@kky42/pievo-server 3.0.0 → 4.2.0

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

@@ -11,114 +11,118 @@ 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-Bi7Bm7v8.js
+var loopTags_Bi7Bm7v8_exports = /* @__PURE__ */ __exportAll$1({
+	$: () => loopIdsWithSnapshots,
+	$t: () => logger_exports,
+	A: () => enqueueRun,
+	At: () => updateMachine,
+	B: () => getRun,
+	Bt: () => loopFileIssue,
+	C: () => buildLoopManifest,
+	Ct: () => setMachineOnline,
+	D: () => createLoop,
+	Dt: () => store_exports,
+	E: () => countRuns,
+	Et: () => stopLoop,
+	F: () => getArtifactFile,
+	Ft: () => LoopFiles,
+	G: () => initializeCronCadence,
+	Gt: () => createBlobStore,
+	H: () => getTerminalReportIncidents,
+	Ht: () => loopFiles_exports,
+	I: () => getExactTerminalReportIncident,
+	It: () => MEMORY_CHAR_CAP,
+	J: () => listLoops,
+	Jt: () => runMigrations,
+	K: () => lastRun,
+	Kt: () => closeClient,
+	L: () => getLoop,
+	Lt: () => MEMORY_FILE,
+	M: () => finalizeRunningRun,
+	Mt: () => ARTIFACT_EXTENSIONS,
+	N: () => forceDeleteLoop,
+	Nt: () => EMPTY_SHA256,
+	O: () => createMachine,
+	Ot: () => tryDeleteLoop,
+	P: () => forceDeleteMachine,
+	Pt: () => LOOP_FILE_BYTE_CAP,
+	Q: () => liveBlobRefs,
+	Qt: () => logger,
+	R: () => getMachine,
+	Rt: () => fileLimitLabel,
+	S: () => blobSizes,
+	St: () => runningRunsForMachine,
+	T: () => countRunSnapshots,
+	Tt: () => startLoop,
+	U: () => hasPendingRun,
+	Ut: () => sha256Buf,
+	V: () => getRunSnapshot,
+	Vt: () => loopFileNames,
+	W: () => hasRunningRun,
+	Wt: () => validArtifactName,
+	X: () => listRuns,
+	Xt: () => CODING_AGENTS,
+	Y: () => listMachines,
+	Yt: () => runs,
+	Z: () => listRunsBefore,
+	Zt: () => coerceCodingAgent,
+	_: () => 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: () => BLOB_GC_GRACE_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,
+	nn: () => __exportAll,
+	nt: () => pauseLoop,
 	o: () => connectKeyValid,
-	ot: () => loopIdsWithSnapshots,
+	ot: () => pruneRunSnapshots,
 	p: () => resolveLease,
-	pt: () => pruneRunSnapshots,
-	q: () => getRun,
-	qt: () => logger,
+	pt: () => reconciliationStatesForRuns,
+	q: () => listArtifacts,
+	qt: () => db,
 	r: () => isValidSemver,
-	rt: () => listRuns,
+	rt: () => pauseLoopState,
 	s: () => isDeviceTokenShape,
-	st: () => loopsForMachine,
+	st: () => putReportReceiptIfAbsent,
 	t: () => validateLoopTags,
-	tt: () => listLoops,
+	tn: () => GC_INTERVAL_MS,
+	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: () => isValidHash
 });
 var import_pino = /* @__PURE__ */ __toESM(require_pino());
 var import_pino_pretty = /* @__PURE__ */ __toESM(require_pino_pretty());
@@ -133,7 +137,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).
@@ -150,9 +154,9 @@ var BLOB_GC_GRACE_MS = 3600 * 1e3;
 /** Storage-maintenance cadence (prune snapshots, then GC blobs). 15 minutes. */
 var GC_INTERVAL_MS = 900 * 1e3;
 /**
-* Uses pino-pretty as a *synchronous* destination stream (not a worker-thread
-* transport) so logs flush before process.exit() in the one-shot CLIs. Writes to
-* stderr (fd 2) to keep stdout clean for QR codes and human CLI output.
+* pino-pretty as a synchronous destination stream (not a worker-thread transport)
+* so logs flush before process.exit() in the one-shot CLIs. Writes to stderr so
+* stdout carries only CLI output.
 */
 var logger_exports = /* @__PURE__ */ __exportAll({ logger: () => logger });
 var level = (process.env.PIEVO_LOG_LEVEL || "info").toLowerCase();
@@ -163,17 +167,9 @@ var stream = (0, import_pino_pretty.default)({
 	ignore: "pid,hostname"
 });
 var logger = (0, import_pino.default)({ level }, stream);
-/** The coding agent a loop is bound to AND executed with (BYOA on the owner's
-*  machine): `claude-code` → Claude Code, `codex` → `codex exec`, `pi` → Pi.
-*  Non-Claude agents may still have thinner daemon telemetry until stream
-*  integration lands; execution itself is real for every value.
-*
-*  Runtime SINGLE SOURCE (anti-drift): every server consumer DERIVES from this
-*  array — the `CodingAgent` type here, the `db/schema.ts` `CodingAgent` type AND
-*  the `loops.agent` column enum, the edit validator (`coerceCodingAgent`), and the
-*  web agent `<select>` (LoopForm). So widening the set is a one-line edit HERE with
-*  no other server change (the daemon's own enum in `packages/daemon/src/create.ts`
-*  is a separate package, widened alongside). */
+/** Single source for coding agents: server types, the `loops.agent` column enum,
+*  validators, and the dashboard select all derive from this array. The daemon
+*  keeps its own copy in `packages/daemon/src/create.ts`; widen both together. */
 var CODING_AGENTS = [
 	"claude-code",
 	"codex",
@@ -193,10 +189,6 @@ var RESERVED_LOOP_TAGS = [
 * Pievo is single-user: no row carries an owner. Timestamp values are ISO
 * strings; JSON columns use `jsonb().$type<>()`.
 */
-/** `skipped`: a pending run retired without executing (pause/retention cleanup,
-*  queue coalescing, or the offline catch-up window elapsed).
-*  Neither success nor failure — excluded from the failure streak (it rides
-*  phase `canceled`, and the streak counts only phase `error`). */
 var machines = pgTable("machines", {
 	id: text("id").primaryKey(),
 	name: text("name").notNull(),
@@ -228,7 +220,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 names, 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(),
@@ -245,11 +238,8 @@ var loops = pgTable("loops", {
 	pauseCause: jsonb("pause_cause").$type(),
 	model: text("model"),
 	reasoningEffort: text("reasoning_effort"),
-	/** Coding agent this loop is BOUND TO and EXECUTED with: the daemon's
-	*  `buildAgentSpawn` branches on this value (`claude-code` → claude,
-	*  `codex` → `codex exec`, `pi` → Pi print mode). Measured from the creating CLI's env when
-	*  detectable, else the declared/selected value. The text column carries
-	*  both a TypeScript enum and a database CHECK constraint. */
+	/** The daemon launches this agent for every run (`buildAgentSpawn`). Enforced by
+	*  both the TypeScript enum and a database CHECK constraint. */
 	agent: text("agent", { enum: CODING_AGENTS }).notNull(),
 	enabled: boolean("enabled").notNull().default(true),
 	nextRunAt: text("next_run_at"),
@@ -277,6 +267,9 @@ var runs = pgTable("runs", {
 	model: text("model"),
 	reasoningEffort: text("reasoning_effort"),
 	runIndex: integer("run_index"),
+	/** A pending run retired without executing (pause, retention cleanup, queue
+	*  coalescing, or an elapsed offline catch-up window) is `canceled`, not `error`,
+	*  so it never counts toward the failure streak. */
 	phase: text("phase", { enum: [
 		"pending",
 		"running",
@@ -296,6 +289,9 @@ var runs = pgTable("runs", {
 		"block"
 	] }),
 	message: text("message"),
+	/** Owner-facing reason from the final response's ATTENTION line. Independent
+	*  of status: it never pauses the loop. */
+	attention: text("attention"),
 	durationMs: integer("duration_ms"),
 	exitCode: integer("exit_code"),
 	finalText: text("final_text"),
@@ -308,7 +304,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 +387,22 @@ 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). */
 	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 +412,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).
@@ -476,7 +477,6 @@ function migrationsDir() {
 	if (fs.existsSync(builtDir)) return builtDir;
 	return devDir;
 }
-/** Apply generated migrations in-process (idempotent). */
 async function runMigrations() {
 	const dir = migrationsDir();
 	if (!fs.existsSync(dir)) return;
@@ -496,16 +496,310 @@ async function closeClient() {
 	} catch {}
 }
 /**
-* Data-access layer over Drizzle. Loop-locked state transitions live here; every
-* DB-touching function is async, while the pure helpers stay sync.
+* 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
+* text/code 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,
+	ARTIFACT_EXTENSIONS: () => ARTIFACT_EXTENSIONS,
+	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;
+/** 256 KB bounds a run's upload and keeps dashboard rendering smooth. */
+var ARTIFACT_BYTE_CAP = 256 * 1024;
+var ARTIFACT_LIMIT_LABEL = `${ARTIFACT_BYTE_CAP / 1024} KB`;
+/** sha256 of zero bytes: the version of a loop file that has never been written. */
+var EMPTY_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+/** Text/code formats accepted as artifacts. Loop files are NUL-free text, so
+*  binary formats (images, PDFs, archives) are deliberately absent; `.svg` is
+*  text and renders through the hardened inline image route. */
+var ARTIFACT_EXTENSIONS = [
+	"md",
+	"markdown",
+	"mdx",
+	"html",
+	"htm",
+	"txt",
+	"text",
+	"rst",
+	"adoc",
+	"org",
+	"sh",
+	"bash",
+	"zsh",
+	"fish",
+	"ps1",
+	"bat",
+	"cmd",
+	"py",
+	"rb",
+	"pl",
+	"lua",
+	"r",
+	"js",
+	"mjs",
+	"cjs",
+	"ts",
+	"tsx",
+	"jsx",
+	"go",
+	"rs",
+	"java",
+	"kt",
+	"kts",
+	"scala",
+	"c",
+	"h",
+	"cc",
+	"cpp",
+	"hpp",
+	"cs",
+	"php",
+	"swift",
+	"dart",
+	"ex",
+	"exs",
+	"erl",
+	"hs",
+	"clj",
+	"cljs",
+	"json",
+	"jsonl",
+	"yaml",
+	"yml",
+	"toml",
+	"xml",
+	"csv",
+	"tsv",
+	"svg",
+	"css",
+	"scss",
+	"sass",
+	"less",
+	"sql",
+	"ini",
+	"conf",
+	"cfg",
+	"env",
+	"properties",
+	"diff",
+	"patch",
+	"tex",
+	"log"
+];
+var ARTIFACT_EXTENSION_SET = new Set(ARTIFACT_EXTENSIONS);
+var ARTIFACT_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}\.([A-Za-z0-9]{1,16})$/;
+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 text/code file name (no directories) other than MEMORY.md. */
+function validArtifactName(name) {
+	if (typeof name !== "string" || name.toLowerCase() === "MEMORY.md".toLowerCase()) return false;
+	const match = ARTIFACT_NAME_RE.exec(name);
+	return match !== null && ARTIFACT_EXTENSION_SET.has(match[1].toLowerCase());
+}
+function loopFileNames(loop) {
+	return [MEMORY_FILE, ...loop.artifacts];
+}
+function fileLimitLabel(name) {
+	return name === "MEMORY.md" ? `${MEMORY_CHAR_CAP} characters` : ARTIFACT_LIMIT_LABEL;
+}
+/** 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 > 262144) return `${name}: ${(bytes.length / 1024).toFixed(1)} KB exceeds the ${ARTIFACT_LIMIT_LABEL} 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. */
 var store_exports = /* @__PURE__ */ __exportAll({
 	TERMINAL_REPORT_GRACE_MS: () => TERMINAL_REPORT_GRACE_MS,
 	acknowledgeRetiredReport: () => acknowledgeRetiredReport,
 	acknowledgeRetiredTerminalIncident: () => acknowledgeRetiredTerminalIncident,
 	advanceDueSchedules: () => advanceDueSchedules,
 	artifactFileReferencesHash: () => artifactFileReferencesHash,
-	blobExists: () => blobExists,
 	blobHashesOlderThan: () => blobHashesOlderThan,
 	blobSizes: () => blobSizes,
 	buildLoopManifest: () => buildLoopManifest,
@@ -540,24 +834,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 +866,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 +989,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 +1332,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 +1372,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 +1507,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 +1572,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 +1823,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 +1840,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 +1863,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 +1906,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,103 +1996,16 @@ 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
-* LEASE (`rk_…`) is minted per delivery, bound to one run, and carries the
-* run's least-privilege caps — the CLI dispatch authorizes the `pievo` shim
-* against it. Its lifecycle is a small state machine (`active` →
-* `terminal-grace` → `reconciliation-only`/`retired`), not a mint→revoke pair;
-* see `RunLease` below.
+* Machine and run credentials. A device token (`dk_…`) identifies a machine whose
+* id is derived from it (`m-sha256(token)[:16]`). A run lease (`rk_…`) is minted per
+* delivery and authorizes only that run's loop-file transfer and terminal report;
+* its lifecycle is the state machine on `RunLease`.
 *
-* Leases and connect-key bindings are DURABLE (run_leases / connect_keys
-* tables): they must survive a deploy, or every restart 401s the in-flight
-* runs' callbacks/finalize and prevents a freshly connected machine from
-* enrolling. The 15-minute `new` idempotency window stays in-process;
-* losing it only degrades retry deduplication, never persisted data.
+* Leases and connect-key bindings are durable so a restart neither rejects
+* in-flight reports nor blocks a just-connected machine from enrolling. The
+* 15-minute `new` idempotency window stays in memory; losing it on restart only
+* weakens retry deduplication.
 */
 var tokens_exports = /* @__PURE__ */ __exportAll({
 	CONNECT_KEY_TTL_MS: () => CONNECT_KEY_TTL_MS,
@@ -2067,8 +2268,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-CecCDRoH.js
+var boot_CecCDRoH_exports = /* @__PURE__ */ __exportAll$1({
 	_: () => validOptionalPollString,
 	a: () => POLL_HTTP_BODY_FIELDS,
 	c: () => MIN_DAEMON_VERSION,
@@ -2082,24 +2283,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. */
@@ -2164,208 +2352,116 @@ async function readJsonBody(request, maxBytes) {
 	} 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));
+}
+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();
+}
+/** Postgres text/jsonb columns reject NUL, so a daemon-supplied string carrying
+*  one would fail mid-finalize. The single sanitizer behind `clipText` and `cli.ts`. */
+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;
+var ATTENTION_LINE_RE = /^ATTENTION:\s*(.*)$/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 long-term experience (max ${MEMORY_CHAR_CAP} characters). Read it first and follow it. Before finishing, record only lessons this run learned the hard way that make later runs faster or safer: a pitfall hit, a workaround found, an environment fact discovered. One line each; correct or delete lessons that proved wrong. Never restate the task or these instructions, and never store state, results, baselines, trends, or run logs (those go in an artifact). Most runs add nothing.`, ...loop.artifacts.map((name) => `- ${name}: artifact shown on the Pievo dashboard (max ${fileLimitLabel(name)}). 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}
+A block pauses the loop until the owner restarts it.
+
+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}
+
+Be concise in everything you write: lead with what changed or needs action; prefer tables and short lists; no filler or restated instructions.
+
+Your final response is only: a summary of at most five short lines (no headings, no repeated tables or file contents); if the owner should look at something, one line \`ATTENTION: <reason>\`; then exactly one last line:
+STATUS: keep|no-change|block`;
+}
+var bareLine = (line) => line.trim().replace(/^[*_`>\s]+|[*_`\s]+$/g, "");
+/**
+* Split a provider's final response into the reported status, an optional
+* attention reason from the ATTENTION lines just above it, and the summary. The final
+* non-empty line must be the status line; markdown emphasis or code ticks around
+* either line 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 match = STATUS_LINE_RE.exec(bareLine(lines[index]));
+	if (!match) return void 0;
+	const status = match[1].toLowerCase();
+	const reasons = [];
+	let end = index;
+	for (;;) {
+		let previous = end;
+		while (previous > 0 && lines[previous - 1].trim() === "") previous--;
+		const attentionMatch = previous > 0 ? ATTENTION_LINE_RE.exec(bareLine(lines[previous - 1])) : null;
+		if (!attentionMatch) break;
+		end = previous - 1;
+		const reason = attentionMatch[1].trim();
+		if (reason && !/^(none|n\/a|-)$/i.test(reason)) reasons.unshift(reason);
 	}
-};
-/** 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;
+	const joined = reasons.join("; ");
+	const attention = joined ? joined.length > 200 ? `${joined.slice(0, 199)}…` : joined : null;
+	return {
+		status,
+		message: lines.slice(0, end).join("\n").trim(),
+		attention
+	};
+}
+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)
+	};
 }
 /**
-* Artifact-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 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:
-*
-*   1. pruneSnapshots() — bound the per-loop run-snapshot history to a window, so
-*      old snapshots stop pinning the blobs they referenced for diffs.
-*   2. gcBlobs()        — delete blob bytes no LIVE row needs: a blob is collected
-*      only when NO artifact_files row AND NO retained run_snapshot references its
-*      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
-* 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
-* delete) re-uploads the bytes (self-healing). We never leave a live blobs row
-* pointing at deleted bytes.
+* Loop-file storage retention. Blob bytes are content-addressed and shared, so
+* replacing a file never frees its old blob by itself. pruneSnapshots() bounds
+* per-loop snapshot history; gcBlobs() then deletes bytes no file row and no
+* retained snapshot references. Correctness wins over aggressiveness: a leaked
+* blob is a storage cost the next pass reclaims, a deleted live blob is data loss.
 */
-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
@@ -2377,28 +2473,14 @@ async function pruneSnapshots(keep = 20) {
 	return pruned;
 }
 /**
-* Reclaim unreferenced blob bytes. Returns the number of blobs collected.
-*
-* Algorithm:
-*   1. Compute the live keep-set (all hashes any artifact_files row / retained
-*      snapshot references) and the grace-windowed candidate list — both reads are
-*      synchronous (interleave-free under the single-threaded event loop).
-*   2. Garbage = candidates not in the keep-set.
-*   3. For each garbage hash, in order:
-*      a. Pre-delete guard: if a sync re-referenced it since the keep-set was
-*         computed, skip it — leaving both its bytes AND metadata row intact
-*         (a consistent live blob, nothing to heal). The guard is two O(1) checks:
-*         an indexed artifact_files point query (always fresh) plus membership in a
-*         snapshot-hash Set deserialized ONCE per pass and rebuilt only when the
-*         snapshot row count changes (a report() raced us) — never the old
-*         per-candidate full snapshot scan (which was O(garbage × snapshots), since
-*         genuine garbage always misses the file check and fell through to it).
-*      b. Otherwise delete the BYTES (the await), then drop the metadata row
-*         UNCONDITIONALLY. Bytes-before-metadata is the data-loss fix: if a sync
-*         raced the byte delete (re-referencing the hash + recreating the blobs
-*         row mid-await), dropping the metadata still leaves blobExists()=false,
-*         so that file re-uploads its bytes on the next sync. We never leave a
-*         live blobs row pointing at deleted bytes.
+* Reclaim unreferenced blob bytes; returns the number collected. Safe alongside
+* owner writes and run uploads because of three guards:
+*  - grace window: blobs whose metadata row is younger than `graceMs` are skipped;
+*  - per-candidate re-check right before deletion: an indexed file-row lookup plus
+*    a snapshot-hash set rebuilt only when the snapshot count changes (a concurrent
+*    report), instead of an O(garbage x snapshots) scan;
+*  - bytes before metadata: the metadata row is dropped after the bytes even if a
+*    writer raced the delete, so blobExists() is false and that writer re-uploads.
 */
 async function gcBlobs(blobStore, graceMs = BLOB_GC_GRACE_MS) {
 	const refs = await liveBlobRefs();
@@ -2418,7 +2500,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 +2511,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 +2846,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 text/code file name other than ${MEMORY_FILE} (supported extensions: ${ARTIFACT_EXTENSIONS.join(", ")}; 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 +2961,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 +3056,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 +3092,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;
@@ -3050,23 +3125,18 @@ var validPollWireId = (value) => typeof value === "string" && value.length <= 20
 var validPollCurrentRun = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 2 && Object.prototype.hasOwnProperty.call(value, "runId") && Object.prototype.hasOwnProperty.call(value, "stage") && validPollWireId(value.runId) && (value.stage === "executing" || value.stage === "reporting");
 var validPollInfo = (value) => value === void 0 || value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).every((key) => POLL_INFO_FIELDS.has(key)) && validOptionalPollString(value.host, 524288) && validOptionalPollString(value.platform, 524288) && validOptionalPollString(value.arch, 524288) && validOptionalPollString(value.version, 64);
 /**
-* Machine gateway - the run-lifecycle core of the HTTP surface the daemon talks
-* to (poll transport: short-poll while a run is in flight, opt-in server-held
-* long-poll while idle). Framework-agnostic like the rest of the gateway
-* (return `{ status, body }` so the methods can be mounted on a plain http
-* server or TanStack server routes):
+* Machine gateway: the run-lifecycle core the daemon talks to. Methods return
+* transport-free `{ status, body }` results for the thin route shells:
 *
-*   POST /api/machine/poll   (Bearer device token) → claim pending runs, deliver
-*   POST /machine/report     (Bearer run token)    → finalize a run
+*   POST /api/machine/poll                (device token) claim and deliver runs
+*   POST /machine/report                  (run token)    finalize a run
+*   GET|PUT /api/machine/run-files/:name  (run token)    loop-file transfer
 *
-* plus owner create/list/edit methods and retention.
-* Also exposes `dispatcher` (a `Dispatcher` for the Scheduler: "is the machine
-* online?") and `sweep()` (mark stale machines offline, reclaim stuck runs).
-* CLI verb dispatch at `/api/machine/cli` lives in `gateway/cli.ts`
-* (`CliGateway`), which reuses this class's owner methods;
-* canonical loop configuration validation lives in `gateway/loopConfig.ts`.
+* Idle polls may be held open (long-poll) until the scheduler's dispatcher wakes
+* them. `sweep()` marks stale machines offline and reclaims silent runs. CLI verbs
+* live in `cli.ts`; loop config validation lives in `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 +3151,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 +3174,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 +3183,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 +3222,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 +3250,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 +3284,37 @@ 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,
+			attention: parsed.attention,
+			error: null
+		}
+	};
 }
 function validateTerminalReport(body) {
 	const issues = [];
@@ -3227,6 +3334,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 +3393,9 @@ var MachineGateway = class {
 	constructor(scheduler, blobStore = createBlobStore()) {
 		this.scheduler = scheduler;
 		this.blobStore = blobStore;
+		this.loopFiles = new LoopFiles(blobStore);
 	}
+	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 +3403,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");
@@ -3344,20 +3472,12 @@ var MachineGateway = class {
 		await pruneExpiredLeases(now);
 		for (const loop of await listLoops()) if (loop.deleteRequestedAt) await tryDeleteLoop(loop.id);
 	}
-	/** Finalize one stuck run as an error (the sweep's reclaim path): persist the
-	*  failure, TERMINALIZE its run lease (flip it to `terminal-grace` rather than
-	*  retiring it outright), while preserving a bounded reconciliation window.
-	*
-	*  Why terminalize, not retire: the usual cause is a laptop that merely fell
-	*  ASLEEP mid-run. When it wakes, claude finishes and the daemon delivers the real
-	*  (often SUCCESSFUL) result. Retiring the lease here would 401 that late report
-	*  and strand the run as a permanent false failure with its message lost (the
-	*  investigated bug). So the lease survives a bounded grace window
-	*  (`TERMINAL_GRACE_MS`) during which exactly ONE late wake-report may reconcile
-	*  the run — see `report()`'s terminal-grace branch. The credential is still
-	*  bounded: CLI mutations are refused while terminal-grace, and the
-	*  reconciliation retires the lease single-shot. Pending rows are durable inbox
-	*  entries and are never reclaimed by this path. */
+	/** Reclaim one silent running run as an error, but terminalize its lease instead
+	*  of retiring it. The usual cause is a laptop that fell asleep mid-run; on wake
+	*  the daemon delivers the real (often successful) result, and a retired lease
+	*  would 401 it and leave a false failure. During TERMINAL_GRACE_MS exactly one
+	*  late report may reconcile the run (see `report()`); CLI mutations stay refused.
+	*  Pending rows are durable queue entries and never reach this path. */
 	async reclaimRun(run, reason) {
 		if (run.phase !== "running") return;
 		const at = nowIso();
@@ -3371,13 +3491,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 +3508,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 +3534,7 @@ var MachineGateway = class {
 				token: deviceToken,
 				online: true
 			});
-			log$2.info({
+			log$1.info({
 				machineId,
 				host: info?.host
 			}, "poll: self-registered machine");
@@ -3445,7 +3566,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 +3584,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 +3596,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 +3628,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 +3645,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;
@@ -3542,11 +3663,8 @@ var MachineGateway = class {
 			waiter.cancel();
 		}
 	}
-	/**
-	* Whether this machine (by device token) currently has a live daemon — so
-	* Claude Code can avoid starting a duplicate. `online` is fresh-checked against
-	* the poll TTL, not just the stored flag.
-	*/
+	/** Whether this machine has a live daemon. `online` is fresh-checked against the
+	*  poll TTL, not just the stored flag. */
 	async status(deviceToken) {
 		const auth = await authenticateDeviceToken(deviceToken, { allowUnknown: true });
 		if (!auth.ok) return auth.response;
@@ -3632,7 +3750,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 +3964,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 +3988,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 +4001,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 +4112,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 +4122,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 +4138,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 +4191,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 +4245,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 +4256,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 +4278,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 +4392,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 +4415,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 +4428,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) {
@@ -4663,6 +4725,7 @@ function normalizedListRun(run) {
 		terminalAt: run.ts,
 		phase: run.phase,
 		status: run.status ?? null,
+		attention: run.attention ?? null,
 		durationMs: run.durationMs ?? null,
 		tokenUsage: totalTokenUsage(run.usage ?? null),
 		message: message.value,
@@ -4717,6 +4780,7 @@ async function listHistory(loop, q) {
 		"terminal",
 		"phase",
 		"status",
+		"attention",
 		"durationMs",
 		"tokenUsage",
 		"message",
@@ -4726,6 +4790,7 @@ async function listHistory(loop, q) {
 		fmt(run.ts),
 		run.phase,
 		run.status ?? null,
+		run.attention ?? null,
 		run.durationMs ?? null,
 		totalTokenUsage(run.usage ?? null),
 		run.message ? truncate(run.message, 500, "use --run for detail").value : null,
@@ -4773,6 +4838,7 @@ async function detailHistory(loop, q) {
 		terminalAt: TERMINAL_PHASES.includes(run.phase) ? run.ts : null,
 		phase: run.phase,
 		status: run.status ?? null,
+		attention: run.attention ?? null,
 		durationMs: run.durationMs ?? null,
 		tokenUsage: totalTokenUsage(run.usage ?? null),
 		message: message.value,
@@ -4781,6 +4847,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,
@@ -4798,6 +4865,7 @@ async function detailHistory(loop, q) {
 		["terminalAt", detail.terminalAt],
 		["phase", detail.phase],
 		["status", detail.status],
+		["attention", detail.attention],
 		["durationMs", detail.durationMs],
 		["tokenUsage", detail.tokenUsage],
 		["message", detail.message],
@@ -4806,6 +4874,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) }]
 	]));
@@ -4820,18 +4889,10 @@ async function readLoopHistory(loop, flags) {
 	return parsed.value.mode === "detail" ? detailHistory(loop, parsed.value) : listHistory(loop, parsed.value);
 }
 /**
-* CLI dispatch - the credential-keyed verb router half of the machine gateway,
-* split out of `MachineGateway` (which keeps poll/report/sweep/owner verbs).
-* Same wire surface, framework-agnostic like the rest of the gateway
-* (`{ status, body }` results):
-*
-*   POST /api/machine/cli  (Bearer device OR run credential) → unified dispatch
-*
-* 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.
+* `/api/machine/cli` verb router. Authority keys on credential type: a device
+* (`dk_`) token gets owner verbs over loops bound to its machine, reusing
+* `MachineGateway`'s owner methods; a run (`rk_`) token gets no verb, because a
+* run reports only through its final response.
 */
 var cliLog = logger.child({ mod: "cli" });
 var CliGateway = class {
@@ -4845,15 +4906,6 @@ var CliGateway = class {
 		this.forceDeleteLoop = deps.forceDeleteLoop ?? forceDeleteLoop;
 		this.destructiveLog = deps.destructiveLog ?? ((event) => cliLog.warn(event, "force-delete: destructive server authority removal"));
 	}
-	/**
-	* The unified CLI endpoint. It is a ROUTER in front of the gateway logic that
-	* 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.
-	*/
 	async cli(token, argv) {
 		return finalizeCli(token.startsWith("dk_") ? await this.deviceCli(token, argv) : await this.runCli(token, argv));
 	}
@@ -4943,13 +4995,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 +5047,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 +5158,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 (verb !== "report") return derr(403, "run credentials authorize only pievo report", "FORBIDDEN");
-		if (flags.help === true) return {
-			code: 200,
-			text: verbHelpText("report", lease)
+		if (!loop) return {
+			status: 404,
+			body: { error: "no such loop on this machine" }
 		};
-		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"
+		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 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 (!name || !names.includes(name)) return {
+			status: 404,
+			body: { error: `no such loop file: ${name ?? ""} (files: ${names.join(", ")})` }
 		};
-		if (result.state === "missing-loop") return {
-			ok: false,
-			detail: "loop not found",
-			code: "NOT_FOUND",
-			status: 404
+		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 === "already-reported") return {
-			ok: false,
-			detail: "this run already reported",
-			code: "CONFLICT",
-			status: 409
+		const bytes = Buffer.from(encoded, "base64");
+		const issue = loopFileIssue(name, bytes);
+		if (issue) return {
+			status: 413,
+			body: { error: `${issue}; nothing was changed` }
+		};
+		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 +5286,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 +5325,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 +5352,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 +5390,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 +5449,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 +5538,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. */
@@ -5677,19 +5668,13 @@ var Scheduler = class {
 function msg(err) {
 	return err instanceof Error ? err.message : String(err);
 }
-/**
-* Server boot — idempotent one-time init of the in-process backend: apply
-* migrations, wire the machine gateway's dispatcher into the Scheduler, start
-* the Scheduler + an offline-sweep interval. Guarded on `globalThis` so it
-* survives dev HMR and runs at most once per process. Call `ensureServer()`
-* from any server-side entry (the standalone machine server / TanStack server
-* fns); the first call boots, the rest share the same instance.
-*/
+/** One-time, idempotent in-process backend boot (migrations, scheduler, sweep and
+* storage-maintenance intervals). Guarded on `globalThis` to survive dev HMR. */
 var boot_exports = /* @__PURE__ */ __exportAll({
 	ensureServer: () => ensureServer,
-	getArtifactSync: () => getArtifactSync,
 	getCliGateway: () => getCliGateway,
-	getGateway: () => getGateway
+	getGateway: () => getGateway,
+	getLoopFiles: () => getLoopFiles
 });
 var g = globalThis;
 function ensureServer() {
@@ -5714,9 +5699,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 +5712,6 @@ async function boot() {
 	return {
 		scheduler,
 		gateway,
-		artifactSync,
 		cliGateway,
 		abort,
 		shutdown
@@ -5738,11 +5720,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, reconciliationStatesForRuns as B, getRun as C, listArtifacts as D, isOutdated as E, machineIdFromToken as F, stopLoop as G, requestRunCancel as H, machinePresence as I, updateMachine as J, tryDeleteLoop as K, mintDeviceToken as L, loopFileNames as M, loopTags_Bi7Bm7v8_exports as N, listLoops as O, loopsForMachine as P, pauseLoop as R, getMachine as S, hasRunningRun as T, sha256 as U, requestDeleteLoop as V, startLoop as W, validateLoopTags as Y, 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, updateLoop as q, boot_CecCDRoH_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, recentLoopUsage as z };