@kky42/pievo-server 2.4.14 → 4.1.0

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

@@ -1,45 +1,2228 @@
-import { r as __exportAll } from "../_runtime.mjs";
-import { _ as isNotNull, d as and, f as eq, g as inArray, j as sql, m as gte, u as desc, x as lte } from "../_libs/drizzle-orm+postgres.mjs";
+import { o as __toESM, r as __exportAll$1 } from "../_runtime.mjs";
+import { t as Ve } from "../_libs/electric-sql__pglite.mjs";
+import { C as integer, S as jsonb, T as sql, _ as notInArray, a as asc, b as timestamp, c as eq, d as inArray, f as isNotNull, g as ne, h as lte, i as check, l as gt, m as lt, n as index, o as desc, p as isNull, r as uniqueIndex, s as and, t as drizzle, u as gte, v as or, w as boolean, x as text, y as pgTable } from "../_libs/drizzle-orm.mjs";
 import { t as E } from "../_libs/croner.mjs";
-import { $ as getLoop, $t as reclaimRun, A as createLoop, An as updateLoop, At as logger, B as enqueueRun, Bt as parseArtifactSyncBody, C as claimReadyRunForMachine, Cn as sha256Buf, Ct as listLoops, D as countRuns, Dn as stopLoop, Dt as listRuns, E as countRunSnapshots, En as startLoop, F as dbWatchdogFailureThreshold, Ft as machinePresence, Gt as pruneRunSnapshots, H as expirePendingRun, Ht as pauseLoopState, I as dbWatchdogIntervalMs, It as machineReferencesBlob, Jt as putTerminalReportIncidentIfAbsent, K as gcIntervalMs, Kt as putReportReceiptIfAbsent, L as dbWatchdogTimeoutMs, M as dataDir, Mn as upsertConfiguredArtifactFile, Mt as loopIdsWithSnapshots, N as db, Nn as validateLoopTags, Nt as loopsForMachine, P as dbWatchdogEnabled, Pt as machineIdFromToken, Sn as sha256, T as coerceCodingAgent, Tn as snapshotRetention, Tt as listMachines, U as finalizeRunningRun, Ut as prevRunSnapshot, W as forceDeleteLoop, Wt as pruneExpiredLeases, Xt as readConnectKeyBinding, Yt as r2Config, Z as getExactTerminalReportIncident, Zt as readNewIdempotency, _ as blobExists, _n as runningRunForLoop, an as recordRunReportOnce, at as getRunSnapshot, b as blobSizes, cn as releaseAbsentReconciliations, dn as requestDeleteLoop, dt as isDeviceTokenShape, en as reconcileConfiguredArtifacts, et as getMachine, f as acknowledgeRetiredReport, fn as requestRunCancel, gn as runMigrations, h as artifactFileReferencesHash, hn as retireLease, in as recordNewIdempotency, it as getRun, j as createMachine, jn as updateMachine, jt as loginGateEnabled, kn as tryDeleteLoop, kt as liveBlobRefs, lt as initializeCronCadence, m as advanceDueSchedules, mn as resolveLease, on as refreshRunHeartbeats, ot as getTerminalReportIncidents, p as acknowledgeRetiredTerminalIncident, pt as isOutdated, qt as putRunSnapshot, rn as recordBlob, rt as getReportReceipt, s as CODING_AGENTS, sn as rejectTerminalReport, tn as reconcileReclaimedRun, u as TERMINAL_GRACE_MS, un as repairTerminalRunLeases, v as blobGcGraceMs, vn as runningRunsForMachine, vt as isValidHash, w as closeClient, wn as snapshotBlobRefs, x as buildLoopManifest, xn as setMachineOnline, xt as lastRun, y as blobHashesOlderThan, yn as runs, yt as isValidSemver, z as deleteBlob, zt as openRuns } from "./loopTags-CXx5UdGf.mjs";
-import { i as __exportAll$1 } from "./factory-ixUjZqJn.mjs";
+import { t as require_pino } from "../_libs/pino+[...].mjs";
+import { t as require_pino_pretty } from "../_libs/pino-pretty+[...].mjs";
 import { t as createTwoFilesPatch } from "../_libs/diff.mjs";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import fs from "node:fs";
+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/boot-C472kLwY.js
-var boot_C472kLwY_exports = /* @__PURE__ */ __exportAll({
+//#region node_modules/.nitro/vite/services/ssr/assets/loopTags-CnVLi70h.js
+var loopTags_CnVLi70h_exports = /* @__PURE__ */ __exportAll$1({
+	$: () => loopIdsWithSnapshots,
+	$t: () => BLOB_GC_GRACE_MS,
+	A: () => enqueueRun,
+	At: () => updateMachine,
+	B: () => getRun,
+	Bt: () => loopFileNames,
+	C: () => buildLoopManifest,
+	Ct: () => setMachineOnline,
+	D: () => createLoop,
+	Dt: () => store_exports,
+	E: () => countRuns,
+	Et: () => stopLoop,
+	F: () => getArtifactFile,
+	Ft: () => MEMORY_CHAR_CAP,
+	G: () => initializeCronCadence,
+	Gt: () => closeClient,
+	H: () => getTerminalReportIncidents,
+	Ht: () => sha256Buf,
+	I: () => getExactTerminalReportIncident,
+	It: () => MEMORY_FILE,
+	J: () => listLoops,
+	Jt: () => runs,
+	K: () => lastRun,
+	Kt: () => db,
+	L: () => getLoop,
+	Lt: () => fileLimitLabel,
+	M: () => finalizeRunningRun,
+	Mt: () => EMPTY_SHA256,
+	N: () => forceDeleteLoop,
+	Nt: () => LOOP_FILE_BYTE_CAP,
+	O: () => createMachine,
+	Ot: () => tryDeleteLoop,
+	P: () => forceDeleteMachine,
+	Pt: () => LoopFiles,
+	Q: () => liveBlobRefs,
+	Qt: () => logger_exports,
+	R: () => getMachine,
+	Rt: () => isValidHash,
+	S: () => blobSizes,
+	St: () => runningRunsForMachine,
+	T: () => countRunSnapshots,
+	Tt: () => startLoop,
+	U: () => hasPendingRun,
+	Ut: () => validArtifactName,
+	V: () => getRunSnapshot,
+	Vt: () => loopFiles_exports,
+	W: () => hasRunningRun,
+	Wt: () => createBlobStore,
+	X: () => listRuns,
+	Xt: () => coerceCodingAgent,
+	Y: () => listMachines,
+	Yt: () => CODING_AGENTS,
+	Z: () => listRunsBefore,
+	Zt: () => logger,
+	_: () => acknowledgeRetiredReport,
+	_t: () => releaseAbsentReconciliations,
+	a: () => TERMINAL_GRACE_MS,
+	at: () => previousRunFileNotices,
+	b: () => artifactFileReferencesHash,
+	bt: () => requestRunCancel,
+	c: () => machineIdFromToken,
+	ct: () => putRunSnapshot,
+	d: () => readNewIdempotency,
+	dt: () => reclaimRun,
+	en: () => GC_INTERVAL_MS,
+	et: () => loopsForMachine,
+	f: () => recordNewIdempotency,
+	ft: () => reconcileReclaimedRun,
+	g: () => tokens_exports,
+	gt: () => rejectTerminalReport,
+	h: () => sha256,
+	ht: () => refreshRunHeartbeats,
+	i: () => machinePresence,
+	it: () => prevRunSnapshot,
+	j: () => expirePendingRun,
+	jt: () => writeLoopFile,
+	k: () => deleteBlob,
+	kt: () => updateLoop,
+	l: () => mintDeviceToken,
+	lt: () => putTerminalReportIncidentIfAbsent,
+	m: () => retireLease,
+	mt: () => recordBlob,
+	n: () => isOutdated,
+	nt: () => pauseLoop,
+	o: () => connectKeyValid,
+	ot: () => pruneRunSnapshots,
+	p: () => resolveLease,
+	pt: () => reconciliationStatesForRuns,
+	q: () => listArtifacts,
+	qt: () => runMigrations,
+	r: () => isValidSemver,
+	rt: () => pauseLoopState,
+	s: () => isDeviceTokenShape,
+	st: () => putReportReceiptIfAbsent,
+	t: () => validateLoopTags,
+	tn: () => __exportAll,
+	tt: () => openRuns,
+	u: () => pruneExpiredLeases,
+	ut: () => recentLoopUsage,
+	v: () => acknowledgeRetiredTerminalIncident,
+	vt: () => repairTerminalRunLeases,
+	w: () => claimReadyRunForMachine,
+	wt: () => snapshotBlobRefs,
+	x: () => blobHashesOlderThan,
+	xt: () => runningRunForLoop,
+	y: () => advanceDueSchedules,
+	yt: () => requestDeleteLoop,
+	z: () => getReportReceipt,
+	zt: () => loopFileIssue
+});
+var import_pino = /* @__PURE__ */ __toESM(require_pino());
+var import_pino_pretty = /* @__PURE__ */ __toESM(require_pino_pretty());
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+/**
+* 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).
+*/
+function dataDir() {
+	return process.env.PIEVO_DATA_DIR?.trim() || path.join(os.homedir(), ".pievo-server");
+}
+/**
+* A blob whose metadata row is younger than this is never collected, so a
+* sync that just wrote a blob can still reference it. A leaked blob is only a
+* storage cost that the next pass reclaims. 1 hour.
+*/
+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.
+*/
+var logger_exports = /* @__PURE__ */ __exportAll({ logger: () => logger });
+var level = (process.env.PIEVO_LOG_LEVEL || "info").toLowerCase();
+var stream = (0, import_pino_pretty.default)({
+	destination: 2,
+	colorize: true,
+	translateTime: "SYS:HH:MM:ss",
+	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). */
+var CODING_AGENTS = [
+	"claude-code",
+	"codex",
+	"pi"
+];
+function coerceCodingAgent(value) {
+	return typeof value === "string" && CODING_AGENTS.includes(value) ? value : null;
+}
+var RESERVED_LOOP_TAGS = [
+	"all loops",
+	"active",
+	"paused",
+	"blocked"
+];
+/**
+* Pievo schema (Drizzle, Postgres `pg-core` dialect, served by embedded PGlite).
+* 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(),
+	hostname: text("hostname"),
+	platform: text("platform"),
+	arch: text("arch"),
+	daemonVersion: text("daemon_version"),
+	/** Breaking machine protocol last observed on poll. */
+	daemonProtocol: integer("daemon_protocol"),
+	tokenHash: text("token_hash").notNull(),
+	/**
+	* Plaintext device token. Stored so the UI can re-show the connect command
+	* anytime (MVP convenience — deviates from "store only the hash"; acceptable
+	* for a self-hosted control plane where the DB is already the trust root).
+	*/
+	token: text("token"),
+	roots: jsonb("roots").$type(),
+	lastSeen: text("last_seen"),
+	online: boolean("online").notNull().default(false),
+	createdAt: text("created_at").notNull()
+});
+var loops = pgTable("loops", {
+	id: text("id").primaryKey(),
+	/** Execution machine (set at creation; no cross-machine fallback). */
+	machineId: text("machine_id").notNull(),
+	name: text("name").notNull(),
+	tags: text("tags").array().notNull().default(sql`ARRAY[]::text[]`),
+	prompt: text("prompt").notNull(),
+	statusKeep: text("status_keep").notNull(),
+	statusNoChange: text("status_no_change").notNull(),
+	statusBlock: text("status_block").notNull(),
+	/** Configured artifact file names (`.md`/`.html`), in addition to the
+	*  always-present MEMORY.md. See `gateway/loopFiles.ts`. */
+	artifacts: jsonb("artifacts").$type().notNull().default([]),
+	cron: text("cron").notNull(),
+	scheduleMode: text("schedule_mode", { enum: ["cron", "continuous"] }).notNull(),
+	/** Cron-only overlap behavior. Continuous runs never overlap. */
+	cronOverlap: text("cron_overlap", { enum: ["skip", "queue-one"] }).notNull(),
+	continuousDelayMinutes: integer("continuous_delay_minutes").notNull(),
+	timezone: text("timezone"),
+	workdir: text("workdir").notNull(),
+	/** Durable Stop-before-delete marker. A deleting loop is never claimable. */
+	deleteRequestedAt: timestamp("delete_requested_at", {
+		withTimezone: true,
+		mode: "string"
+	}),
+	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. */
+	agent: text("agent", { enum: CODING_AGENTS }).notNull(),
+	enabled: boolean("enabled").notNull().default(true),
+	nextRunAt: text("next_run_at"),
+	/** The next recurring cadence occurrence not yet materialized as a run. Cron
+	* advances this fact after each due occurrence; continuous clears it on due
+	* and restores it from a successful/error terminal. */
+	nextCadenceAt: text("next_cadence_at"),
+	lastRunIndex: integer("last_run_index").notNull().default(0),
+	createdAt: text("created_at").notNull(),
+	updatedAt: text("updated_at").notNull()
+}, (t) => [
+	index("loops_machine_idx").on(t.machineId),
+	index("delete_requested_loops").on(t.deleteRequestedAt).where(sql`${t.deleteRequestedAt} IS NOT NULL`),
+	check("loops_agent_check", sql`${t.agent} IN ('claude-code', 'codex', 'pi')`),
+	check("loops_tags_count_check", sql`cardinality(${t.tags}) <= 4`),
+	check("loops_tags_reserved_check", sql`NOT (${t.tags} && ARRAY['all loops', 'active', 'paused', 'blocked']::text[])`),
+	check("loops_schedule_mode_check", sql`${t.scheduleMode} IN ('cron', 'continuous')`),
+	check("loops_cron_overlap_check", sql`${t.cronOverlap} IN ('skip', 'queue-one')`)
+]);
+var runs = pgTable("runs", {
+	id: text("id").primaryKey(),
+	loopId: text("loop_id").notNull(),
+	machineId: text("machine_id").notNull(),
+	agent: text("agent", { enum: CODING_AGENTS }),
+	model: text("model"),
+	reasoningEffort: text("reasoning_effort"),
+	runIndex: integer("run_index"),
+	phase: text("phase", { enum: [
+		"pending",
+		"running",
+		"done",
+		"error",
+		"canceled"
+	] }).notNull(),
+	/** Durable queue authority. It only promotes system→owner; diagnostic trigger
+	* reasons, if added later, must never drive lifecycle state. */
+	requestedBy: text("requested_by", { enum: ["owner", "system"] }).notNull().default("system"),
+	ts: text("ts").notNull(),
+	createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP::text`),
+	updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP::text`),
+	status: text("status", { enum: [
+		"keep",
+		"no-change",
+		"block"
+	] }),
+	message: text("message"),
+	durationMs: integer("duration_ms"),
+	exitCode: integer("exit_code"),
+	finalText: text("final_text"),
+	error: text("error"),
+	sessionId: text("session_id"),
+	usage: jsonb("usage").$type(),
+	/** Monotonic cancellation intent. Running becomes canceled only on daemon report. */
+	cancelRequestedAt: timestamp("cancel_requested_at", {
+		withTimezone: true,
+		mode: "string"
+	}),
+	heartbeatAt: text("heartbeat_at"),
+	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),
+	index("runs_machine_phase_ready_idx").on(t.machineId, t.phase),
+	index("runs_loop_ts_idx").on(t.loopId, t.ts),
+	uniqueIndex("runs_loop_run_index_idx").on(t.loopId, t.runIndex).where(sql`${t.runIndex} IS NOT NULL`),
+	index("runs_loop_terminal_history_idx").on(t.loopId, t.runIndex).where(sql`${t.runIndex} IS NOT NULL AND ${t.phase} IN ('done', 'error', 'canceled')`),
+	uniqueIndex("runs_loop_pending_idx").on(t.loopId).where(sql`${t.phase} = 'pending'`),
+	uniqueIndex("one_running_run_per_loop").on(t.loopId).where(sql`${t.phase} = 'running'`),
+	check("runs_agent_check", sql`${t.agent} IS NULL OR ${t.agent} IN ('claude-code', 'codex', 'pi')`),
+	check("runs_phase_check", sql`${t.phase} IN ('pending', 'running', 'done', 'error', 'canceled')`),
+	check("runs_requested_by_check", sql`${t.requestedBy} IN ('owner', 'system')`),
+	check("runs_status_check", sql`${t.status} IS NULL OR ${t.status} IN ('keep', 'no-change', 'block')`)
+]);
+var runLeases = pgTable("run_leases", {
+	tokenHash: text("token_hash").primaryKey(),
+	runId: text("run_id").notNull(),
+	loopId: text("loop_id").notNull(),
+	machineId: text("machine_id").notNull(),
+	state: text("state", { enum: [
+		"active",
+		"terminal-grace",
+		"reconciliation-only",
+		"retired"
+	] }).notNull().default("active"),
+	/** Null while active/retired; ISO only during terminal-grace. */
+	expiresAt: text("expires_at"),
+	createdAt: text("created_at").notNull()
+}, (t) => [
+	index("run_leases_run_idx").on(t.runId),
+	index("run_leases_loop_idx").on(t.loopId),
+	check("run_leases_state_check", sql`${t.state} IN ('active', 'terminal-grace', 'reconciliation-only', 'retired')`)
+]);
+var runReportReceipts = pgTable("run_report_receipts", {
+	reportId: text("report_id").primaryKey(),
+	runId: text("run_id").notNull(),
+	payloadDigest: text("payload_digest").notNull(),
+	ackStatus: integer("ack_status").notNull(),
+	ackBody: jsonb("ack_body").$type().notNull(),
+	createdAt: timestamp("created_at", {
+		withTimezone: true,
+		mode: "string"
+	}).notNull()
+}, (t) => [index("report_receipts_created").on(t.createdAt)]);
+/** Durable evidence for a rejected terminal attempt. It is keyed by
+* sha256(reportId + canonical-payload-digest), is never loop-owned, and therefore
+* survives loop deletion just like normal report receipts. */
+var terminalReportIncidents = pgTable("terminal_report_incidents", {
+	id: text("id").primaryKey(),
+	runId: text("run_id").notNull(),
+	reportId: text("report_id").notNull(),
+	payloadDigest: text("payload_digest").notNull(),
+	disposition: text("disposition", { enum: ["run-error", "telemetry-rejected"] }).$type().notNull(),
+	ackBody: jsonb("ack_body").$type().notNull(),
+	createdAt: timestamp("created_at", {
+		withTimezone: true,
+		mode: "string"
+	}).notNull()
+}, (t) => [
+	index("terminal_report_incidents_report_id").on(t.reportId),
+	index("terminal_report_incidents_created").on(t.createdAt),
+	check("terminal_report_incidents_disposition_check", sql`${t.disposition} IN ('run-error', 'telemetry-rejected')`)
+]);
+var connectKeys = pgTable("connect_keys", {
+	machineId: text("machine_id").primaryKey(),
+	/** Mint time (ISO) — drives the TTL. */
+	mintedAt: text("minted_at").notNull()
+});
+/**
+* One content-addressed blob (deduped across every loop/run). The bytes live in
+* the byte store under the hash; this row records verified byte presence and size.
+*/
+var blobs = pgTable("blobs", {
+	hash: text("hash").primaryKey(),
+	size: integer("size").notNull(),
+	createdAt: text("created_at").notNull()
+});
+/**
+* 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(),
+	/** Loop file name: MEMORY.md or a configured artifact name. */
+	path: text("path").notNull(),
+	hash: text("hash"),
+	size: integer("size"),
+	/** Legacy snapshot/diff metadata. Loop-file ingress rejects NUL, so new rows
+	*  always store false. */
+	binary: boolean("binary").notNull().default(false),
+	/** 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()
+}, (t) => [
+	index("artifact_files_loop_idx").on(t.loopId),
+	uniqueIndex("artifact_files_loop_path_idx").on(t.loopId, t.path),
+	index("artifact_files_hash_idx").on(t.hash)
+]);
+/**
+* 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).
+*/
+var runSnapshots = pgTable("run_snapshots", {
+	runId: text("run_id").primaryKey(),
+	loopId: text("loop_id").notNull(),
+	manifest: jsonb("manifest").$type().notNull(),
+	createdAt: text("created_at").notNull()
+}, (t) => [index("run_snapshots_loop_idx").on(t.loopId)]);
+/**
+* Embedded PGlite (WASM Postgres) database, file-backed at `<dataDir>/pgdata`,
+* plus the Drizzle handle. A `globalThis` guard keeps the handle a singleton
+* across dev HMR reloads (the Scheduler shares it in-process). Exactly one
+* server process may own a data directory.
+*/
+var schema = {
+	machines,
+	loops,
+	runs,
+	blobs,
+	artifactFiles,
+	runSnapshots,
+	runLeases,
+	runReportReceipts,
+	terminalReportIncidents,
+	connectKeys
+};
+var g$1 = globalThis;
+function open() {
+	if (g$1.__pievoDb && g$1.__pievoClient) return {
+		db: g$1.__pievoDb,
+		client: g$1.__pievoClient
+	};
+	const dir = path.join(dataDir(), "pgdata");
+	logger.info({ pgdata: dir }, "database: pglite");
+	fs.mkdirSync(dataDir(), { recursive: true });
+	const client = new Ve(dir);
+	const db = drizzle(client, { schema });
+	g$1.__pievoClient = client;
+	g$1.__pievoDb = db;
+	return {
+		db,
+		client
+	};
+}
+var opened = open();
+var db = opened.db;
+opened.client;
+/**
+* Migrations dir. In DEV this file lives at `src/db`, so the folder is at the
+* package root (`../../drizzle`). In the BUILT server the module is bundled under
+* `.output/server/{_ssr,_libs}` and `copy-pglite-assets.mjs` lands the folder at
+* `.output/server/drizzle` (`../drizzle`). Return the first candidate that exists
+* so the database migrates in-process from either layout.
+*/
+function migrationsDir() {
+	const here = path.dirname(fileURLToPath(import.meta.url));
+	const devDir = path.resolve(here, "..", "..", "drizzle");
+	const builtDir = path.resolve(here, "..", "drizzle");
+	if (fs.existsSync(devDir)) return devDir;
+	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;
+	const { migrate } = await import("../_libs/drizzle-orm.mjs").then((n) => n.E);
+	await migrate(opened.db, { migrationsFolder: dir });
+}
+/**
+* Best-effort clean shutdown of the database client (called from the
+* boot AbortController on SIGINT/SIGTERM). PGlite must be closed explicitly:
+* after migrations it owns a referenced WASM timer that otherwise keeps Node
+* alive until the managed launcher's graceful-stop deadline. Never throws —
+* shutdown must not wedge on a slow drain.
+*/
+async function closeClient() {
+	try {
+		await opened.client.close();
+	} catch {}
+}
+/**
+* Content-addressed blob byte store for loop files.
+*
+* Bytes are keyed by their sha256 hash (content-addressed ⇒ deduped across every
+* loop/run). The store ONLY writes/reads bytes — it never executes or interprets
+* them — preserving the server's zero-exec invariant.
+*
+* `LocalBlobStore` is the durable store under `<dataDir>/blobs`;
+* `MemoryBlobStore` is the injected test fake.
+*/
+var log$3 = logger.child({ mod: "blobstore" });
+var SHA256_HEX = /^[a-f0-9]{64}$/;
+/** Durable filesystem adapter. Hash sharding bounds entries per directory; atomic
+* temp-file renames ensure readers see either complete bytes or no object. */
+var LocalBlobStore = class {
+	root;
+	initialized;
+	constructor(root = path.join(dataDir(), "blobs")) {
+		this.root = root;
+	}
+	file(hash) {
+		if (!SHA256_HEX.test(hash)) throw new Error("invalid sha256 blob key");
+		return path.join(this.root, hash.slice(0, 2), hash);
+	}
+	async has(hash) {
+		const target = this.file(hash);
+		await this.ensureInitialized();
+		try {
+			return (await fs$1.stat(target)).isFile();
+		} catch (err) {
+			if (err.code === "ENOENT") return false;
+			throw err;
+		}
+	}
+	async syncDir(dir) {
+		let handle;
+		try {
+			handle = await fs$1.open(dir, "r");
+			await handle.sync();
+		} catch (err) {
+			const code = err.code;
+			if (![
+				"EINVAL",
+				"ENOTSUP",
+				"EBADF",
+				"EPERM",
+				"ENOENT"
+			].includes(code)) throw err;
+		} finally {
+			await handle?.close().catch(() => {});
+		}
+	}
+	ensureInitialized() {
+		return this.initialized ??= (async () => {
+			await fs$1.mkdir(this.root, { recursive: true });
+			await this.syncDir(path.dirname(path.dirname(this.root)));
+			await this.syncDir(path.dirname(this.root));
+			await this.syncDir(this.root);
+			for (const shard of await fs$1.readdir(this.root, { withFileTypes: true })) {
+				if (!shard.isDirectory() || !/^[a-f0-9]{2}$/.test(shard.name)) continue;
+				const dir = path.join(this.root, shard.name);
+				let removed = false;
+				for (const name of await fs$1.readdir(dir)) {
+					if (!/^\.[a-f0-9]{64}\.\d+\.[0-9a-f-]+\.tmp$/.test(name)) continue;
+					await fs$1.rm(path.join(dir, name), { force: true });
+					removed = true;
+				}
+				if (removed) await this.syncDir(dir);
+			}
+		})();
+	}
+	async put(hash, bytes) {
+		const target = this.file(hash);
+		await this.ensureInitialized();
+		const dir = path.dirname(target);
+		await fs$1.mkdir(dir, { recursive: true });
+		await this.syncDir(this.root);
+		const temp = path.join(dir, `.${hash}.${process.pid}.${randomUUID()}.tmp`);
+		let handle;
+		try {
+			handle = await fs$1.open(temp, "wx", 384);
+			await handle.writeFile(bytes);
+			await handle.sync();
+			await handle.close();
+			handle = void 0;
+			try {
+				await fs$1.rename(temp, target);
+				await this.syncDir(dir);
+			} catch (err) {
+				if ([
+					"EEXIST",
+					"EACCES",
+					"EPERM"
+				].includes(err.code ?? "") && await this.has(hash)) {
+					await fs$1.rm(temp, { force: true });
+					return;
+				}
+				throw err;
+			}
+		} catch (err) {
+			await handle?.close().catch(() => {});
+			await fs$1.rm(temp, { force: true }).catch(() => {});
+			throw err;
+		}
+	}
+	async get(hash) {
+		const target = this.file(hash);
+		await this.ensureInitialized();
+		try {
+			return await fs$1.readFile(target);
+		} catch (err) {
+			if (err.code === "ENOENT") return null;
+			throw err;
+		}
+	}
+	async delete(hash) {
+		const target = this.file(hash);
+		await this.ensureInitialized();
+		await fs$1.rm(target, { force: true });
+		await this.syncDir(path.dirname(target));
+	}
+};
+/** The one local blob store shared by loop-file writes/reads and GC. */
+function createBlobStore() {
+	const local = new LocalBlobStore();
+	log$3.info({ root: local.root }, "blob store: local filesystem");
+	return local;
+}
+/**
+* Loop files: a loop's server-owned memory and display artifacts.
+*
+* Every loop has the required `MEMORY.md` plus up to MAX_ARTIFACTS configured
+* `.md`/`.html` artifact names. The server is authoritative: bytes live in the
+* content-addressed BlobStore and the current version of each name is an
+* `artifact_files` row. For each run the daemon downloads the current files into
+* a private run directory, and the terminal report carries the changed versions
+* back with the hash each edit started from, so an owner edit made during the run
+* wins over the agent's (base-hash check under the loop lock).
+*
+* Limits are part of the agent-facing prompt contract and are mirrored in the
+* daemon (`packages/daemon/src/loop-files.ts`); change both together. An over-limit
+* version is rejected and the previous version kept, never truncated, because a cut
+* HTML file renders broken and a cut memory file silently loses its newest notes.
+*/
+var loopFiles_exports = /* @__PURE__ */ __exportAll({
+	ARTIFACT_BYTE_CAP: () => ARTIFACT_BYTE_CAP,
+	EMPTY_SHA256: () => EMPTY_SHA256,
+	LOOP_FILE_BYTE_CAP: () => LOOP_FILE_BYTE_CAP,
+	LoopFiles: () => LoopFiles,
+	MAX_ARTIFACTS: () => 4,
+	MEMORY_CHAR_CAP: () => MEMORY_CHAR_CAP,
+	MEMORY_FILE: () => MEMORY_FILE,
+	fileLimitLabel: () => fileLimitLabel,
+	isValidHash: () => isValidHash,
+	loopFileIssue: () => loopFileIssue,
+	loopFileNames: () => loopFileNames,
+	sha256Buf: () => sha256Buf,
+	validArtifactName: () => validArtifactName
+});
+var MEMORY_FILE = "MEMORY.md";
+/** Memory is re-read by every run, so it is bounded in characters (Unicode code
+*  points), roughly 2k tokens of prompt context per run. */
+var MEMORY_CHAR_CAP = 8e3;
+/** HTML reports are bulky; 2 MB keeps a run's upload and the dashboard iframe cheap. */
+var ARTIFACT_BYTE_CAP = 2 * 1024 * 1024;
+/** sha256 of zero bytes: the version of a loop file that has never been written. */
+var EMPTY_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+var ARTIFACT_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}\.(md|html)$/;
+function sha256Buf(bytes) {
+	return createHash("sha256").update(bytes).digest("hex");
+}
+function isValidHash(hash) {
+	return typeof hash === "string" && /^[0-9a-f]{64}$/.test(hash);
+}
+/** A plain file name (no directories) ending in .md or .html, other than MEMORY.md. */
+function validArtifactName(name) {
+	return typeof name === "string" && ARTIFACT_NAME_RE.test(name) && name.toLowerCase() !== "MEMORY.md".toLowerCase();
+}
+function loopFileNames(loop) {
+	return [MEMORY_FILE, ...loop.artifacts];
+}
+function fileLimitLabel(name) {
+	return name === "MEMORY.md" ? `${MEMORY_CHAR_CAP} characters` : "2 MB";
+}
+/** Why `bytes` cannot become the next version of `name`, or undefined if it can. */
+function loopFileIssue(name, bytes) {
+	if (bytes.includes(0)) return `${name}: binary content is not allowed`;
+	if (name === "MEMORY.md") {
+		const chars = Array.from(bytes.toString("utf8")).length;
+		if (chars > 8e3) return `${name}: ${chars} characters exceeds the ${MEMORY_CHAR_CAP}-character limit`;
+		return;
+	}
+	if (bytes.length > 2097152) return `${name}: ${(bytes.length / 1024 / 1024).toFixed(1)} MB exceeds the 2 MB limit`;
+}
+/** The largest byte size any loop file can have (a code point is at most 4 bytes). */
+var LOOP_FILE_BYTE_CAP = Math.max(ARTIFACT_BYTE_CAP, MEMORY_CHAR_CAP * 4);
+var LoopFiles = class {
+	blobStore;
+	constructor(blobStore = createBlobStore()) {
+		this.blobStore = blobStore;
+	}
+	readBlob(hash) {
+		if (!isValidHash(hash)) return Promise.resolve(null);
+		if (hash === "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855") return Promise.resolve(Buffer.alloc(0));
+		return this.blobStore.get(hash);
+	}
+	/** Persist bytes under their own hash. Idempotent; callers record the metadata row. */
+	async putBlob(bytes) {
+		const hash = sha256Buf(bytes);
+		if (hash !== "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" && !await this.blobStore.has(hash)) await this.blobStore.put(hash, bytes);
+		return hash;
+	}
+	async hasBlob(hash) {
+		return hash === "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" || this.blobStore.has(hash);
+	}
+};
+/**
+* Data-access layer over Drizzle. Loop-locked state transitions live here; every
+* DB-touching function is async, while the pure helpers stay sync.
+*/
+var store_exports = /* @__PURE__ */ __exportAll({
+	TERMINAL_REPORT_GRACE_MS: () => TERMINAL_REPORT_GRACE_MS,
+	acknowledgeRetiredReport: () => acknowledgeRetiredReport,
+	acknowledgeRetiredTerminalIncident: () => acknowledgeRetiredTerminalIncident,
+	advanceDueSchedules: () => advanceDueSchedules,
+	artifactFileReferencesHash: () => artifactFileReferencesHash,
+	blobHashesOlderThan: () => blobHashesOlderThan,
+	blobSizes: () => blobSizes,
+	buildLoopManifest: () => buildLoopManifest,
+	claimReadyRunForMachine: () => claimReadyRunForMachine,
+	countRunSnapshots: () => countRunSnapshots,
+	countRuns: () => countRuns,
+	createLoop: () => createLoop,
+	createMachine: () => createMachine,
+	deleteBlob: () => deleteBlob,
+	enqueueRun: () => enqueueRun,
+	expirePendingRun: () => expirePendingRun,
+	finalizeRunningRun: () => finalizeRunningRun,
+	forceDeleteLoop: () => forceDeleteLoop,
+	forceDeleteMachine: () => forceDeleteMachine,
+	getArtifactFile: () => getArtifactFile,
+	getExactTerminalReportIncident: () => getExactTerminalReportIncident,
+	getLoop: () => getLoop,
+	getMachine: () => getMachine,
+	getReportReceipt: () => getReportReceipt,
+	getRun: () => getRun,
+	getRunSnapshot: () => getRunSnapshot,
+	getTerminalReportIncidents: () => getTerminalReportIncidents,
+	hasPendingRun: () => hasPendingRun,
+	hasRunningRun: () => hasRunningRun,
+	initializeCronCadence: () => initializeCronCadence,
+	lastRun: () => lastRun,
+	listArtifacts: () => listArtifacts,
+	listLoops: () => listLoops,
+	listMachines: () => listMachines,
+	listRuns: () => listRuns,
+	listRunsBefore: () => listRunsBefore,
+	liveBlobRefs: () => liveBlobRefs,
+	loopIdsWithSnapshots: () => loopIdsWithSnapshots,
+	loopsForMachine: () => loopsForMachine,
+	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,
+	reconcileReclaimedRun: () => reconcileReclaimedRun,
+	reconciliationStatesForRuns: () => reconciliationStatesForRuns,
+	recordBlob: () => recordBlob,
+	refreshRunHeartbeats: () => refreshRunHeartbeats,
+	rejectTerminalReport: () => rejectTerminalReport,
+	releaseAbsentReconciliations: () => releaseAbsentReconciliations,
+	repairTerminalRunLeases: () => repairTerminalRunLeases,
+	requestDeleteLoop: () => requestDeleteLoop,
+	requestRunCancel: () => requestRunCancel,
+	runningRunForLoop: () => runningRunForLoop,
+	runningRunsForMachine: () => runningRunsForMachine,
+	setMachineOnline: () => setMachineOnline,
+	snapshotBlobRefs: () => snapshotBlobRefs,
+	startLoop: () => startLoop,
+	stopLoop: () => stopLoop,
+	terminalIncidentReceiptId: () => terminalIncidentReceiptId,
+	tryDeleteLoop: () => tryDeleteLoop,
+	updateLoop: () => updateLoop,
+	updateMachine: () => updateMachine,
+	writeLoopFile: () => writeLoopFile
+});
+function newLoopId() {
+	return `loop-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+}
+function nowIso$1() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function nextCronAt(cron, timezone, after) {
+	if (!timezone) throw new Error("invariant: cron schedule has no timezone");
+	const probe = new E(cron, {
+		paused: true,
+		timezone
+	});
+	try {
+		const next = probe.nextRun(new Date(after));
+		if (!next) throw new Error(`cron expression never fires again: ${cron}`);
+		return next.toISOString();
+	} finally {
+		probe.stop();
+	}
+}
+function runTimes(at = nowIso$1()) {
+	return {
+		ts: at,
+		createdAt: at,
+		updatedAt: at
+	};
+}
+async function listLoops() {
+	return db.select().from(loops);
+}
+async function getLoop(id) {
+	return (await db.select().from(loops).where(eq(loops.id, id)))[0];
+}
+async function loopsForMachine(machineId) {
+	return db.select().from(loops).where(eq(loops.machineId, machineId));
+}
+async function createLoop(input) {
+	const ts = nowIso$1();
+	const enabled = input.enabled ?? true;
+	if (input.scheduleMode === "cron" && !input.timezone) throw new Error("invariant: cron loop creation requires a timezone");
+	if (input.scheduleMode === "continuous" && input.timezone !== null) throw new Error("invariant: continuous loop creation requires a null timezone");
+	const nextCadenceAt = !enabled ? null : input.scheduleMode === "continuous" ? ts : nextCronAt(input.cron, input.timezone, ts);
+	const row = {
+		...input,
+		enabled,
+		pauseCause: input.pauseCause ?? (!enabled ? {
+			kind: "owner",
+			at: ts
+		} : null),
+		nextRunAt: enabled ? input.nextRunAt ?? null : null,
+		nextCadenceAt,
+		id: input.id ?? newLoopId(),
+		createdAt: ts,
+		updatedAt: ts
+	};
+	return db.transaction(async (tx) => {
+		if (!(await tx.select({ id: machines.id }).from(machines).where(eq(machines.id, input.machineId)).for("key share"))[0]) throw new Error(`machine ${input.machineId} does not exist`);
+		return (await tx.insert(loops).values(row).returning())[0];
+	});
+}
+/** Allocate the next 1-based history number. Every caller already holds the
+* owning loop row lock, so the counter and run transition share one commit. */
+async function allocateRunIndexTx(tx, loopId) {
+	const updated = (await tx.update(loops).set({ lastRunIndex: sql`${loops.lastRunIndex} + 1` }).where(eq(loops.id, loopId)).returning({ runIndex: loops.lastRunIndex }))[0];
+	if (!updated) throw new Error(`cannot allocate history index for missing loop ${loopId}`);
+	return updated.runIndex;
+}
+async function ensureRunIndexTx(tx, run) {
+	return run.runIndex ?? allocateRunIndexTx(tx, run.loopId);
+}
+async function cancelPendingTx(tx, where, message, at) {
+	const pending = await tx.select({
+		id: runs.id,
+		loopId: runs.loopId,
+		runIndex: runs.runIndex
+	}).from(runs).where(where).orderBy(asc(runs.createdAt), asc(runs.id)).for("update");
+	for (const run of pending) {
+		const runIndex = await ensureRunIndexTx(tx, run);
+		await tx.update(runs).set({
+			phase: "canceled",
+			runIndex,
+			message,
+			ts: at,
+			updatedAt: at
+		}).where(and(eq(runs.id, run.id), eq(runs.phase, "pending")));
+	}
+}
+/** Apply one loop patch while its row lock is held. This is shared by owner edits
+* and run-authorized mutations, so cadence semantics cannot drift. */
+async function updateLoopTx(tx, current, patch, at) {
+	const extra = {};
+	if (patch.enabled === true) extra.pauseCause = null;
+	else if (patch.enabled === false && current.enabled && patch.pauseCause === void 0) extra.pauseCause = {
+		kind: "owner",
+		at
+	};
+	const effective = {
+		...current,
+		...patch,
+		...extra
+	};
+	if (current.deleteRequestedAt) extra.enabled = false;
+	const pausing = !effective.enabled || current.deleteRequestedAt != null;
+	const activating = effective.enabled && (patch.enabled === true && !current.enabled || patch.scheduleMode !== void 0 && patch.scheduleMode !== current.scheduleMode);
+	if (pausing) {
+		extra.nextCadenceAt = null;
+		extra.nextRunAt = null;
+	} else if (activating) if (effective.scheduleMode === "cron") extra.nextCadenceAt = nextCronAt(effective.cron, effective.timezone, at);
+	else extra.nextCadenceAt = (await tx.select({ id: runs.id }).from(runs).where(and(eq(runs.loopId, current.id), inArray(runs.phase, ["pending", "running"]))).limit(1))[0] ? null : at;
+	else if (effective.enabled && effective.scheduleMode === "cron" && (patch.cron !== void 0 && patch.cron !== current.cron || patch.timezone !== void 0 && patch.timezone !== current.timezone)) extra.nextCadenceAt = nextCronAt(effective.cron, effective.timezone, at);
+	else if (effective.enabled && effective.scheduleMode === "continuous" && current.nextCadenceAt && Date.parse(current.nextCadenceAt) > Date.parse(at) && patch.continuousDelayMinutes !== void 0 && patch.continuousDelayMinutes !== current.continuousDelayMinutes) {
+		const terminalAt = Date.parse(current.nextCadenceAt) - current.continuousDelayMinutes * 6e4;
+		extra.nextCadenceAt = new Date(terminalAt + effective.continuousDelayMinutes * 6e4).toISOString();
+	}
+	const loop = (await tx.update(loops).set({
+		...patch,
+		...extra,
+		updatedAt: 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([MEMORY_FILE, ...patch.artifacts ?? []]);
+		const removed = (await tx.select({
+			id: artifactFiles.id,
+			path: artifactFiles.path
+		}).from(artifactFiles).where(and(eq(artifactFiles.loopId, current.id), eq(artifactFiles.deleted, false)))).filter((file) => !allowed.has(file.path)).map((file) => file.id);
+		if (removed.length) await tx.update(artifactFiles).set({
+			hash: null,
+			deleted: true,
+			updatedAt: at
+		}).where(inArray(artifactFiles.id, removed));
+	}
+	return loop;
+}
+async function updateLoop(id, patch) {
+	return db.transaction(async (tx) => {
+		const current = (await tx.select().from(loops).where(eq(loops.id, id)).for("update"))[0];
+		return current ? updateLoopTx(tx, current, patch, nowIso$1()) : void 0;
+	});
+}
+/** Delete loop-owned history/content without erasing durable late-report evidence.
+* A retired lease is non-authorizing and never blocks deletion; only the matching
+* report→410 receipt transaction may consume it. */
+async function deleteLoopDataTx(tx, id) {
+	if (!(await tx.delete(loops).where(eq(loops.id, id)).returning({ id: loops.id })).length) return false;
+	await tx.delete(runs).where(eq(runs.loopId, id));
+	await tx.delete(runLeases).where(and(eq(runLeases.loopId, id), ne(runLeases.state, "retired")));
+	await tx.delete(artifactFiles).where(eq(artifactFiles.loopId, id));
+	await tx.delete(runSnapshots).where(eq(runSnapshots.loopId, id));
+	return true;
+}
+/** Stable Pause plus the post-transition running fact, observed under the same loop
+* lock. Callers use this result for truthful wording without a pre-lock race. */
+async function pauseLoopState(id) {
+	return db.transaction(async (tx) => {
+		const current = (await tx.select().from(loops).where(eq(loops.id, id)).for("update"))[0];
+		if (!current) return void 0;
+		const loop = await updateLoopTx(tx, current, { enabled: false }, nowIso$1());
+		const running = (await tx.select().from(runs).where(and(eq(runs.loopId, id), eq(runs.phase, "running"))).limit(1))[0];
+		return {
+			loop,
+			...running ? { running } : {}
+		};
+	});
+}
+async function pauseLoop(id) {
+	return (await pauseLoopState(id))?.loop;
+}
+async function startLoop(id) {
+	return db.transaction(async (tx) => {
+		const current = (await tx.select().from(loops).where(eq(loops.id, id)).for("update"))[0];
+		if (!current || current.deleteRequestedAt) return void 0;
+		return updateLoopTx(tx, current, { enabled: true }, nowIso$1());
+	});
+}
+async function stopLoopTx(tx, current, at) {
+	const loop = (await tx.update(loops).set({
+		enabled: false,
+		pauseCause: {
+			kind: "owner",
+			at
+		},
+		nextCadenceAt: null,
+		nextRunAt: null,
+		updatedAt: at
+	}).where(eq(loops.id, current.id)).returning())[0];
+	await cancelPendingTx(tx, and(eq(runs.loopId, current.id), eq(runs.phase, "pending")), "canceled - loop stopped before this queued run was claimed", at);
+	const running = (await tx.select().from(runs).where(and(eq(runs.loopId, current.id), eq(runs.phase, "running"))).limit(1).for("update"))[0];
+	if (!running) return { loop };
+	return {
+		loop,
+		running: running.cancelRequestedAt ? running : (await tx.update(runs).set({
+			cancelRequestedAt: at,
+			updatedAt: at
+		}).where(and(eq(runs.id, running.id), eq(runs.phase, "running"), isNull(runs.cancelRequestedAt))).returning())[0] ?? running
+	};
+}
+async function stopLoop(id) {
+	return db.transaction(async (tx) => {
+		const current = (await tx.select().from(loops).where(eq(loops.id, id)).for("update"))[0];
+		return current ? stopLoopTx(tx, current, nowIso$1()) : void 0;
+	});
+}
+async function requestRunCancel(loopId, runId) {
+	return db.transaction(async (tx) => {
+		if (!(await tx.select({ id: loops.id }).from(loops).where(eq(loops.id, loopId)).for("update"))[0]) return void 0;
+		const run = (await tx.select().from(runs).where(and(eq(runs.id, runId), eq(runs.loopId, loopId))).limit(1).for("update"))[0];
+		if (!run) return void 0;
+		if (run.phase === "pending") {
+			const at = nowIso$1();
+			const runIndex = await ensureRunIndexTx(tx, run);
+			return (await tx.update(runs).set({
+				phase: "canceled",
+				runIndex,
+				error: "stopped by user",
+				ts: at,
+				updatedAt: at
+			}).where(and(eq(runs.id, runId), eq(runs.phase, "pending"))).returning())[0] ?? run;
+		}
+		if (run.phase === "running" && !run.cancelRequestedAt) {
+			const at = nowIso$1();
+			return (await tx.update(runs).set({
+				cancelRequestedAt: at,
+				updatedAt: at
+			}).where(and(eq(runs.id, runId), eq(runs.phase, "running"), isNull(runs.cancelRequestedAt))).returning())[0] ?? run;
+		}
+		return run;
+	});
+}
+async function requestDeleteLoop(id) {
+	return db.transaction(async (tx) => {
+		let current = (await tx.select().from(loops).where(eq(loops.id, id)).for("update"))[0];
+		if (!current) return void 0;
+		const at = current.deleteRequestedAt ?? nowIso$1();
+		if (!current.deleteRequestedAt) current = (await tx.update(loops).set({
+			deleteRequestedAt: at,
+			updatedAt: at
+		}).where(eq(loops.id, id)).returning())[0];
+		return stopLoopTx(tx, current, at);
+	});
+}
+async function tryDeleteLoop(id) {
+	return db.transaction(async (tx) => {
+		if (!(await tx.select().from(loops).where(eq(loops.id, id)).for("update"))[0]?.deleteRequestedAt) return false;
+		const open = (await tx.select({ id: runs.id }).from(runs).where(and(eq(runs.loopId, id), inArray(runs.phase, ["pending", "running"]))).limit(1))[0];
+		const authority = (await tx.select({ id: runLeases.tokenHash }).from(runLeases).where(and(eq(runLeases.loopId, id), inArray(runLeases.state, ["active", "terminal-grace"]))).limit(1))[0];
+		if (open || authority) return false;
+		await tx.update(runLeases).set({
+			state: "retired",
+			expiresAt: null
+		}).where(and(eq(runLeases.loopId, id), eq(runLeases.state, "reconciliation-only")));
+		return deleteLoopDataTx(tx, id);
+	});
+}
+async function forceDeleteLoopTx(tx, id) {
+	if (!(await tx.select().from(loops).where(eq(loops.id, id)).for("update"))[0]) return false;
+	await tx.update(runLeases).set({
+		state: "retired",
+		expiresAt: null
+	}).where(and(eq(runLeases.loopId, id), inArray(runLeases.state, [
+		"active",
+		"terminal-grace",
+		"reconciliation-only",
+		"retired"
+	])));
+	return deleteLoopDataTx(tx, id);
+}
+async function forceDeleteLoop(id) {
+	return db.transaction((tx) => forceDeleteLoopTx(tx, id));
+}
+async function enqueueRunTx(tx, loop, request, at) {
+	if (loop.deleteRequestedAt) return {
+		state: "rejected",
+		reason: "loop is being deleted"
+	};
+	if (request.requestedBy !== "owner" && !loop.enabled) return {
+		state: "skipped",
+		reason: "loop is paused"
+	};
+	const pending = (await tx.select().from(runs).where(and(eq(runs.loopId, loop.id), eq(runs.phase, "pending"))).limit(1).for("update"))[0];
+	if (pending) {
+		const requestedBy = pending.requestedBy === "owner" || request.requestedBy === "owner" ? "owner" : "system";
+		const updated = (await tx.update(runs).set({
+			requestedBy,
+			ts: at,
+			updatedAt: at
+		}).where(and(eq(runs.id, pending.id), eq(runs.phase, "pending"))).returning())[0];
+		return updated ? {
+			state: "coalesced",
+			run: updated
+		} : {
+			state: "skipped",
+			reason: "queued run was claimed concurrently"
+		};
+	}
+	const row = {
+		id: randomUUID(),
+		loopId: loop.id,
+		machineId: loop.machineId,
+		phase: "pending",
+		requestedBy: request.requestedBy,
+		...runTimes(at)
+	};
+	return {
+		state: "queued",
+		run: (await tx.insert(runs).values(row).returning())[0]
+	};
+}
+async function failureStreakTx(tx, loopId) {
+	const lastOk = (await tx.select({ runIndex: runs.runIndex }).from(runs).where(and(eq(runs.loopId, loopId), eq(runs.phase, "done"), isNotNull(runs.runIndex))).orderBy(desc(runs.runIndex)).limit(1))[0];
+	const conds = [
+		eq(runs.loopId, loopId),
+		eq(runs.phase, "error"),
+		isNotNull(runs.runIndex)
+	];
+	if (lastOk?.runIndex != null) conds.push(gt(runs.runIndex, lastOk.runIndex));
+	const row = (await tx.select({ n: sql`count(*)` }).from(runs).where(and(...conds)))[0];
+	return Number(row?.n ?? 0);
+}
+async function terminalLifecycleTx(tx, currentLoop, run, terminalAt, loopPatch = {}, failureAutopauseStreak = 0) {
+	const effective = {
+		...currentLoop,
+		...loopPatch
+	};
+	const update = { ...loopPatch };
+	if ((run.phase === "done" || run.phase === "error") && effective.scheduleMode === "continuous") {
+		const openExec = (await tx.select({ id: runs.id }).from(runs).where(and(eq(runs.loopId, currentLoop.id), inArray(runs.phase, ["pending", "running"]))).limit(1))[0];
+		update.nextCadenceAt = effective.enabled && !openExec ? new Date(Date.parse(terminalAt) + Math.max(1, effective.continuousDelayMinutes) * 6e4).toISOString() : null;
+	}
+	let loop = Object.keys(update).length ? (await tx.update(loops).set({
+		...update,
+		updatedAt: terminalAt
+	}).where(eq(loops.id, currentLoop.id)).returning())[0] : currentLoop;
+	let failureStreak = 0;
+	let autoPaused = false;
+	if (run.phase === "done" && run.status === "block") {
+		loop = (await tx.update(loops).set({
+			enabled: false,
+			pauseCause: {
+				kind: "blocked",
+				at: terminalAt,
+				runId: run.id
+			},
+			nextCadenceAt: null,
+			nextRunAt: null,
+			updatedAt: terminalAt
+		}).where(eq(loops.id, currentLoop.id)).returning())[0];
+		await cancelPendingTx(tx, and(eq(runs.loopId, currentLoop.id), eq(runs.phase, "pending"), eq(runs.requestedBy, "system")), "canceled - loop auto-paused after a block report", terminalAt);
+		autoPaused = true;
+	}
+	if (run.phase === "error") {
+		failureStreak = await failureStreakTx(tx, currentLoop.id);
+		if (failureAutopauseStreak > 0 && failureStreak >= failureAutopauseStreak && loop.enabled) {
+			loop = (await tx.update(loops).set({
+				enabled: false,
+				pauseCause: {
+					kind: "failure-streak",
+					at: terminalAt,
+					runId: run.id,
+					count: failureStreak
+				},
+				nextCadenceAt: null,
+				nextRunAt: null,
+				updatedAt: terminalAt
+			}).where(eq(loops.id, currentLoop.id)).returning())[0];
+			await cancelPendingTx(tx, and(eq(runs.loopId, currentLoop.id), eq(runs.phase, "pending"), eq(runs.requestedBy, "system")), "canceled - loop auto-paused after consecutive failures", terminalAt);
+			autoPaused = true;
+		}
+	}
+	return {
+		loop,
+		failureStreak,
+		autoPaused
+	};
+}
+async function getRun(id) {
+	return (await db.select().from(runs).where(eq(runs.id, id)))[0];
+}
+async function runningRunsForMachine(machineId) {
+	return db.select().from(runs).where(and(eq(runs.machineId, machineId), eq(runs.phase, "running"))).orderBy(asc(runs.createdAt), asc(runs.id));
+}
+async function runningRunForLoop(loopId) {
+	return (await db.select().from(runs).where(and(eq(runs.loopId, loopId), eq(runs.phase, "running"))).limit(1))[0];
+}
+async function getReportReceipt(reportId) {
+	return (await db.select().from(runReportReceipts).where(eq(runReportReceipts.reportId, reportId)))[0];
+}
+function terminalIncidentReceiptId(reportId, payloadDigest) {
+	return createHash("sha256").update(reportId + payloadDigest).digest("hex");
+}
+async function getTerminalReportIncidents(reportId) {
+	return db.select().from(terminalReportIncidents).where(eq(terminalReportIncidents.reportId, reportId)).orderBy(asc(terminalReportIncidents.createdAt));
+}
+async function getExactTerminalReportIncident(reportId, payloadDigest) {
+	return (await db.select().from(terminalReportIncidents).where(eq(terminalReportIncidents.id, terminalIncidentReceiptId(reportId, payloadDigest))))[0];
+}
+async function putTerminalReportIncidentIfAbsent(input) {
+	return db.transaction(async (tx) => {
+		await lockReportIdTx(tx, input.reportId);
+		const id = terminalIncidentReceiptId(input.reportId, input.payloadDigest);
+		const existing = (await tx.select().from(terminalReportIncidents).where(eq(terminalReportIncidents.id, id)).limit(1))[0];
+		if (existing) return existing;
+		return (await tx.insert(terminalReportIncidents).values({
+			id,
+			...input,
+			createdAt: nowIso$1()
+		}).returning())[0];
+	});
+}
+/** Serialize all terminal handling for one reportId, even when the competing
+* runs belong to different loop locks or one terminal result lands in the incident table. */
+async function lockReportIdTx(tx, reportId) {
+	const unsigned = BigInt(`0x${createHash("sha256").update(reportId).digest("hex").slice(0, 16)}`);
+	const key = BigInt.asIntN(64, unsigned).toString();
+	await tx.execute(sql`select pg_advisory_xact_lock(${key}::bigint)`);
+}
+/** Race-safe receipt reservation for definitive non-finalization ACKs (RETIRED).
+* Returns the row that owns reportId, whether inserted here or concurrently. */
+async function putReportReceiptIfAbsent(input) {
+	return db.transaction(async (tx) => {
+		await lockReportIdTx(tx, input.reportId);
+		return (await tx.insert(runReportReceipts).values(input).onConflictDoNothing({ target: runReportReceipts.reportId }).returning())[0] ?? (await tx.select().from(runReportReceipts).where(eq(runReportReceipts.reportId, input.reportId)))[0];
+	});
+}
+/** Idempotent startup repair for a crash across terminalization.
+* Terminal runs can never retain active authority. */
+async function repairTerminalRunLeases(now = Date.now()) {
+	const repaired = await db.update(runLeases).set({
+		state: "terminal-grace",
+		expiresAt: new Date(now + TERMINAL_REPORT_GRACE_MS).toISOString()
+	}).where(and(eq(runLeases.state, "active"), sql`exists (select 1 from ${runs} where ${runs.id} = ${runLeases.runId} and ${runs.phase} in ('done', 'error', 'canceled'))`)).returning({ tokenHash: runLeases.tokenHash });
+	await db.update(runLeases).set({ expiresAt: null }).where(eq(runLeases.state, "retired"));
+	return repaired.length;
+}
+/** Atomically persist a definitive 410 and consume only the matching retired
+* tombstone. If the HTTP response is lost, the independent receipt replays it. */
+async function acknowledgeRetiredReport(leaseTokenHash, input) {
+	return db.transaction(async (tx) => {
+		await lockReportIdTx(tx, input.reportId);
+		if (!(await tx.select().from(runLeases).where(and(eq(runLeases.tokenHash, leaseTokenHash), eq(runLeases.state, "retired"))).limit(1).for("update"))[0]) return void 0;
+		await tx.insert(runReportReceipts).values(input).onConflictDoNothing({ target: runReportReceipts.reportId });
+		const stored = (await tx.select().from(runReportReceipts).where(eq(runReportReceipts.reportId, input.reportId)))[0];
+		if (stored?.runId === input.runId && stored.payloadDigest === input.payloadDigest && stored.ackStatus === input.ackStatus) await tx.delete(runLeases).where(and(eq(runLeases.tokenHash, leaseTokenHash), eq(runLeases.state, "retired")));
+		return stored;
+	});
+}
+/** Refresh provider-neutral liveness in one machine-scoped UPDATE. Untrusted ids
+* cannot stamp another machine or a non-running row; fresh stamps stay untouched. */
+async function refreshRunHeartbeats(machineId, runIds, at, staleBefore) {
+	if (!runIds.length) return 0;
+	return (await db.update(runs).set({
+		heartbeatAt: at,
+		updatedAt: at
+	}).where(and(eq(runs.machineId, machineId), eq(runs.phase, "running"), inArray(runs.id, runIds), or(isNull(runs.heartbeatAt), lt(runs.heartbeatAt, staleBefore)))).returning({ id: runs.id })).length;
+}
+async function activeRunForReportTx(tx, loopId, runId, leaseTokenHash) {
+	const lease = (await tx.select().from(runLeases).where(and(eq(runLeases.tokenHash, leaseTokenHash), eq(runLeases.runId, runId), eq(runLeases.loopId, loopId), eq(runLeases.state, "active"))).limit(1).for("update"))[0];
+	if (!lease) return { state: "invalid-lease" };
+	const run = (await tx.select().from(runs).where(and(eq(runs.id, runId), eq(runs.loopId, loopId), eq(runs.machineId, lease.machineId), eq(runs.phase, "running"))).limit(1).for("update"))[0];
+	return run ? {
+		state: "active",
+		run
+	} : { state: "run-not-running" };
+}
+/** 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);
+	const current = (await tx.select().from(loops).where(eq(loops.id, input.loopId)).for("update"))[0];
+	if (!current) return void 0;
+	if (input.receipt) {
+		if ((await tx.select({ id: terminalReportIncidents.id }).from(terminalReportIncidents).where(eq(terminalReportIncidents.reportId, input.receipt.reportId)).limit(1))[0]) return void 0;
+	}
+	const leaseState = input.leaseCheck ? await input.leaseCheck(tx) : void 0;
+	if (input.leaseCheck && !leaseState) return void 0;
+	const target = (await tx.select().from(runs).where(and(eq(runs.id, input.runId), eq(runs.loopId, input.loopId), eq(runs.phase, input.runPhase))).limit(1).for("update"))[0];
+	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];
+	if (!run) return void 0;
+	const lifecycle = leaseState === "reconciliation-only" ? {
+		loop: current,
+		failureStreak: 0,
+		autoPaused: false
+	} : await terminalLifecycleTx(tx, current, run, at, input.loopPatch, input.failureAutopauseStreak);
+	if (input.leaseTokenHash) await tx.delete(runLeases).where(eq(runLeases.runId, input.runId));
+	if (input.receipt) await tx.insert(runReportReceipts).values(input.receipt);
+	return {
+		run,
+		...lifecycle,
+		...input.reconciliation ? { reportOnly: leaseState === "reconciliation-only" } : {}
+	};
+}
+async function reclaimedLeaseStateTx(tx, loopId, runId, leaseTokenHash) {
+	const leaseNow = nowIso$1();
+	const lease = (await tx.select({ state: runLeases.state }).from(runLeases).where(and(eq(runLeases.tokenHash, leaseTokenHash), eq(runLeases.runId, runId), eq(runLeases.loopId, loopId), inArray(runLeases.state, ["terminal-grace", "reconciliation-only"]), gt(runLeases.expiresAt, leaseNow))).limit(1).for("update"))[0];
+	return lease?.state === "terminal-grace" || lease?.state === "reconciliation-only" ? lease.state : void 0;
+}
+/** Consume a retired tombstone when its reportId is owned by another run.
+* The run/loop may already be deleted, so only the exact incident receipt and
+* lease tombstone participate in this transaction. */
+async function acknowledgeRetiredTerminalIncident(input) {
+	return db.transaction(async (tx) => {
+		await lockReportIdTx(tx, input.reportId);
+		const id = terminalIncidentReceiptId(input.reportId, input.payloadDigest);
+		const replay = (await tx.select().from(terminalReportIncidents).where(eq(terminalReportIncidents.id, id)).limit(1))[0];
+		const lease = (await tx.select({ tokenHash: runLeases.tokenHash }).from(runLeases).where(and(eq(runLeases.tokenHash, input.leaseTokenHash), eq(runLeases.runId, input.runId), eq(runLeases.state, "retired"))).limit(1).for("update"))[0];
+		if (!lease) return void 0;
+		if (replay) {
+			await tx.delete(runLeases).where(eq(runLeases.tokenHash, lease.tokenHash));
+			return replay;
+		}
+		const receipt = (await tx.insert(terminalReportIncidents).values({
+			id,
+			runId: input.runId,
+			reportId: input.reportId,
+			payloadDigest: input.payloadDigest,
+			disposition: "telemetry-rejected",
+			ackBody: input.ackBody,
+			createdAt: nowIso$1()
+		}).returning())[0];
+		await tx.delete(runLeases).where(eq(runLeases.tokenHash, lease.tokenHash));
+		return receipt;
+	});
+}
+/** Reject one correlatable terminal attempt as a durable terminal fact. Authority,
+* run/loop lifecycle, incident receipt, and lease consumption share one transaction.
+* No payload-authored cursor/task/message field is accepted here. */
+async function rejectTerminalReport(input) {
+	return db.transaction(async (tx) => {
+		await lockReportIdTx(tx, input.reportId);
+		const current = (await tx.select().from(loops).where(eq(loops.id, input.loopId)).for("update"))[0];
+		if (!current) return { state: "missing-loop" };
+		const normal = (await tx.select().from(runReportReceipts).where(eq(runReportReceipts.reportId, input.reportId)))[0];
+		if (normal?.runId === input.runId) return {
+			state: "normal-replay",
+			receipt: normal
+		};
+		const priorIncident = (await tx.select().from(terminalReportIncidents).where(eq(terminalReportIncidents.id, terminalIncidentReceiptId(input.reportId, input.payloadDigest))).limit(1))[0];
+		if (priorIncident?.runId === input.runId) return {
+			state: "incident-replay",
+			receipt: priorIncident
+		};
+		const now = nowIso$1();
+		const leaseConditions = [
+			eq(runLeases.tokenHash, input.leaseTokenHash),
+			eq(runLeases.runId, input.runId),
+			eq(runLeases.loopId, input.loopId),
+			input.leaseState === "active" ? eq(runLeases.state, "active") : inArray(runLeases.state, ["terminal-grace", "reconciliation-only"])
+		];
+		if (input.leaseState !== "active") leaseConditions.push(gt(runLeases.expiresAt, now));
+		const lease = (await tx.select().from(runLeases).where(and(...leaseConditions)).limit(1).for("update"))[0];
+		if (!lease) return { state: "invalid-lease" };
+		const receiptInput = {
+			id: terminalIncidentReceiptId(input.reportId, input.payloadDigest),
+			runId: input.runId,
+			reportId: input.reportId,
+			payloadDigest: input.payloadDigest,
+			disposition: input.disposition,
+			ackBody: input.ackBody,
+			createdAt: input.incident.at
+		};
+		if (lease.state !== "active") {
+			const run = (await tx.update(runs).set({
+				reportIncident: input.incident,
+				updatedAt: input.incident.at
+			}).where(and(eq(runs.id, input.runId), eq(runs.loopId, input.loopId), inArray(runs.phase, [
+				"done",
+				"error",
+				"canceled"
+			]))).returning())[0];
+			if (!run) return { state: "run-not-terminalizable" };
+			await tx.delete(runLeases).where(eq(runLeases.tokenHash, input.leaseTokenHash));
+			return {
+				state: "telemetry-rejected",
+				run,
+				loop: current,
+				receipt: priorIncident ?? (await tx.insert(terminalReportIncidents).values(receiptInput).returning())[0],
+				failureStreak: 0,
+				autoPaused: false
+			};
+		}
+		const target = (await tx.select().from(runs).where(and(eq(runs.id, input.runId), eq(runs.loopId, input.loopId), eq(runs.phase, "running"))).limit(1).for("update"))[0];
+		if (!target) return { state: "run-not-terminalizable" };
+		const runIndex = await ensureRunIndexTx(tx, target);
+		const run = (await tx.update(runs).set({
+			phase: "error",
+			runIndex,
+			error: input.incident.reason,
+			reportIncident: input.incident,
+			ts: input.incident.at,
+			updatedAt: input.incident.at
+		}).where(and(eq(runs.id, input.runId), eq(runs.loopId, input.loopId), eq(runs.phase, "running"))).returning())[0];
+		if (!run) return { state: "run-not-terminalizable" };
+		const lifecycle = await terminalLifecycleTx(tx, current, run, input.incident.at, {}, input.failureAutopauseStreak ?? 0);
+		await tx.delete(runLeases).where(eq(runLeases.tokenHash, input.leaseTokenHash));
+		const receipt = priorIncident ?? (await tx.insert(terminalReportIncidents).values(receiptInput).returning())[0];
+		return {
+			state: "run-error",
+			run,
+			...lifecycle,
+			receipt
+		};
+	});
+}
+/** 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, fileUpdates) {
+	return db.transaction(async (tx) => {
+		return finalizeTerminalRunTx(tx, {
+			loopId,
+			runId,
+			runPhase: "running",
+			fileUpdates,
+			runPatch,
+			loopPatch,
+			leaseTokenHash,
+			leaseCheck: leaseTokenHash ? async (lockedTx) => {
+				return (await activeRunForReportTx(lockedTx, loopId, runId, leaseTokenHash)).state === "active" ? "active" : void 0;
+			} : void 0,
+			failureAutopauseStreak,
+			receipt
+		});
+	});
+}
+/** Sweep reclaim under the same loop lock as claim/report/cancel. Running
+* reclaims terminalize their lease and write the provisional continuous cadence
+* fact atomically; pending reclaims have no lease. */
+async function reclaimRun(runId, expected, reason, at = nowIso$1(), graceMs = 1440 * 60 * 1e3, failureAutopauseStreak = 0) {
+	return db.transaction(async (tx) => {
+		const observed = (await tx.select({ loopId: runs.loopId }).from(runs).where(eq(runs.id, runId)).limit(1))[0];
+		if (!observed) return void 0;
+		const loop = (await tx.select().from(loops).where(eq(loops.id, observed.loopId)).for("update"))[0];
+		if (!loop) return void 0;
+		const currentRun = (await tx.select().from(runs).where(eq(runs.id, runId)).limit(1).for("update"))[0];
+		if (currentRun?.phase !== expected) return void 0;
+		if (expected === "running") await tx.update(runLeases).set({
+			state: "terminal-grace",
+			expiresAt: new Date(Date.parse(at) + graceMs).toISOString()
+		}).where(and(eq(runLeases.runId, runId), eq(runLeases.state, "active")));
+		const runIndex = await ensureRunIndexTx(tx, currentRun);
+		const reclaimed = (await tx.update(runs).set({
+			phase: "error",
+			runIndex,
+			error: reason,
+			ts: at,
+			updatedAt: at
+		}).where(and(eq(runs.id, runId), eq(runs.phase, expected))).returning())[0];
+		if (!reclaimed) return void 0;
+		return {
+			run: reclaimed,
+			...await terminalLifecycleTx(tx, loop, reclaimed, at, {}, failureAutopauseStreak)
+		};
+	});
+}
+/** A daemon's completed recovery snapshot is authoritative for execution
+* exclusion. Reclaimed runs absent from that snapshot retain late-report authority
+* until their original expiry, but stop blocking queued work immediately. */
+async function releaseAbsentReconciliations(machineId, recoverableRunIds, at = nowIso$1()) {
+	const conditions = [
+		eq(runLeases.machineId, machineId),
+		eq(runLeases.state, "terminal-grace"),
+		gt(runLeases.expiresAt, at)
+	];
+	const ids = [...new Set(recoverableRunIds)];
+	if (ids.length) conditions.push(notInArray(runLeases.runId, ids));
+	return (await db.update(runLeases).set({ state: "reconciliation-only" }).where(and(...conditions)).returning({ runId: runLeases.runId })).map((row) => row.runId);
+}
+/** Consume one terminal reconciliation lease and reconcile its reclaimed error
+* 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, fileUpdates) {
+	return db.transaction(async (tx) => {
+		return finalizeTerminalRunTx(tx, {
+			loopId,
+			runId,
+			runPhase: "error",
+			fileUpdates,
+			runPatch,
+			loopPatch,
+			leaseTokenHash,
+			leaseCheck: (lockedTx) => reclaimedLeaseStateTx(lockedTx, loopId, runId, leaseTokenHash),
+			failureAutopauseStreak,
+			receipt,
+			reconciliation: true
+		});
+	});
+}
+var TERMINAL_REPORT_GRACE_MS = 600 * 1e3;
+/**
+* The durable run-queue write seam. It serializes on the loop row and owns every
+* queue invariant callers would otherwise have to reproduce:
+*  - at most one ordinary pending row per loop (also backed by a partial unique index),
+*  - a running run may retain one coalesced follow-up,
+*  - owner authority promotes an existing system row and never downgrades,
+*  - paused loops accept owner Run-once work while recurring system work stays stopped.
+*/
+async function enqueueRun(loopId, request) {
+	return db.transaction(async (tx) => {
+		const loop = (await tx.select().from(loops).where(eq(loops.id, loopId)).for("update"))[0];
+		if (!loop) return {
+			state: "rejected",
+			reason: "loop not found"
+		};
+		return enqueueRunTx(tx, loop, request, nowIso$1());
+	});
+}
+/** Materialize every due schedule fact. Each loop is locked and rechecked in its
+* own transaction; cadence and one-shot facts may coalesce into one system exec
+* and are consumed together. */
+async function advanceDueSchedules(at = nowIso$1(), filter = {}) {
+	const due = or(and(isNotNull(loops.nextCadenceAt), sql`${loops.nextCadenceAt} <= ${at}`), and(isNotNull(loops.nextRunAt), sql`${loops.nextRunAt} <= ${at}`));
+	const candidates = await db.select({ id: loops.id }).from(loops).where(and(eq(loops.enabled, true), isNull(loops.deleteRequestedAt), due, filter.loopId ? eq(loops.id, filter.loopId) : void 0, filter.machineId ? eq(loops.machineId, filter.machineId) : void 0));
+	const advanced = [];
+	for (const { id } of candidates) {
+		const result = await db.transaction(async (tx) => {
+			const loop = (await tx.select().from(loops).where(eq(loops.id, id)).for("update"))[0];
+			if (!loop?.enabled || loop.deleteRequestedAt) return void 0;
+			const cadenceDue = !!loop.nextCadenceAt && Date.parse(loop.nextCadenceAt) <= Date.parse(at);
+			const oneShotDue = !!loop.nextRunAt && Date.parse(loop.nextRunAt) <= Date.parse(at);
+			if (!cadenceDue && !oneShotDue) return void 0;
+			if ((await tx.select({ tokenHash: runLeases.tokenHash }).from(runLeases).where(and(eq(runLeases.loopId, id), eq(runLeases.state, "terminal-grace"), gt(runLeases.expiresAt, at))).limit(1))[0]) return void 0;
+			const open = (await tx.select({ id: runs.id }).from(runs).where(and(eq(runs.loopId, id), inArray(runs.phase, ["pending", "running"]))).limit(1))[0];
+			const skipRecurring = cadenceDue && !!open && (loop.scheduleMode === "continuous" || loop.cronOverlap === "skip");
+			const queued = oneShotDue || !skipRecurring ? await enqueueRunTx(tx, loop, { requestedBy: "system" }, at) : void 0;
+			if (queued && !("run" in queued)) return void 0;
+			const nextCadenceAt = cadenceDue ? loop.scheduleMode === "cron" ? nextCronAt(loop.cron, loop.timezone, at) : null : loop.nextCadenceAt;
+			const updatedLoop = (await tx.update(loops).set({
+				nextCadenceAt,
+				...oneShotDue ? { nextRunAt: null } : {},
+				updatedAt: at
+			}).where(eq(loops.id, id)).returning())[0];
+			return queued ? {
+				loop: updatedLoop,
+				run: queued.run,
+				state: queued.state
+			} : {
+				loop: updatedLoop,
+				state: "skipped"
+			};
+		});
+		if (result) advanced.push(result);
+	}
+	return advanced;
+}
+/** Conservative boot initialization for pre-fact cron rows. No history lookup and
+* no missed-fire catch-up: only install the next future occurrence. */
+async function initializeCronCadence(at = nowIso$1()) {
+	const candidates = await db.select({ id: loops.id }).from(loops).where(and(eq(loops.enabled, true), isNull(loops.deleteRequestedAt), eq(loops.scheduleMode, "cron"), isNull(loops.nextCadenceAt)));
+	const initialized = [];
+	for (const { id } of candidates) {
+		const loop = await db.transaction(async (tx) => {
+			const current = (await tx.select().from(loops).where(eq(loops.id, id)).for("update"))[0];
+			if (!current?.enabled || current.scheduleMode !== "cron" || current.nextCadenceAt) return void 0;
+			return (await tx.update(loops).set({
+				nextCadenceAt: nextCronAt(current.cron, current.timezone, at),
+				updatedAt: at
+			}).where(eq(loops.id, id)).returning())[0];
+		});
+		if (loop) initialized.push(loop);
+	}
+	return initialized;
+}
+/** Claim one ready loop and mint its lease atomically. Repeated polls may add
+* unlimited cross-loop concurrency; the loop index remains the final same-loop
+* serialization invariant. Reported local runs exclude their loops even if the
+* server has already terminalized an older process. */
+async function claimReadyRunForMachine(machineId, at = nowIso$1(), excludeRunIds = []) {
+	return db.transaction(async (tx) => {
+		if (!(await tx.select({ id: machines.id }).from(machines).where(eq(machines.id, machineId)).for("update"))[0]) return void 0;
+		const excludedLoops = /* @__PURE__ */ new Set();
+		if (excludeRunIds.length) {
+			const rows = await tx.select({ loopId: runs.loopId }).from(runs).where(and(eq(runs.machineId, machineId), inArray(runs.id, [...new Set(excludeRunIds)])));
+			for (const row of rows) excludedLoops.add(row.loopId);
+		}
+		const next = (await tx.select({
+			run: runs,
+			loop: loops
+		}).from(runs).innerJoin(loops, eq(loops.id, runs.loopId)).where(and(eq(runs.machineId, machineId), eq(runs.phase, "pending"), isNull(runs.cancelRequestedAt), or(eq(loops.enabled, true), eq(runs.requestedBy, "owner")), isNull(loops.deleteRequestedAt), excludedLoops.size ? notInArray(loops.id, [...excludedLoops]) : void 0, sql`not exists (select 1 from runs occupied where occupied.loop_id = ${loops.id} and occupied.phase = 'running')`, sql`not exists (select 1 from run_leases authority where authority.loop_id = ${loops.id} and (authority.state = 'active' or (authority.state = 'terminal-grace' and authority.expires_at > ${at})))`)).orderBy(asc(runs.createdAt), asc(runs.id)).limit(1))[0];
+		if (!next) return void 0;
+		let loop = (await tx.select().from(loops).where(eq(loops.id, next.loop.id)).for("update"))[0];
+		const candidate = (await tx.select().from(runs).where(eq(runs.id, next.run.id)).limit(1).for("update"))[0];
+		if (!loop || !candidate || candidate.phase !== "pending" || candidate.cancelRequestedAt || loop.deleteRequestedAt || !loop.enabled && candidate.requestedBy !== "owner") return void 0;
+		const occupied = (await tx.select({ id: runs.id }).from(runs).where(and(eq(runs.loopId, loop.id), eq(runs.phase, "running"))).limit(1))[0];
+		const authority = (await tx.select({ tokenHash: runLeases.tokenHash }).from(runLeases).where(and(eq(runLeases.loopId, loop.id), inArray(runLeases.state, ["active", "terminal-grace"]), or(eq(runLeases.state, "active"), gt(runLeases.expiresAt, at)))).limit(1))[0];
+		if (occupied || authority) return void 0;
+		const runIndex = await ensureRunIndexTx(tx, candidate);
+		const run = (await tx.update(runs).set({
+			phase: "running",
+			runIndex,
+			agent: loop.agent,
+			model: loop.model,
+			reasoningEffort: loop.reasoningEffort,
+			heartbeatAt: null,
+			ts: at,
+			updatedAt: at
+		}).where(and(eq(runs.id, candidate.id), eq(runs.phase, "pending"), isNull(runs.cancelRequestedAt))).returning())[0];
+		if (!run) return void 0;
+		if (loop.scheduleMode === "continuous" && loop.nextCadenceAt != null) loop = (await tx.update(loops).set({
+			nextCadenceAt: null,
+			updatedAt: at
+		}).where(eq(loops.id, loop.id)).returning())[0];
+		const runToken = `rk_${randomBytes(16).toString("hex")}`;
+		const tokenHash = createHash("sha256").update(runToken).digest("hex");
+		await tx.insert(runLeases).values({
+			tokenHash,
+			runId: run.id,
+			loopId: loop.id,
+			machineId,
+			createdAt: at
+		});
+		return {
+			run,
+			loop,
+			runToken
+		};
+	});
+}
+async function listRuns(loopId, limit = 30) {
+	return (await db.select().from(runs).where(eq(runs.loopId, loopId)).orderBy(desc(runs.ts)).limit(limit)).reverse();
+}
+async function reconciliationStatesForRuns(loopId, runIds, at = nowIso$1()) {
+	if (!runIds.length) return /* @__PURE__ */ new Map();
+	const rows = await db.select({
+		runId: runLeases.runId,
+		state: runLeases.state
+	}).from(runLeases).where(and(eq(runLeases.loopId, loopId), inArray(runLeases.runId, [...new Set(runIds)]), inArray(runLeases.state, ["terminal-grace", "reconciliation-only"]), gt(runLeases.expiresAt, at)));
+	return new Map(rows.map((row) => [row.runId, row.state === "terminal-grace" ? "blocking" : "report-only"]));
+}
+/** One older page: runs strictly before `beforeTs`, newest-first then capped,
+*  returned chronological (oldest-first) to match listRuns. Cursor-based (by ts,
+*  not offset) so it's stable while new runs land at the head. */
+async function listRunsBefore(loopId, beforeTs, limit = 16) {
+	return (await db.select().from(runs).where(and(eq(runs.loopId, loopId), lt(runs.ts, beforeTs))).orderBy(desc(runs.ts)).limit(limit)).reverse();
+}
+async function lastRun(loopId) {
+	return (await db.select().from(runs).where(eq(runs.loopId, loopId)).orderBy(desc(runs.ts)).limit(1))[0];
+}
+async function countRuns(loopId) {
+	const r = (await db.select({ n: sql`count(*)` }).from(runs).where(eq(runs.loopId, loopId)))[0];
+	return Number(r?.n ?? 0);
+}
+async function recentLoopUsage(loopId, since) {
+	const row = (await db.select({
+		runCount: sql`count(*)`,
+		tokenCount: sql`coalesce(sum(
+        coalesce((${runs.usage} ->> 'inputTokens')::bigint, 0) +
+        coalesce((${runs.usage} ->> 'outputTokens')::bigint, 0)
+      ), 0)`
+	}).from(runs).where(and(eq(runs.loopId, loopId), sql`${runs.ts} >= ${since}`)))[0];
+	return {
+		runCount: Number(row?.runCount ?? 0),
+		tokenCount: Number(row?.tokenCount ?? 0)
+	};
+}
+async function openRuns() {
+	return db.select().from(runs).where(inArray(runs.phase, ["pending", "running"]));
+}
+async function hasRunningRun(loopId) {
+	return !!(await db.select({ id: runs.id }).from(runs).where(and(eq(runs.loopId, loopId), eq(runs.phase, "running"))).limit(1))[0];
+}
+async function hasPendingRun(loopId) {
+	return !!(await db.select({ id: runs.id }).from(runs).where(and(eq(runs.loopId, loopId), eq(runs.phase, "pending"))).limit(1))[0];
+}
+/** Expire one offline system row only if the sweep snapshot is still exact and
+* its immutable lifetime remains over the cap under the loop lock. */
+async function expirePendingRun(runId, expected, at, maxLifetimeMs, message) {
+	return db.transaction(async (tx) => {
+		const observed = (await tx.select({ loopId: runs.loopId }).from(runs).where(eq(runs.id, runId)).limit(1))[0];
+		if (!observed) return false;
+		const loop = (await tx.select({ id: loops.id }).from(loops).where(eq(loops.id, observed.loopId)).for("update"))[0];
+		if (!loop) return false;
+		const current = (await tx.select().from(runs).where(and(eq(runs.id, runId), eq(runs.loopId, loop.id), eq(runs.phase, "pending"), eq(runs.requestedBy, "system"), eq(runs.requestedBy, expected.requestedBy), eq(runs.updatedAt, expected.updatedAt))).limit(1).for("update"))[0];
+		if (!current || Date.parse(at) - Date.parse(current.createdAt) <= maxLifetimeMs) return false;
+		if ((await tx.select({ online: machines.online }).from(machines).where(eq(machines.id, current.machineId)).limit(1))[0]?.online) return false;
+		const runIndex = await ensureRunIndexTx(tx, current);
+		return (await tx.update(runs).set({
+			phase: "canceled",
+			runIndex,
+			message,
+			ts: at,
+			updatedAt: at
+		}).where(and(eq(runs.id, runId), eq(runs.phase, "pending"), eq(runs.requestedBy, "system"), eq(runs.updatedAt, expected.updatedAt))).returning({ id: runs.id })).length > 0;
+	});
+}
+async function listMachines() {
+	return db.select().from(machines).orderBy(asc(machines.name), asc(machines.id));
+}
+async function getMachine(id) {
+	return (await db.select().from(machines).where(eq(machines.id, id)))[0];
+}
+async function createMachine(input) {
+	return (await db.insert(machines).values({
+		...input,
+		createdAt: nowIso$1()
+	}).returning())[0];
+}
+async function updateMachine(id, patch) {
+	await db.update(machines).set(patch).where(eq(machines.id, id));
+	return getMachine(id);
+}
+/** Atomically retire all loop authority, remove server-owned machine data, revoke
+* enrollment, and delete the machine. */
+async function forceDeleteMachine(id) {
+	return db.transaction(async (tx) => {
+		if (!(await tx.select({ id: machines.id }).from(machines).where(eq(machines.id, id)).for("update"))[0]) return { state: "not-found" };
+		const ownedLoops = await tx.select().from(loops).where(eq(loops.machineId, id)).for("update");
+		for (const loop of ownedLoops) if (!await forceDeleteLoopTx(tx, loop.id)) throw new Error(`failed to delete loop ${loop.id}`);
+		await tx.delete(connectKeys).where(eq(connectKeys.machineId, id));
+		await tx.delete(machines).where(eq(machines.id, id));
+		return {
+			state: "deleted",
+			loopIds: ownedLoops.map((loop) => loop.id)
+		};
+	});
+}
+async function setMachineOnline(id, online) {
+	await db.update(machines).set({
+		online,
+		lastSeen: nowIso$1()
+	}).where(eq(machines.id, id));
+}
+/** 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) {
+	if (!hashes.length) return /* @__PURE__ */ new Map();
+	const rows = await db.select({
+		hash: blobs.hash,
+		size: blobs.size
+	}).from(blobs).where(inArray(blobs.hash, [...new Set(hashes)]));
+	return new Map(rows.map((row) => [row.hash, row.size]));
+}
+async function recordBlob(hash, size) {
+	await db.insert(blobs).values({
+		hash,
+		size,
+		createdAt: nowIso$1()
+	}).onConflictDoNothing();
+}
+async function writeConfiguredArtifactTx(tx, input, ts) {
+	await tx.insert(artifactFiles).values({
+		id: randomUUID(),
+		loopId: input.loopId,
+		path: input.path,
+		hash: input.hash,
+		size: input.size,
+		binary: input.binary,
+		oversize: input.oversize,
+		deleted: false,
+		updatedAt: ts
+	}).onConflictDoUpdate({
+		target: [artifactFiles.loopId, artifactFiles.path],
+		set: {
+			hash: input.hash,
+			size: input.size,
+			binary: input.binary,
+			oversize: input.oversize,
+			deleted: false,
+			updatedAt: ts
+		}
+	});
+}
+/** 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().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;
+	});
+}
+/** 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);
+}
+async function getArtifactFile(loopId, path) {
+	return (await db.select().from(artifactFiles).where(and(eq(artifactFiles.loopId, loopId), eq(artifactFiles.path, path))))[0];
+}
+async function buildLoopManifest(loopId) {
+	const manifest = {};
+	for (const f of await listArtifacts(loopId)) manifest[f.path] = {
+		hash: f.hash,
+		size: f.size,
+		binary: f.binary,
+		oversize: f.oversize
+	};
+	return manifest;
+}
+/** 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,
+		loopId,
+		manifest,
+		createdAt: nowIso$1()
+	}).onConflictDoUpdate({
+		target: runSnapshots.runId,
+		set: {
+			loopId,
+			manifest,
+			createdAt: nowIso$1()
+		}
+	});
+}
+async function getRunSnapshot(runId) {
+	return (await db.select().from(runSnapshots).where(eq(runSnapshots.runId, runId)))[0];
+}
+/** The most recent indexed snapshot before one run. History order, not a
+* timestamp tie, is the diff baseline. */
+async function prevRunSnapshot(loopId, beforeRunIndex) {
+	return (await db.select({ snap: runSnapshots }).from(runSnapshots).innerJoin(runs, eq(runSnapshots.runId, runs.id)).where(and(eq(runSnapshots.loopId, loopId), isNotNull(runs.runIndex), lt(runs.runIndex, beforeRunIndex))).orderBy(desc(runs.runIndex)).limit(1))[0]?.snap;
+}
+/**
+* Prune a loop's run snapshots down to the `keep` most recent (by createdAt),
+* deleting the rest. Returns the number deleted. This is what makes an old
+* snapshot's now-unreferenced blobs collectable by the blob GC. `keep <= 0`
+* means "keep none" (still bounded). Safe to call repeatedly (idempotent once
+* at/under the window).
+*/
+async function pruneRunSnapshots(loopId, keep) {
+	const survivors = keep > 0 ? (await db.select({ runId: runSnapshots.runId }).from(runSnapshots).where(eq(runSnapshots.loopId, loopId)).orderBy(desc(runSnapshots.createdAt), desc(runSnapshots.runId)).limit(keep)).map((r) => r.runId) : [];
+	const pred = survivors.length ? and(eq(runSnapshots.loopId, loopId), notInArray(runSnapshots.runId, survivors)) : eq(runSnapshots.loopId, loopId);
+	return (await db.delete(runSnapshots).where(pred).returning({ id: runSnapshots.runId })).length;
+}
+async function loopIdsWithSnapshots() {
+	return (await db.selectDistinct({ loopId: runSnapshots.loopId }).from(runSnapshots)).map((r) => r.loopId);
+}
+/**
+* The full set of blob hashes still referenced by a LIVE row — the GC's keep
+* set. A hash is live if ANY artifact_files row points at it (deleted tombstones
+* carry hash=null, so they don't pin a blob) OR ANY retained run_snapshot's
+* manifest references it. Computed in one pass so the GC never deletes a blob a
+* snapshot still needs for its diff.
+*/
+async function liveBlobRefs() {
+	const refs = /* @__PURE__ */ new Set();
+	for (const r of await db.selectDistinct({ hash: artifactFiles.hash }).from(artifactFiles).where(isNotNull(artifactFiles.hash))) if (r.hash) refs.add(r.hash);
+	for (const hash of await collectSnapshotBlobRefs()) refs.add(hash);
+	return refs;
+}
+/** Blob hashes whose metadata row predates `cutoffIso` (GC candidates — the grace
+*  window excludes freshly-written blobs a concurrent sync may be referencing). */
+async function blobHashesOlderThan(cutoffIso) {
+	return (await db.select({ hash: blobs.hash }).from(blobs).where(lt(blobs.createdAt, cutoffIso))).map((r) => r.hash);
+}
+/** Delete a blob's metadata row (the bytes are reclaimed separately via the
+*  BlobStore). Idempotent. */
+async function deleteBlob(hash) {
+	await db.delete(blobs).where(eq(blobs.hash, hash));
+}
+/** Indexed point check: does any LIVE artifact_files row still point at this hash?
+*  The GC's cheap, always-fresh per-candidate guard (the common re-reference path) —
+*  uses the artifact_files_hash index, so it stays O(1) even as candidates pile up. */
+async function artifactFileReferencesHash(hash) {
+	return !!(await db.select({ id: artifactFiles.id }).from(artifactFiles).where(eq(artifactFiles.hash, hash)))[0];
+}
+/** Every blob hash referenced by ANY retained run_snapshot's manifest — the full
+*  snapshot scan deserialized ONCE into a Set so the GC can answer per-candidate
+*  snapshot membership in O(1) instead of re-scanning the whole table per garbage
+*  hash. The GC rebuilds this only when the snapshot row count changes (a report()
+*  raced the pass), so a snapshot that comes to reference a hash mid-pass is still
+*  caught — closing the GC-check-time gap where a snapshot references a hash no live
+*  file row does — without paying O(garbage × snapshots). */
+async function collectSnapshotBlobRefs() {
+	const refs = /* @__PURE__ */ new Set();
+	for (const r of await db.select({ manifest: runSnapshots.manifest }).from(runSnapshots)) for (const entry of Object.values(r.manifest)) if (entry?.hash) refs.add(entry.hash);
+	return refs;
+}
+async function snapshotBlobRefs() {
+	return collectSnapshotBlobRefs();
+}
+/** Count of retained run_snapshot rows — the GC's cheap change-detector for deciding
+*  whether to rebuild its precomputed snapshotBlobRefs() set mid-pass. */
+async function countRunSnapshots() {
+	const r = (await db.select({ n: sql`count(*)` }).from(runSnapshots))[0];
+	return Number(r?.n ?? 0);
+}
+/**
+* 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.
+*
+* 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.
+*/
+var tokens_exports = /* @__PURE__ */ __exportAll({
+	CONNECT_KEY_TTL_MS: () => CONNECT_KEY_TTL_MS,
+	NEW_IDEMPOTENCY_TTL_MS: () => NEW_IDEMPOTENCY_TTL_MS,
+	TERMINAL_GRACE_MS: () => TERMINAL_GRACE_MS,
+	connectKeyValid: () => connectKeyValid,
+	isDeviceTokenShape: () => isDeviceTokenShape,
+	isRunTokenShape: () => isRunTokenShape,
+	machineIdFromToken: () => machineIdFromToken,
+	mintDeviceToken: () => mintDeviceToken,
+	pruneExpiredLeases: () => pruneExpiredLeases,
+	readNewIdempotency: () => readNewIdempotency,
+	recordNewIdempotency: () => recordNewIdempotency,
+	rememberConnectKey: () => rememberConnectKey,
+	resolveLease: () => resolveLease,
+	retireLease: () => retireLease,
+	sha256: () => sha256
+});
+function sha256(s) {
+	return createHash("sha256").update(s).digest("hex");
+}
+function mintDeviceToken() {
+	return `dk_${randomBytes(15).toString("hex")}`;
+}
+function machineIdFromToken(token) {
+	return `m-${sha256(token).slice(0, 16)}`;
+}
+/**
+* Whether a string has the one current device-token wire shape. This malformed-input
+* filter runs before enrollment lookup; the connect-key gate remains the auth boundary.
+*/
+var DEVICE_TOKEN_RE = /^dk_[0-9a-f]{30}$/;
+function isDeviceTokenShape(token) {
+	return DEVICE_TOKEN_RE.test(token);
+}
+/** Keep bindings long enough for a leisurely paste, then drop (bounded table). */
+var CONNECT_KEY_TTL_MS = 1440 * 60 * 1e3;
+function connectKeyFresh(mintedAt, now) {
+	return now - Date.parse(mintedAt) <= CONNECT_KEY_TTL_MS;
+}
+/** Record a freshly minted connect key and prune expired rows. */
+async function rememberConnectKey(connectKey) {
+	const now = /* @__PURE__ */ new Date();
+	await db.delete(connectKeys).where(lt(connectKeys.mintedAt, (/* @__PURE__ */ new Date(now.getTime() - CONNECT_KEY_TTL_MS)).toISOString()));
+	const row = {
+		machineId: machineIdFromToken(connectKey),
+		mintedAt: now.toISOString()
+	};
+	await db.insert(connectKeys).values(row).onConflictDoUpdate({
+		target: connectKeys.machineId,
+		set: row
+	});
+}
+async function connectKeyValid(connectKey, now = Date.now()) {
+	if (!connectKey) return false;
+	const row = (await db.select().from(connectKeys).where(eq(connectKeys.machineId, machineIdFromToken(connectKey))))[0];
+	return !!row && connectKeyFresh(row.mintedAt, now);
+}
+/** How long a terminal-grace lease stays alive to accept one late wake-report.
+*  A laptop can sleep overnight or across a weekend before the daemon resumes. */
+var TERMINAL_GRACE_MS = 1440 * 60 * 1e3;
+/** Leases live in the `run_leases` table, keyed by sha256(full `rk_…` wire
+* token), so a deploy is invisible to an in-flight run and a DB leak never hands
+* out live credentials. In rows, `expiresAt` null encodes `Infinity`. */
+function leaseFromRow(row) {
+	return {
+		runId: row.runId,
+		loopId: row.loopId,
+		machineId: row.machineId,
+		state: row.state,
+		expiresAt: row.expiresAt == null ? Number.POSITIVE_INFINITY : Date.parse(row.expiresAt)
+	};
+}
+/** Mint a fresh run lease and return its wire token (`rk_…`, so the unified CLI
+*  dispatch can tell a run credential from a device `dk_…` in O(1) before any
+*  lookup). Starts `active` with no expiry. */
+var RUN_TOKEN_RE = /^rk_[0-9a-f]{32}$/;
+function isRunTokenShape(token) {
+	return RUN_TOKEN_RE.test(token);
+}
+/** Resolve a run lease. An elapsed reconciliation window is atomically reduced
+* to durable, non-authorizing retired evidence rather than deleted. */
+async function resolveLease(token, now = Date.now()) {
+	if (!isRunTokenShape(token)) return void 0;
+	const tokenHash = sha256(token);
+	let row = (await db.select().from(runLeases).where(eq(runLeases.tokenHash, tokenHash)))[0];
+	if (!row) return void 0;
+	if ((row.state === "terminal-grace" || row.state === "reconciliation-only") && row.expiresAt != null && now > Date.parse(row.expiresAt)) {
+		row = (await db.update(runLeases).set({
+			state: "retired",
+			expiresAt: null
+		}).where(and(eq(runLeases.tokenHash, tokenHash), inArray(runLeases.state, ["terminal-grace", "reconciliation-only"]), isNotNull(runLeases.expiresAt), lt(runLeases.expiresAt, new Date(now).toISOString()))).returning())[0] ?? (await db.select().from(runLeases).where(eq(runLeases.tokenHash, tokenHash)))[0];
+		if (!row) return void 0;
+	}
+	return leaseFromRow(row);
+}
+/** Retire a lease outside a terminal write transaction (canceled/losing report
+* cleanup and expiry paths). Normal finalize and reclaimed-run
+* reconcile consume the row inside their store transaction so run+loop+lease are
+* one single-shot commit. */
+async function retireLease(token) {
+	await db.delete(runLeases).where(eq(runLeases.tokenHash, sha256(token)));
+}
+/** State-aware lease maintenance. Expired reconciliation authority becomes a
+* durable retired tombstone. Active and already-retired rows are never age-pruned. */
+async function pruneExpiredLeases(now = Date.now()) {
+	await db.update(runLeases).set({
+		state: "retired",
+		expiresAt: null
+	}).where(and(inArray(runLeases.state, ["terminal-grace", "reconciliation-only"]), isNotNull(runLeases.expiresAt), lt(runLeases.expiresAt, new Date(now).toISOString())));
+}
+var newIdempotency = /* @__PURE__ */ new Map();
+/** Long enough to swallow a timed-out retry without collapsing later creates. */
+var NEW_IDEMPOTENCY_TTL_MS = 900 * 1e3;
+function pruneNewIdempotency(now) {
+	for (const [key, rec] of newIdempotency) if (now - rec.at > 9e5) newIdempotency.delete(key);
+}
+function recordNewIdempotency(key, machineId, loopId, now = Date.now()) {
+	pruneNewIdempotency(now);
+	newIdempotency.set(key, {
+		loopId,
+		machineId,
+		at: now
+	});
+}
+/** The loop a still-live key already created for THIS machine, or undefined (a miss,
+*  an expired key — dropped here — or a cross-machine record). NON-evicting on a hit:
+*  a genuine retry may arrive more than once within the window. */
+function readNewIdempotency(key, machineId, now = Date.now()) {
+	const rec = newIdempotency.get(key);
+	if (!rec) return void 0;
+	if (now - rec.at > 9e5) {
+		newIdempotency.delete(key);
+		return;
+	}
+	if (rec.machineId !== machineId) return void 0;
+	return rec.loopId;
+}
+/**
+* Derive a machine's presence from its stored `online` flag + `lastSeen` stamp.
+* `online` requires BOTH the flag and a fresh stamp (the stored flag lags the
+* sweep by up to one interval); everything else keys off how stale `lastSeen` is.
+*/
+function machinePresence(online, lastSeen, now = Date.now()) {
+	const seenAt = lastSeen ? Date.parse(lastSeen) : NaN;
+	if (!Number.isFinite(seenAt)) return "offline";
+	const age = now - seenAt;
+	if (!!online && age < 3e4) return "online";
+	if (age < 216e5) return "asleep";
+	return "offline";
+}
+/**
+* Tiny semver comparison — just enough to decide "is the daemon older than the
+* latest published version?" for the web's update hint. No dependency; we only
+* need numeric-core ordering (major.minor.patch), and a pre-release is treated
+* as older than its release (a "0.9.0-rc.1" daemon is still behind "0.9.0").
+*/
+/** Strict SemVer validation for security/protocol gates. Unlike the update-hint
+* comparison below, this accepts no whitespace, `v` prefix, partial core, or
+* trailing garbage. */
+function isValidSemver(value) {
+	const plus = value.split("+");
+	if (plus.length > 2) return false;
+	const [versionAndPre, build] = plus;
+	if (build !== void 0 && !validIdentifiers(build, false)) return false;
+	const dash = versionAndPre.indexOf("-");
+	const numeric = dash < 0 ? versionAndPre : versionAndPre.slice(0, dash);
+	const pre = dash < 0 ? void 0 : versionAndPre.slice(dash + 1);
+	if (!/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(numeric)) return false;
+	return pre === void 0 || validIdentifiers(pre, true);
+}
+function validIdentifiers(value, rejectNumericLeadingZero) {
+	if (!value) return false;
+	return value.split(".").every((identifier) => {
+		if (!/^[0-9A-Za-z-]+$/.test(identifier)) return false;
+		return !rejectNumericLeadingZero || !/^\d+$/.test(identifier) || identifier === "0" || !identifier.startsWith("0");
+	});
+}
+function core(v) {
+	const m = /^\s*v?(\d+)\.(\d+)\.(\d+)/.exec(v);
+	if (!m) return null;
+	return [
+		Number(m[1]),
+		Number(m[2]),
+		Number(m[3])
+	];
+}
+function isPre(v) {
+	return /^\s*v?\d+\.\d+\.\d+-/.test(v);
+}
+/**
+* `true` when `current` is strictly older than `latest`. Returns `false` on any
+* unparseable/equal/newer input — the hint is opt-in, so we only ever show it
+* when we can be confident the daemon is genuinely behind.
+*/
+function isOutdated(current, latest) {
+	if (!current || !latest) return false;
+	const a = core(current);
+	const b = core(latest);
+	if (!a || !b) return false;
+	for (let i = 0; i < 3; i++) {
+		const ai = a[i];
+		const bi = b[i];
+		if (ai < bi) return true;
+		if (ai > bi) return false;
+	}
+	return isPre(current) && !isPre(latest);
+}
+var reserved = new Set(RESERVED_LOOP_TAGS);
+function normalizeLoopTag(value) {
+	return value.normalize("NFKC").trim().replace(/\s+/gu, " ").toLocaleLowerCase("en-US");
+}
+function validateLoopTags(value) {
+	if (value === void 0) return {
+		ok: true,
+		value: []
+	};
+	if (!Array.isArray(value)) return {
+		ok: false,
+		detail: "tags must be an array of strings"
+	};
+	if (value.length > 4) return {
+		ok: false,
+		detail: `tags must contain at most 4 values`
+	};
+	const tags = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of value) {
+		if (typeof entry !== "string") return {
+			ok: false,
+			detail: "tags must contain only strings"
+		};
+		if (/\p{Cc}|\p{Cf}|\p{Default_Ignorable_Code_Point}/u.test(entry)) return {
+			ok: false,
+			detail: "tags must not contain control or invisible characters"
+		};
+		const tag = normalizeLoopTag(entry);
+		if (!tag) return {
+			ok: false,
+			detail: "tags must not contain empty values"
+		};
+		if ([...tag].length > 64) return {
+			ok: false,
+			detail: `each tag must contain at most 64 characters`
+		};
+		if (reserved.has(tag)) return {
+			ok: false,
+			detail: `reserved tag: ${tag}`
+		};
+		if (seen.has(tag)) return {
+			ok: false,
+			detail: `duplicate tag: ${tag}`
+		};
+		seen.add(tag);
+		tags.push(tag);
+	}
+	return {
+		ok: true,
+		value: [...tags].sort()
+	};
+}
+//#endregion
+//#region node_modules/.nitro/vite/services/ssr/assets/boot-DmpKtb0A.js
+var boot_DmpKtb0A_exports = /* @__PURE__ */ __exportAll$1({
 	_: () => validOptionalPollString,
 	a: () => POLL_HTTP_BODY_FIELDS,
 	c: () => MIN_DAEMON_VERSION,
-	d: () => statusDefinitionsFromLoop,
+	d: () => canonicalLoopSummary,
 	f: () => validateLoopEdit,
 	g: () => readJsonBody,
 	h: () => readByteBody,
 	i: () => runDiff_exports,
 	l: () => daemonNeedsUpdate,
-	m: () => POLL_INFO_TEXT_CAP,
+	m: () => WIRE_TEXT_CAP,
 	n: () => ensureServer,
 	o: () => validPollCurrentRun,
 	p: () => MACHINE_BODY_CAP,
-	r: () => getArtifactSync,
+	r: () => getLoopFiles,
 	s: () => validPollWireId,
 	t: () => boot_exports,
-	u: () => scheduleFromLoop
+	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. */
@@ -116,7 +2299,7 @@ function nowIso() {
 /** 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 index.ts's `str` - and used directly by `cli.ts`
+*  `clipText` - and used directly by `cli.ts`
 *  (parseFlags/validateState, the same one-chokepoint discipline). */
 function stripNul(s) {
 	return s.replace(/\u0000/g, "");
@@ -124,15 +2307,54 @@ function stripNul(s) {
 function clipText(s, cap) {
 	return stripNul(s.slice(0, cap));
 }
+/** Literal placeholder the daemon replaces with the run's absolute loop-file
+*  directory before launch (and exports as an env var of the same name). */
+var LOOP_DIR_PLACEHOLDER = "$PIEVO_LOOP_DIR";
+var STATUS_LINE_RE = /^STATUS:\s*(keep|no-change|block)\.?$/i;
 /**
-* Deliver the user's prompt unchanged, followed only by the complete report
-* contract. The run index intentionally remains an internal history fact.
+* 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) {
-	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>`;
+function buildRunTask(loop, previousNotices = []) {
+	const files = [`- ${MEMORY_FILE}: this loop's memory, kept across runs (max ${MEMORY_CHAR_CAP} characters). Read it before you start. Before finishing, update it with anything that would help future runs avoid mistakes or work faster. Keep it concise: merge similar notes, delete stale or wrong ones, no run logs.`, ...loop.artifacts.map((name) => `- ${name}: artifact shown on the Pievo dashboard (max 2 MB). Update it only as the task above asks.`)];
+	const notices = previousNotices.length ? `\n\nNotices from the previous run:\n${previousNotices.map((notice) => `- ${notice}`).join("\n")}` : "";
+	return `${loop.prompt}
+
+Status definitions:
+- keep: ${loop.statusKeep}
+- no-change: ${loop.statusNoChange}
+- block: ${loop.statusBlock}
+
+Loop files in ${LOOP_DIR_PLACEHOLDER}:
+${files.join("\n")}
+A file over its limit is rejected and its previous version kept. Other files in that directory are discarded.${notices}
+
+End your final response with a short summary, then exactly one last line:
+STATUS: keep|no-change|block`;
+}
+/**
+* Split a provider's final response into the reported status and summary. The
+* final non-empty line must be the status line; markdown emphasis or code ticks
+* around it are tolerated because models add them unprompted.
+*/
+function parseFinalStatus(finalText) {
+	if (!finalText) return void 0;
+	const lines = finalText.split(/\r?\n/);
+	let index = lines.length - 1;
+	while (index >= 0 && lines[index].trim() === "") index--;
+	if (index < 0) return void 0;
+	const bare = lines[index].trim().replace(/^[*_`>\s]+|[*_`\s]+$/g, "");
+	const match = STATUS_LINE_RE.exec(bare);
+	if (!match) return void 0;
+	return {
+		status: match[1].toLowerCase(),
+		message: lines.slice(0, index).join("\n").trim()
+	};
 }
 async function buildDelivery(loop, queuedRun, runToken, roots) {
 	if (queuedRun.runIndex == null) throw new Error(`claimed run ${queuedRun.id} has no history index`);
+	const notices = await previousRunFileNotices(loop.id, queuedRun.runIndex);
 	return {
 		runId: queuedRun.id,
 		runIndex: queuedRun.runIndex,
@@ -146,266 +2368,16 @@ async function buildDelivery(loop, queuedRun, runToken, roots) {
 			reasoningEffort: loop.reasoningEffort ?? null,
 			agent: loop.agent
 		},
-		task: buildRunTask(loop),
-		artifacts: loop.artifacts
+		task: buildRunTask(loop, notices),
+		files: loopFileNames(loop)
 	};
 }
 /**
-* 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.
-*
-* Three implementations behind one small interface:
-*   • LocalBlobStore — durable filesystem default under PIEVO_DATA_DIR/blobs.
-*   • R2BlobStore — Cloudflare R2 (S3-compatible) when credentials are configured.
-*   • MemoryBlobStore — explicit ephemeral selection or injected test fake.
-*
-* The S3 client is dynamic-imported inside R2BlobStore so tests (and any deploy
-* without R2 creds) never load the AWS SDK, and it stays out of the client bundle.
-*/
-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 MemoryBlobStore = class {
-	map = /* @__PURE__ */ new Map();
-	async has(hash) {
-		return this.map.has(hash);
-	}
-	async put(hash, bytes) {
-		this.map.set(hash, Buffer.from(bytes));
-	}
-	async get(hash) {
-		return this.map.get(hash) ?? null;
-	}
-	async delete(hash) {
-		this.map.delete(hash);
-	}
-};
-function blobKey(hash) {
-	return `blobs/${hash}`;
-}
-var R2BlobStore = class {
-	cfg;
-	client;
-	constructor(cfg) {
-		this.cfg = cfg;
-	}
-	async s3() {
-		if (this.client) return this.client;
-		const { S3Client } = await import("../_libs/@aws-sdk/client-s3+[...].mjs").then((n) => n.t);
-		this.client = new S3Client({
-			region: this.cfg.region,
-			endpoint: this.cfg.endpoint,
-			credentials: {
-				accessKeyId: this.cfg.accessKeyId,
-				secretAccessKey: this.cfg.secretAccessKey
-			},
-			forcePathStyle: true
-		});
-		return this.client;
-	}
-	async has(hash) {
-		const { HeadObjectCommand } = await import("../_libs/@aws-sdk/client-s3+[...].mjs").then((n) => n.t);
-		const client = await this.s3();
-		try {
-			await client.send(new HeadObjectCommand({
-				Bucket: this.cfg.bucket,
-				Key: blobKey(hash)
-			}));
-			return true;
-		} catch (err) {
-			if (isNotFound(err)) return false;
-			throw err;
-		}
-	}
-	async put(hash, bytes) {
-		const { PutObjectCommand } = await import("../_libs/@aws-sdk/client-s3+[...].mjs").then((n) => n.t);
-		await (await this.s3()).send(new PutObjectCommand({
-			Bucket: this.cfg.bucket,
-			Key: blobKey(hash),
-			Body: bytes,
-			ContentLength: bytes.length
-		}));
-	}
-	async get(hash) {
-		const { GetObjectCommand } = await import("../_libs/@aws-sdk/client-s3+[...].mjs").then((n) => n.t);
-		const client = await this.s3();
-		try {
-			const body = (await client.send(new GetObjectCommand({
-				Bucket: this.cfg.bucket,
-				Key: blobKey(hash)
-			}))).Body;
-			if (!body?.transformToByteArray) return null;
-			return Buffer.from(await body.transformToByteArray());
-		} catch (err) {
-			if (isNotFound(err)) return null;
-			throw err;
-		}
-	}
-	async delete(hash) {
-		const { DeleteObjectCommand } = await import("../_libs/@aws-sdk/client-s3+[...].mjs").then((n) => n.t);
-		await (await this.s3()).send(new DeleteObjectCommand({
-			Bucket: this.cfg.bucket,
-			Key: blobKey(hash)
-		}));
-	}
-};
-function isNotFound(err) {
-	const e = err;
-	return e?.name === "NotFound" || e?.name === "NoSuchKey" || e?.$metadata?.httpStatusCode === 404;
-}
-/**
-* The configured blob store: durable local filesystem under PIEVO_DATA_DIR by
-* default; complete R2 credentials preserve the existing R2 selection behavior,
-* while memory requires an explicit selector. Constructed once and shared by every
-* gateway so writes, reads, and GC use the same adapter.
-*/
-function createBlobStore() {
-	const selection = process.env.PIEVO_BLOB_STORE?.trim().toLowerCase();
-	if (selection && ![
-		"local",
-		"r2",
-		"memory"
-	].includes(selection)) throw new Error("PIEVO_BLOB_STORE must be local, r2, or memory");
-	if (selection === "memory") {
-		log$4.warn("blob store: EPHEMERAL MEMORY explicitly selected; all artifact bytes are lost on restart");
-		return new MemoryBlobStore();
-	}
-	if (selection === "local") {
-		const local = new LocalBlobStore();
-		log$4.info({ root: local.root }, "blob store: local filesystem (explicit)");
-		return local;
-	}
-	const cfg = r2Config();
-	if (selection === "r2" && !cfg) throw new Error("PIEVO_BLOB_STORE=r2 requires complete PIEVO_R2_* configuration");
-	if (cfg) {
-		log$4.info({
-			bucket: cfg.bucket,
-			endpoint: cfg.endpoint
-		}, "blob store: Cloudflare R2");
-		return new R2BlobStore(cfg);
-	}
-	const local = new LocalBlobStore();
-	log$4.info({ root: local.root }, "blob store: local filesystem");
-	return local;
-}
-/**
-* Artifact-storage retention + garbage collection — the policy that keeps the
-* local/R2 byte store from growing monotonically.
+* Loop-file storage retention + garbage collection — the policy that keeps the
+* local byte store from growing monotonically.
 *
-* The artifact pipeline is content-addressed: blob BYTES are keyed by sha256 and
-* deduped across every loop/run. When a path is deleted or its content changes,
+* The loop-file pipeline is content-addressed: blob BYTES are keyed by sha256 and
+* deduped across every loop/run. When a file is deleted or its content changes,
 * the OLD blob is no longer pointed at by the current file row — but nothing was
 * reclaiming it, so the byte store grew forever. This module closes that gap with two pieces:
 *
@@ -416,24 +2388,24 @@ function createBlobStore() {
 *      hash. CORRECTNESS over aggressiveness — a still-referenced blob is never
 *      deleted; a leaked blob is only a cost bug the next pass reclaims.
 *
-* Concurrency: gcBlobs is safe to run alongside active syncs. Three guards combine —
-* a grace window (a blob whose metadata row is younger than the window is never
-* collected, so a blob a sync just wrote/referenced is untouchable), a point
-* re-check of each candidate immediately before its bytes are deleted (so a blob
+* Concurrency: gcBlobs is safe alongside owner writes and run uploads. Three guards
+* combine — a grace window (a blob whose metadata row is younger than the window is
+* never collected, so a blob a run just uploaded is untouchable), a point re-check
+* of each candidate immediately before its bytes are deleted (so a blob
 * re-referenced before we touch it keeps both its bytes and metadata), and a
 * bytes-before-metadata delete ordering: each candidate's bytes are reclaimed
 * FIRST, then its metadata row is dropped unconditionally — so blobExists() goes
-* false and any sync that re-references the hash (even one that raced the byte
+* false and any writer that re-references the hash (even one that raced the byte
 * delete) re-uploads the bytes (self-healing). We never leave a live blobs row
 * pointing at deleted bytes.
 */
-var log$3 = logger.child({ mod: "retention" });
+var log$2 = logger.child({ mod: "retention" });
 /**
 * Prune every loop's run snapshots down to the configured retention window
 * (most-recent-N). Returns the total number pruned. This is what makes an old
 * snapshot's now-unreferenced blobs collectable by gcBlobs().
 */
-async function pruneSnapshots(keep = snapshotRetention()) {
+async function pruneSnapshots(keep = 20) {
 	let pruned = 0;
 	for (const loopId of await loopIdsWithSnapshots()) pruned += await pruneRunSnapshots(loopId, keep);
 	return pruned;
@@ -462,7 +2434,7 @@ async function pruneSnapshots(keep = snapshotRetention()) {
 *         so that file re-uploads its bytes on the next sync. We never leave a
 *         live blobs row pointing at deleted bytes.
 */
-async function gcBlobs(blobStore, graceMs = blobGcGraceMs()) {
+async function gcBlobs(blobStore, graceMs = BLOB_GC_GRACE_MS) {
 	const refs = await liveBlobRefs();
 	const garbage = (await blobHashesOlderThan(new Date(Date.now() - graceMs).toISOString())).filter((h) => !refs.has(h));
 	let snapCount = await countRunSnapshots();
@@ -480,7 +2452,7 @@ async function gcBlobs(blobStore, graceMs = blobGcGraceMs()) {
 			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");
@@ -488,16 +2460,10 @@ async function gcBlobs(blobStore, graceMs = blobGcGraceMs()) {
 	}
 	return reclaimed;
 }
-/**
-* One full storage-maintenance pass: prune snapshots, then GC the blobs they
-* freed (plus any already-unreferenced). Order matters — pruning first lets the
-* same pass reclaim the blobs it just unpinned. Idempotent and safe with no
-* garbage (returns zeros).
-*/
-async function maintainStorage(blobStore) {
-	const snapshotsPruned = await pruneSnapshots();
-	const blobsReclaimed = await gcBlobs(blobStore);
-	if (snapshotsPruned || blobsReclaimed) log$3.info({
+async function maintainStorage(blobStore, options = {}) {
+	const snapshotsPruned = await pruneSnapshots(options.keep);
+	const blobsReclaimed = await gcBlobs(blobStore, options.graceMs);
+	if (snapshotsPruned || blobsReclaimed) log$2.info({
 		snapshotsPruned,
 		blobsReclaimed
 	}, "storage maintenance");
@@ -832,44 +2798,37 @@ function validateStatusDefinitions(value) {
 		}
 	};
 }
-function validateArtifactPaths(value) {
+function validateArtifactNames(value) {
 	if (value === void 0 || value === null) return {
 		ok: true,
 		value: []
 	};
 	if (!Array.isArray(value)) return {
 		ok: false,
-		detail: "artifacts must be an array of exact relative file paths"
+		detail: "artifacts must be an array of file names"
+	};
+	if (value.length > 4) return {
+		ok: false,
+		detail: `at most 4 artifacts are allowed`
 	};
-	const paths = [];
+	const names = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const entry of value) {
-		if (typeof entry !== "string" || entry.length === 0) return {
-			ok: false,
-			detail: "artifact paths must be non-empty strings"
-		};
-		if (entry.includes("\0")) return {
-			ok: false,
-			detail: "artifact path must not contain NUL"
-		};
-		if (entry.startsWith("/") || entry.startsWith("\\") || /^[A-Za-z]:[\\/]/.test(entry)) return {
+		if (!validArtifactName(entry)) return {
 			ok: false,
-			detail: `artifact path must be relative to workdir: ${entry}`
+			detail: `artifact must be a plain .md or .html file name other than ${MEMORY_FILE} (letters, digits, . _ -; at most 64 characters before the extension): ${JSON.stringify(entry)}`
 		};
-		if (entry.split(/[\\/]/).some((part) => part === "" || part === "." || part === "..")) return {
+		const key = entry.toLowerCase();
+		if (seen.has(key)) return {
 			ok: false,
-			detail: `artifact path must not traverse or alias another path: ${entry}`
+			detail: `duplicate artifact name: ${entry}`
 		};
-		if (seen.has(entry)) return {
-			ok: false,
-			detail: `duplicate artifact path: ${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) {
@@ -911,6 +2870,15 @@ function statusDefinitionsFromLoop(loop) {
 	};
 }
 function canonicalLoopEnvelope(loop) {
+	return {
+		...canonicalLoopSummary(loop),
+		prompt: loop.prompt,
+		statusDefinitions: statusDefinitionsFromLoop(loop),
+		artifacts: loop.artifacts,
+		enabled: loop.enabled
+	};
+}
+function canonicalLoopSummary(loop) {
 	return {
 		id: loop.id,
 		name: loop.name,
@@ -919,11 +2887,7 @@ function canonicalLoopEnvelope(loop) {
 		workdir: loop.workdir,
 		agent: loop.agent,
 		model: loop.model ?? null,
-		reasoningEffort: loop.reasoningEffort ?? null,
-		prompt: loop.prompt,
-		statusDefinitions: statusDefinitionsFromLoop(loop),
-		artifacts: loop.artifacts,
-		enabled: loop.enabled
+		reasoningEffort: loop.reasoningEffort ?? null
 	};
 }
 function validateLoopCreate(value) {
@@ -949,7 +2913,7 @@ function validateLoopCreate(value) {
 	if (!schedule.ok) return schedule;
 	const statusDefinitions = validateStatusDefinitions(raw.statusDefinitions);
 	if (!statusDefinitions.ok) return statusDefinitions;
-	const artifacts = validateArtifactPaths(raw.artifacts);
+	const artifacts = validateArtifactNames(raw.artifacts);
 	if (!artifacts.ok) return artifacts;
 	const model = optionalProvider(raw.model, "model");
 	if (!model.ok) return model;
@@ -1044,7 +3008,7 @@ function validateLoopEdit(loop, value) {
 		update.statusBlock = result.value.block;
 	}
 	if (raw.artifacts !== void 0) {
-		const result = validateArtifactPaths(raw.artifacts);
+		const result = validateArtifactNames(raw.artifacts);
 		if (!result.ok) return result;
 		update.artifacts = result.value;
 	}
@@ -1080,7 +3044,7 @@ function validateLoopEdit(loop, value) {
 		value: update
 	};
 }
-var MIN_DAEMON_VERSION = "2.4.0";
+var MIN_DAEMON_VERSION = "4.0.0";
 function daemonNeedsUpdate(current, required = MIN_DAEMON_VERSION) {
 	if (!current || !isValidSemver(current) || !isValidSemver(required)) return true;
 	if (current === required) return false;
@@ -1121,6 +3085,7 @@ var validPollInfo = (value) => value === void 0 || value !== null && typeof valu
 *
 *   POST /api/machine/poll   (Bearer device token) → claim pending runs, deliver
 *   POST /machine/report     (Bearer run token)    → finalize a run
+*   GET|PUT /api/machine/run-files/:name (Bearer run token) → loop-file transfer
 *
 * plus owner create/list/edit methods and retention.
 * Also exposes `dispatcher` (a `Dispatcher` for the Scheduler: "is the machine
@@ -1129,7 +3094,7 @@ var validPollInfo = (value) => value === void 0 || value !== null && typeof valu
 * (`CliGateway`), which reuses this class's owner methods;
 * canonical loop configuration validation lives in `gateway/loopConfig.ts`.
 */
-var log$2 = logger.child({ mod: "gateway" });
+var log$1 = logger.child({ mod: "gateway" });
 var ONLINE_TTL_MS = 3e4;
 /** Auto-pause after this many consecutive errors. Canceled rows are transparent;
 *  zero disables the breaker. */
@@ -1140,14 +3105,19 @@ var configuredRunTimeoutMs = Number(process.env.PIEVO_RUN_TIMEOUT_MS || 20 * 6e4
 var RUN_TIMEOUT_MS = Number.isFinite(configuredRunTimeoutMs) && configuredRunTimeoutMs > 0 ? configuredRunTimeoutMs : 20 * 6e4;
 /** The ONLY keys an owner `editLoop` patch may touch. A key outside this set is
 *  rejected (400) rather than silently ignored, so a `--json` typo fails loudly
-*  and identity/ownership columns (id/userId/machineId/timestamps) can never be
+*  and identity columns (id/machineId/timestamps) can never be
 *  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;
@@ -1162,7 +3132,7 @@ var HEARTBEAT_STAMP_REFRESH_MS = heartbeatRefreshMs(RUN_TIMEOUT_MS);
 *  and an idle poll becomes read-only, with worst-case staleness well inside
 *  the 30s TTL (max stamp gap = refresh + one poll interval). */
 var LAST_SEEN_REFRESH_MS = 1e4;
-var MACHINE_REPORT_FIELD_SET = new Set([
+var MACHINE_REPORT_FIELDS = [
 	"reportId",
 	"runId",
 	"result",
@@ -1171,8 +3141,17 @@ var MACHINE_REPORT_FIELD_SET = new Set([
 	"sessionId",
 	"usage",
 	"error",
-	"finalText"
-]);
+	"finalText",
+	"files",
+	"fileNotices"
+];
+var REPORT_FILE_FIELDS = [
+	"baseHash",
+	"hash",
+	"name",
+	"size"
+];
+var MACHINE_REPORT_FIELD_SET = new Set(MACHINE_REPORT_FIELDS);
 var MACHINE_REPORT_USAGE_FIELDS = new Set([
 	"inputTokens",
 	"outputTokens",
@@ -1201,7 +3180,7 @@ function receiptFor(body, runId, ackStatus = 200, ackBody) {
 }
 function receiptResponse(receipt, expected) {
 	if (!receipt || receipt.runId !== expected.runId) return void 0;
-	if (receipt.payloadDigest !== expected.payloadDigest) log$2.warn({
+	if (receipt.payloadDigest !== expected.payloadDigest) log$1.warn({
 		reportId: expected.reportId,
 		runId: expected.runId
 	}, "report: same-run payload changed after commit; replaying authoritative ACK");
@@ -1229,7 +3208,7 @@ async function committedReportEvidence(reportId, payloadDigest, authoritativeRun
 			foreignRun: false
 		};
 		if (normal?.runId === authoritativeRunId) {
-			if (normal.payloadDigest !== payloadDigest) log$2.warn({
+			if (normal.payloadDigest !== payloadDigest) log$1.warn({
 				reportId,
 				runId: authoritativeRunId
 			}, "report: same-run payload changed after commit; replaying authoritative ACK");
@@ -1262,15 +3241,37 @@ function incidentDiagnosis(code, issues, reportId, payloadDigest) {
 		faultDomain,
 		recommendedAction
 	};
-}
-/** Validate the durable report facts before a successful provider process may
-* become a successful run. The CLI validates first so an agent can retry; this
-* terminal seam prevents an ignored 400 from silently producing an empty run. */
-function runProtocolMissing(run) {
-	const missing = [];
-	if (run.status !== "keep" && run.status !== "no-change" && run.status !== "block") missing.push("status");
-	if (!run.message?.trim()) missing.push("message");
-	return missing;
+}
+var MISSING_STATUS_ERROR = "run protocol incomplete: the final response has no \"STATUS: keep|no-change|block\" line";
+/** The run outcome a terminal report establishes. Only a successful provider
+* exit is read for a status; a successful exit without one is a protocol error. */
+function reportOutcome(body) {
+	const canceled = body.result === "canceled";
+	if (canceled) return {
+		ok: false,
+		canceled,
+		patch: { error: "stopped by user" }
+	};
+	if (body.result !== "success") return {
+		ok: false,
+		canceled,
+		patch: { error: typeof body.error === "string" ? clipText(body.error, MESSAGE_CAP) : "run failed on machine" }
+	};
+	const parsed = parseFinalStatus(body.finalText);
+	if (!parsed) return {
+		ok: false,
+		canceled,
+		patch: { error: MISSING_STATUS_ERROR }
+	};
+	return {
+		ok: true,
+		canceled,
+		patch: {
+			status: parsed.status,
+			message: clipText(parsed.message, 2e3) || null,
+			error: null
+		}
+	};
 }
 function validateTerminalReport(body) {
 	const issues = [];
@@ -1290,6 +3291,25 @@ function validateTerminalReport(body) {
 		"error",
 		"finalText"
 	]) if (has(key) && typeof body[key] !== "string") issues.push(`${key} must be a string`);
+	if (has("files")) {
+		const files = body.files;
+		if (!Array.isArray(files) || files.length > REPORT_FILES_MAX) issues.push(`files must be an array of at most ${REPORT_FILES_MAX} entries`);
+		else {
+			const names = /* @__PURE__ */ new Set();
+			for (const entry of files) {
+				const file = entry;
+				if (!(file !== null && typeof file === "object" && !Array.isArray(file) && Object.keys(file).sort().join(",") === REPORT_FILE_FIELDS.join(",") && typeof file.name === "string" && file.name.length > 0 && file.name.length <= 100 && !names.has(file.name) && isValidHash(file.baseHash) && isValidHash(file.hash) && typeof file.size === "number" && Number.isInteger(file.size) && file.size >= 0 && file.size <= LOOP_FILE_BYTE_CAP)) {
+					issues.push("files entries must be exactly {name, baseHash, hash, size} with unique names, sha256 hashes, and an in-cap size");
+					break;
+				}
+				names.add(file.name);
+			}
+		}
+	}
+	if (has("fileNotices")) {
+		const notices = body.fileNotices;
+		if (!Array.isArray(notices) || notices.length > REPORT_NOTICES_MAX || notices.some((notice) => typeof notice !== "string" || notice.length > NOTICE_CAP)) issues.push(`fileNotices must be an array of at most ${REPORT_NOTICES_MAX} strings of at most ${NOTICE_CAP} characters`);
+	}
 	if (has("usage")) if (body.usage === null || typeof body.usage !== "object" || Array.isArray(body.usage)) issues.push("usage must be an object");
 	else {
 		const usage = body.usage;
@@ -1330,7 +3350,10 @@ var MachineGateway = class {
 	constructor(scheduler, blobStore = createBlobStore()) {
 		this.scheduler = scheduler;
 		this.blobStore = blobStore;
+		this.loopFiles = new LoopFiles(blobStore);
 	}
+	/** Loop-file bytes over the same blob store that maintenance garbage-collects. */
+	loopFiles;
 	/** In-flight latch: the maintenance pass is sequential and the first post-deploy
 	*  backlog reclamation can overrun the interval, so a fresh tick skips rather than
 	*  running a second pass concurrently (idempotent but wasteful + double-counts). */
@@ -1338,7 +3361,7 @@ var MachineGateway = class {
 	applyAutopauseTimer(loopId, terminal) {
 		if (!terminal.autoPaused) return;
 		this.scheduler.removeLoop(loopId);
-		log$2.warn({
+		log$1.warn({
 			loopId,
 			streak: terminal.failureStreak
 		}, "loop auto-paused after block or consecutive errors");
@@ -1434,13 +3457,14 @@ var MachineGateway = class {
 	* Periodic storage maintenance: prune each loop's run snapshots to the
 	* retention window, then GC blob bytes no live row needs. Wired to its own
 	* interval in boot (independent of the faster offline-sweep) and exposed for
-	* tests / on-demand triggers. Safe to run concurrently with active syncs (a
-	* grace window + final re-check protect freshly-written/referenced blobs) and
-	* idempotent with no garbage. Best-effort — never throws into the caller.
+	* tests / on-demand triggers. Safe to run concurrently with owner writes and
+	* run uploads (a grace window + final re-check protect freshly-written or
+	* referenced blobs) and idempotent with no garbage. Best-effort — never throws
+	* into the caller.
 	*/
-	async maintainStorage() {
+	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
@@ -1448,9 +3472,9 @@ var MachineGateway = class {
 		}
 		this.maintenanceRunning = true;
 		try {
-			return await maintainStorage(this.blobStore);
+			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
@@ -1465,20 +3489,18 @@ var MachineGateway = class {
 		const { machineId } = auth;
 		let machine = auth.machine;
 		if (!machine) {
-			const binding = await readConnectKeyBinding(deviceToken);
-			if (!binding) return {
+			if (!await connectKeyValid(deviceToken)) return {
 				status: 401,
 				body: { error: "unknown device token — connect this machine first" }
 			};
 			machine = await createMachine({
 				id: machineId,
-				userId: binding.userId,
 				name: info?.host || `machine-${machineId.slice(2, 8)}`,
 				tokenHash: sha256(deviceToken),
 				token: deviceToken,
 				online: true
 			});
-			log$2.info({
+			log$1.info({
 				machineId,
 				host: info?.host
 			}, "poll: self-registered machine");
@@ -1510,7 +3532,7 @@ var MachineGateway = class {
 			const claimed = await claimReadyRunForMachine(machineId, void 0, currentRunIds ?? []);
 			if (claimed) delivery = await buildDelivery(claimed.loop, claimed.run, claimed.runToken, machine.roots ?? []);
 		}
-		if (delivery) log$2.info({
+		if (delivery) log$1.info({
 			machineId,
 			runId: delivery.runId
 		}, "poll: delivered");
@@ -1528,7 +3550,7 @@ var MachineGateway = class {
 				code: "VALIDATION_ERROR"
 			}
 		};
-		if (request.protocolVersion !== 4) {
+		if (request.protocolVersion !== 5) {
 			const auth = await authenticateDeviceToken(deviceToken, { allowUnknown: true });
 			if (!auth.ok && auth.reason === "mismatch") return auth.response;
 			if (auth.ok && auth.machine) {
@@ -1540,7 +3562,7 @@ var MachineGateway = class {
 				body: {
 					error: "daemon upgrade required; run `npm install -g @kky42/pievo@latest`, then `pievo daemon restart`",
 					code: "UPGRADE_REQUIRED",
-					requiredProtocol: 4
+					requiredProtocol: 5
 				}
 			};
 		}
@@ -1572,7 +3594,7 @@ var MachineGateway = class {
 		const needsUpdate = daemonNeedsUpdate(reportedVersion);
 		const base = await this.pollCore(deviceToken, request.info, currentIds, !needsUpdate, true);
 		if (base.status !== 200) return base;
-		if ((await getMachine(machineId))?.daemonProtocol !== 4) await updateMachine(machineId, { daemonProtocol: 4 });
+		if ((await getMachine(machineId))?.daemonProtocol !== 5) await updateMachine(machineId, { daemonProtocol: 5 });
 		const running = await runningRunsForMachine(machineId);
 		const currentSet = new Set(currentIds);
 		return {
@@ -1589,7 +3611,7 @@ var MachineGateway = class {
 		};
 	}
 	async pollV4Wait(deviceToken, request, waitMs = LONG_POLL_WAIT_MS) {
-		if (request.currentRuns?.length || request.protocolVersion !== 4) return this.pollV4(deviceToken, request);
+		if (request.currentRuns?.length || request.protocolVersion !== 5) return this.pollV4(deviceToken, request);
 		const auth = await authenticateDeviceToken(deviceToken, { allowUnknown: true });
 		if (!auth.ok) return auth.response;
 		const machineId = auth.machineId;
@@ -1620,7 +3642,7 @@ var MachineGateway = class {
 			status: 200,
 			body: {
 				registered: false,
-				claimValid: await readConnectKeyBinding(deviceToken) !== void 0,
+				claimValid: await connectKeyValid(deviceToken),
 				online: false,
 				name: null,
 				lastSeen: null,
@@ -1650,7 +3672,6 @@ var MachineGateway = class {
 		const auth = await authenticateDeviceToken(deviceToken);
 		if (!auth.ok) return auth.response;
 		const { machineId } = auth;
-		const machine = auth.machine;
 		{
 			if (body === null || typeof body !== "object" || Array.isArray(body)) return {
 				status: 400,
@@ -1693,13 +3714,12 @@ var MachineGateway = class {
 				}
 			};
 			const loop = await createLoop({
-				userId: machine.userId,
 				machineId,
 				...row
 			});
 			this.scheduler.addLoop(loop);
 			recordNewIdempotency(idempotencyKey, machineId, loop.id);
-			log$2.info({
+			log$1.info({
 				machineId,
 				loopId: loop.id,
 				agent: loop.agent
@@ -1913,18 +3933,156 @@ 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) {
+		const raced = await committedReportEvidence(body.reportId, payloadDigest, lease.runId);
+		if (raced.response) return raced.response;
+		if (raced.foreignRun) return this.rejectTerminalAttempt(runToken, lease, body, payloadDigest, "REPORT_CONFLICT", ["reportId was already committed for another run"]);
+	}
+	async resolveLostTerminalRace(runToken, lease, body, payloadDigest, retryReconcile, logMessage) {
+		const raced = await this.reportRaceResponse(runToken, lease, body, payloadDigest);
+		if (raced) return raced;
+		const fresh = await getRun(lease.runId);
+		if (fresh?.phase === "canceled") return this.ignoreCanceledReport(runToken, lease, body);
+		if (fresh?.phase === "done") return {
+			status: 409,
+			body: {
+				error: "run already finalized",
+				code: "REPORT_NOT_FINALIZED",
+				reportId: body.reportId
+			}
+		};
+		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$1.info({
+			runId: lease.runId,
+			phase: fresh?.phase
+		}, logMessage);
+		return {
+			status: 409,
+			body: {
+				error: "terminal report was not finalized",
+				code: "REPORT_NOT_FINALIZED",
+				reportId: body.reportId
+			}
+		};
+	}
+	/** 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$1.warn({
+				runId,
+				err: err instanceof Error ? err.message : String(err)
+			}, "snapshot capture failed");
+		}
+	}
 	/** Reconcile one swept run. The store consumes the terminal-grace lease in the
 	* 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));
@@ -1933,60 +4091,23 @@ 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 committedReportEvidence(receipt.reportId, payloadDigest, lease.runId);
-			if (raced.response) return raced.response;
-			if (raced.foreignRun) return this.rejectTerminalAttempt(runToken, lease, body, payloadDigest, "REPORT_CONFLICT", ["reportId was already committed for another run"]);
+			const raced = await this.reportRaceResponse(runToken, lease, body, payloadDigest);
+			if (raced) return raced;
 			throw error;
 		}
-		if (!reconciled) {
-			const raced = await committedReportEvidence(receipt.reportId, payloadDigest, lease.runId);
-			if (raced.response) return raced.response;
-			if (raced.foreignRun) return this.rejectTerminalAttempt(runToken, lease, body, payloadDigest, "REPORT_CONFLICT", ["reportId was already committed for another run"]);
-			const fresh = await getRun(lease.runId);
-			if (fresh?.phase === "canceled") return this.ignoreCanceledReport(runToken, lease, body);
-			if (fresh?.phase === "done") return {
-				status: 409,
-				body: {
-					error: "run already finalized",
-					code: "REPORT_NOT_FINALIZED",
-					reportId: body.reportId
-				}
-			};
-			if ((await resolveLease(runToken))?.state === "retired") return this.retiredReport(runToken, body, lease.runId);
-			log$2.info({
-				runId: lease.runId,
-				phase: fresh?.phase
-			}, "report: late reconcile lost terminal race");
-			return {
-				status: 409,
-				body: {
-					error: "terminal report was not finalized",
-					code: "REPORT_NOT_FINALIZED",
-					reportId: body.reportId
-				}
-			};
-		}
+		if (!reconciled) return this.resolveLostTerminalRace(runToken, lease, body, payloadDigest, false, "report: late reconcile lost terminal race");
 		const deleting = reconciled.loop.deleteRequestedAt != null;
 		const reportOnly = reconciled.reportOnly === true;
-		if (!deleting && !reportOnly) try {
-			await putRunSnapshot(lease.runId, lease.loopId, await buildLoopManifest(lease.loopId));
-			await pruneRunSnapshots(lease.loopId, snapshotRetention());
-		} catch (err) {
-			log$2.warn({
-				runId: lease.runId,
-				err: err instanceof Error ? err.message : String(err)
-			}, "snapshot capture failed");
-		}
-		reconciled.run;
+		if (!deleting && !reportOnly) await this.captureRunSnapshot(lease.runId, lease.loopId);
 		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
@@ -2039,7 +4160,7 @@ var MachineGateway = class {
 			this.scheduler.addLoop(rejected.loop);
 			if (rejected.state === "run-error") this.applyAutopauseTimer(lease.loopId, rejected);
 			if (rejected.loop.deleteRequestedAt) await tryDeleteLoop(lease.loopId);
-			log$2.warn({
+			log$1.warn({
 				runId: lease.runId,
 				reportId,
 				code,
@@ -2093,8 +4214,6 @@ var MachineGateway = class {
 		if (evidence.foreignRun) return this.rejectTerminalAttempt(runToken, lease, body, payloadDigest, "REPORT_CONFLICT", ["reportId was already committed for another run"]);
 		if (issues.length) return this.rejectTerminalAttempt(runToken, lease, body, payloadDigest, "REPORT_INVALID", issues);
 		const expected = receiptFor(body, lease.runId);
-		const ok = body.result === "success";
-		const canceled = body.result === "canceled";
 		const run = await getRun(lease.runId);
 		if (run?.phase === "canceled") return this.ignoreCanceledReport(runToken, lease, body);
 		if (run?.phase === "done") return {
@@ -2106,67 +4225,29 @@ 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 committedReportEvidence(reportId, payloadDigest, lease.runId);
-			if (raced.response) return raced.response;
-			if (raced.foreignRun) return this.rejectTerminalAttempt(runToken, lease, body, payloadDigest, "REPORT_CONFLICT", ["reportId was already committed for another run"]);
+			const raced = await this.reportRaceResponse(runToken, lease, body, payloadDigest);
+			if (raced) return raced;
 			throw error;
 		}
-		if (!terminal) {
-			const raced = await committedReportEvidence(reportId, payloadDigest, lease.runId);
-			if (raced.response) return raced.response;
-			if (raced.foreignRun) return this.rejectTerminalAttempt(runToken, lease, body, payloadDigest, "REPORT_CONFLICT", ["reportId was already committed for another run"]);
-			const fresh = await getRun(lease.runId);
-			if (fresh?.phase === "canceled") return this.ignoreCanceledReport(runToken, lease, body);
-			if (fresh?.phase === "done") return {
-				status: 409,
-				body: {
-					error: "run already finalized",
-					code: "REPORT_NOT_FINALIZED",
-					reportId
-				}
-			};
-			const refreshedLease = await resolveLease(runToken);
-			if (refreshedLease?.state === "retired") return this.retiredReport(runToken, body, lease.runId);
-			if (fresh?.phase === "error" && refreshedLease?.state === "terminal-grace") return this.reconcileReclaimedReport(runToken, refreshedLease, fresh, body);
-			log$2.info({
-				runId: lease.runId,
-				phase: fresh?.phase
-			}, "report: lost terminal race");
-			return {
-				status: 409,
-				body: {
-					error: "terminal report was not finalized",
-					code: "REPORT_NOT_FINALIZED",
-					reportId
-				}
-			};
-		}
-		terminal.run;
+		if (!terminal) return this.resolveLostTerminalRace(runToken, lease, body, payloadDigest, true, "report: lost terminal race");
 		const deleting = terminal.loop.deleteRequestedAt != null;
-		if (!deleting) try {
-			await putRunSnapshot(lease.runId, lease.loopId, await buildLoopManifest(lease.loopId));
-			await pruneRunSnapshots(lease.loopId, snapshotRetention());
-		} catch (err) {
-			log$2.warn({
-				runId: lease.runId,
-				err: err instanceof Error ? err.message : String(err)
-			}, "snapshot capture failed");
-		}
+		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");
@@ -2280,162 +4361,14 @@ 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).
 */
-var runDiff_exports = /* @__PURE__ */ __exportAll$1({ computeRunDiff: () => computeRunDiff });
+var runDiff_exports = /* @__PURE__ */ __exportAll({ computeRunDiff: () => computeRunDiff });
 /**
 * Upper bound for computing an inline unified diff. jsdiff is synchronous and
 * roughly O(N*D); on a multi-MB or minified text file it would block the
@@ -2451,7 +4384,7 @@ function withinDiffCap(e) {
 }
 async function bytesOf(e) {
 	if (!e.hash) return null;
-	return await (await getArtifactSync()).readBlob(e.hash) ?? null;
+	return await (await getLoopFiles()).readBlob(e.hash) ?? null;
 }
 function unified(path, oldText, newText, maxEditLength) {
 	return maxEditLength === void 0 ? createTwoFilesPatch(path, path, oldText, newText, "previous run", "this run") : createTwoFilesPatch(path, path, oldText, newText, "previous run", "this run", { maxEditLength });
@@ -2464,7 +4397,7 @@ function expectedInputBytes(change, verifiedSizes) {
 	if (sizes.some((size) => size === void 0)) return null;
 	return sizes.reduce((sum, size) => sum + size, 0);
 }
-/** Compute one run's artifact diff. The default remains the web UI's complete
+/** Compute one run's loop-file diff. The default remains the web UI's complete
 * view. Budgeted callers get explicit totals and stop before blob reads/jsdiff
 * once any work limit is spent. */
 async function computeRunDiff(runId, budget) {
@@ -2879,6 +4812,7 @@ async function detailHistory(loop, q) {
 		errorTruncated: error.truncated,
 		finalText: finalText.value,
 		finalTextTruncated: finalText.truncated,
+		fileNotices: run.fileNotices ?? [],
 		diffAvailable: !!snapshot,
 		diff: q.diff ? await boundedDiff(run.id) : {
 			included: false,
@@ -2904,6 +4838,7 @@ async function detailHistory(loop, q) {
 		["errorTruncated", detail.errorTruncated],
 		["finalText", detail.finalText],
 		["finalTextTruncated", detail.finalTextTruncated],
+		["fileNotices", { raw: JSON.stringify(detail.fileNotices) }],
 		["diffAvailable", detail.diffAvailable],
 		["diff", { raw: JSON.stringify(detail.diff) }]
 	]));
@@ -2928,8 +4863,8 @@ async function readLoopHistory(loop, flags) {
 * The verb router keys authority on credential type first (`dk_` device prefix
 * vs `rk_` run lease) and reuses the core gateway
 * methods (`createLoop`/`editLoop`) through the injected `MachineGateway`,
-* plus the credential-neutral history module. Run credentials expose only the
-* exactly-once report callback.
+* plus the credential-neutral history module. Run credentials authorize no CLI
+* verb: a run reports through its final response, not a callback.
 */
 var cliLog = logger.child({ mod: "cli" });
 var CliGateway = class {
@@ -2948,9 +4883,8 @@ var CliGateway = class {
 	* already exists — never a rewrite — that keys authority on the credential type:
 	*   · DEVICE credential (`dk_`-prefixed) → owner authority over any loop bound to
 	*     the machine: `new`→createLoop, `loops`→listLoops, `edit`→editLoop,
-	*     `log`→readLoopHistory, `show`→describe. `report` is RUN-only (403).
-	*   · RUN credential (`rk_` run lease) → report and report help only.
-	*     Every owner verb is rejected.
+	*     `log`→readLoopHistory, `show`→describe, `file`→loop files.
+	*   · RUN credential (`rk_` run lease) → rejected; runs have no CLI.
 	*/
 	async cli(token, argv) {
 		return finalizeCli(token.startsWith("dk_") ? await this.deviceCli(token, argv) : await this.runCli(token, argv));
@@ -3041,13 +4975,10 @@ var CliGateway = class {
 					}
 				};
 			}
-			case "report": return {
-				status: 403,
-				body: { error: "pievo: report is a run-only verb; the owner edits via edit" }
-			};
+			case "file": return this.ownerFile(machineId, argv);
 			default: return {
 				status: 400,
-				body: { error: `pievo: unknown command "${verb}" for the device credential (try: new, loops, pause, start, stop, delete, run stop, edit, log, show)` }
+				body: { error: `pievo: unknown command "${verb}" for the device credential (try: new, loops, pause, start, stop, delete, run stop, edit, log, show, file)` }
 			};
 		}
 	}
@@ -3096,7 +5027,7 @@ var CliGateway = class {
 	}
 	async requireStopProtocol(machineId, running) {
 		if (!running) return void 0;
-		if ((await getMachine(machineId))?.daemonProtocol === 4) return void 0;
+		if ((await getMachine(machineId))?.daemonProtocol === 5) return void 0;
 		return {
 			status: 426,
 			body: {
@@ -3152,7 +5083,6 @@ var CliGateway = class {
 				action: "force-delete",
 				loopId: loop.id,
 				machineId,
-				actorUserId: loop.userId,
 				machineReachability: reachability
 			});
 			return {
@@ -3208,121 +5138,90 @@ var CliGateway = class {
 			body: { text: `run already finished: ${runResultToken(stopped)}` }
 		};
 	}
-	async runCli(runToken, argv) {
-		const lease = await resolveLease(runToken);
-		if (!lease) return {
+	async runCli(runToken, _argv) {
+		if (!await resolveLease(runToken)) return {
 			status: 401,
 			body: {
 				text: errorBlock("invalid or expired token", "UNAUTHORIZED"),
 				exitCode: 1
 			}
 		};
-		if (lease.state === "terminal-grace" || lease.state === "reconciliation-only") return {
-			status: 409,
-			body: {
-				text: errorBlock(TERMINAL_GRACE_MSG, "CONFLICT"),
-				exitCode: 1
-			}
-		};
-		const verb = argv[0] ?? "";
-		const flags = parseFlags(argv.slice(1));
-		if (DEVICE_ONLY_VERBS.has(verb)) return {
+		return {
 			status: 403,
 			body: {
-				text: errorBlock(`"${verb}" needs the device credential (owner authority); a run may only report`, "FORBIDDEN"),
+				text: errorBlock(RUN_HAS_NO_CLI, "FORBIDDEN"),
 				exitCode: 1
 			}
 		};
-		if (flags.help === true && verb === "report") return {
-			status: 200,
-			body: {
-				text: verbHelpText("report", lease),
-				exitCode: 0
-			}
+	}
+	/** `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" && verb !== "help" && verb !== "--help" && verb !== "-h" && verb !== "") return {
-			status: 403,
-			body: {
-				text: errorBlock("run credentials authorize only pievo report", "FORBIDDEN"),
-				exitCode: 1
-			}
+		if (!loop) return {
+			status: 404,
+			body: { error: "no such loop on this machine" }
 		};
-		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
-			}
+		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`])) }
 		};
-	}
-	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)
-		};
-		if (verb !== "report") return derr(403, "run credentials authorize only pievo report", "FORBIDDEN");
-		if (flags.help === true) return {
-			code: 200,
-			text: verbHelpText("report", lease)
-		};
-		const 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 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 = {}) {
@@ -3367,17 +5266,8 @@ var CliGateway = class {
 		})), scoped.elsewhere, await recentMachineRuns(loops, 3));
 	}
 };
-var TERMINAL_GRACE_MSG = "this run is terminal and no longer accepts commands; its final result is delivered via the terminal report";
-/** Verbs that require device authority. `report` is run-only and rejected there. */
-var DEVICE_ONLY_VERBS = new Set([
-	"new",
-	"edit",
-	"loops",
-	"start",
-	"stop",
-	"delete",
-	"run"
-]);
+var RUN_HAS_NO_CLI = "pievo commands are not available inside a run; end your final response with a summary and a last line `STATUS: keep|no-change|block`";
+var FILE_USAGE = "pievo file list <loop> | file get <loop> <name> | file set <loop> <name> --from <path>";
 var PAUSED_FINISHING = "loop paused; current run is finishing";
 var STOP_UPGRADE_REQUIRED = "Daemon upgrade required to stop a running process. Run `npm install -g @kky42/pievo@latest`, then `pievo daemon restart`.";
 var FORCE_DELETE_CONFIRMATION = "delete-server-data-anyway";
@@ -3415,15 +5305,6 @@ function parseJsonFlag(raw) {
 		value: obj
 	};
 }
-/** A structured `error:`/`code:` TOON result for stdout.
-*  Mirrors the `{code, text}` shape `dispatch` returns; the slug defaults from the
-*  HTTP status but a caller may pin it (e.g. CONFLICT). */
-function derr(code, message, slug) {
-	return {
-		code,
-		text: errorBlock(message, slug ?? codeForStatus(code))
-	};
-}
 /** The structured keys a `/api/machine/cli` body may carry. The daemon renders
 * `text` and exits with `exitCode`; two structured channels remain because the
 * current daemon reads them as data:
@@ -3451,18 +5332,6 @@ function finalizeCli(res) {
 	}
 	return res;
 }
-function renderReportedText(status, hasMessage) {
-	const parts = [];
-	if (status) parts.push(`status=${status}`);
-	if (hasMessage) parts.push("message recorded");
-	return `reported: ${parts.length ? parts.join(" · ") : "recorded"}`;
-}
-var RUN_VERB_HELP = { report: {
-	syntax: "report --status keep|no-change|block --message <text>",
-	summary: "record this run's required status and non-empty summary",
-	avail: () => "always available",
-	help: ["Run `pievo report --status no-change --message \"no actionable change\"` to close this run", "Run `pievo report --status keep --message \"completed the requested work\"` to retain a result"]
-} };
 var DEVICE_VERB_HELP = {
 	new: {
 		syntax: "new --json '<config>' [--dry-run]",
@@ -3501,24 +5370,29 @@ var DEVICE_VERB_HELP = {
 	},
 	delete: {
 		syntax: "delete <id> [--force]",
-		summary: "stop first, then delete server history and synced artifact metadata",
-		help: ["Stop this loop and delete its Pievo history and synced artifacts? Local project files are not deleted.", "--force requires a prior Delete request and explicit local confirmation; the local process may still be running"]
+		summary: "stop first, then delete server history, memory, and artifacts",
+		help: ["Stop this loop and delete its Pievo history, memory, and artifacts? Local project files are not deleted.", "--force requires a prior Delete request and explicit local confirmation; the local process may still be running"]
 	},
 	run: {
 		syntax: "run stop <run-id>",
 		summary: "stop one pending or running run without pausing its loop",
 		help: ["A running run remains running until the daemon confirms cancellation"]
 	},
+	file: {
+		syntax: "file list <id> | file get <id> <name> | file set <id> <name> --from <path>",
+		summary: "inspect or replace a loop's MEMORY.md and artifact files",
+		help: ["Run `pievo file get <id> MEMORY.md` to read the loop's memory", "An edit made while a run is executing wins over that run's version of the file"]
+	},
 	log: {
 		syntax: "log [<id>] [--limit 1..20] [--since ISO] [--until ISO] [--status keep|no-change|block] [--phase done|error|canceled] [--run <index|UUID> [--diff]] [--json]",
 		summary: "bounded terminal history or one detailed run",
 		help: ["Run `pievo log <id> --json` for structured history", "Run `pievo log <id> --run 12 --diff` for bounded run detail and artifact diff"]
 	}
 };
-function verbHelpText(verb, lease) {
-	const spec = lease ? RUN_VERB_HELP[verb] : DEVICE_VERB_HELP[verb];
+function verbHelpText(verb) {
+	const spec = DEVICE_VERB_HELP[verb];
 	if (!spec) return void 0;
-	return doc(kvLine("verb", verb), kvLine("syntax", spec.syntax), kvLine("summary", spec.summary), lease && spec.avail ? kvLine("availability", spec.avail(lease)) : null, helpBlock(spec.help));
+	return doc(kvLine("verb", verb), kvLine("syntax", spec.syntax), kvLine("summary", spec.summary), helpBlock(spec.help));
 }
 function loopEnvelope(loop) {
 	return { ...canonicalLoopEnvelope(loop) };
@@ -3555,7 +5429,8 @@ function renderShowText(loop, env, totalRuns, lastRun, opts = {}) {
 	const help = [
 		`Run \`pievo show ${loop.id} --full\` to see the complete prompt`,
 		`Run \`pievo edit ${loop.id} --json '{"schedule":{"mode":"continuous","delayMinutes":5}}'\` to change the schedule`,
-		`Run \`pievo log ${loop.id}\` to see recent run results`
+		`Run \`pievo log ${loop.id}\` to see recent run results`,
+		`Run \`pievo file list ${loop.id}\` to see the loop's memory and artifact files`
 	];
 	return doc(block, kvLine("nextFire", nextFireDisplay(loop)), `lifecycle: ${loop.enabled ? "active" : "paused"}`, `runs: ${runsTally}`, !loop.enabled ? kvLine("pauseCause", loop.pauseCause?.kind === "failure-streak" ? `failure-streak (run ${loop.pauseCause.runId}, count ${loop.pauseCause.count})` : loop.pauseCause?.kind === "blocked" ? `blocked (run ${loop.pauseCause.runId})` : loop.pauseCause?.kind === "owner" ? "owner" : "unknown") : null, lastRun?.reportIncident ? kvLine("reportIncident", `${lastRun.reportIncident.code} · ${lastRun.reportIncident.faultDomain} · ${lastRun.reportIncident.reason}`) : null, helpBlock(help));
 }
@@ -3643,9 +5518,6 @@ function renderHomeText(ctx, presence, here, elsewhere, recent) {
 		"Run `pievo new --json '{...}'` to create a loop"
 	]));
 }
-function reportStatus(s) {
-	return s === "keep" || s === "no-change" || s === "block" ? s : void 0;
-}
 /** Tiny flag parser: `--k v` pairs, bare `--flag` → true, first positional under `_`.
 *  Every key/value is NUL-stripped at this wire boundary before validation or
 *  persistence because Postgres text rejects NUL. */
@@ -3777,87 +5649,6 @@ function msg(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 /**
-* DB watchdog — the real auto-recovery backstop for a wedged postgres-js pool.
-*
-* BACKGROUND (2026-07-12 outage, twice in one day): the runtime pool against the
-* Supabase transaction pooler wedged — every connection stuck on a query that
-* never returned, so `/api/health/db`'s `select 1` queued behind them forever and
-* the server stopped sending response headers. Fly's health check went `critical`,
-* which only PULLS the machine from load balancing (a well-known Fly footgun:
-* failing `[http_service.checks]` do NOT restart the VM — only a process EXIT
-* triggers `restart.policy = "on-failure"`). Result: ~9h fully down with no
-* auto-recovery until a manual `fly machine restart`. The pool's own self-healing
-* (`max_lifetime`/`statement_timeout`, `db/index.ts`) can't cover a busy-wedged
-* connection or a dead socket that never errors.
-*
-* This watchdog closes that gap: it pings `select 1` on a fixed cadence under a
-* HARD client-side deadline (a hung ping counts as a failure, since the underlying
-* query can't be canceled). After N consecutive failures it exits the process, so
-* Fly restarts the machine with a fresh pool — turning a multi-hour hang into a
-* ~1-2min self-heal. A single healthy ping resets the streak, so a transient blip
-* never restarts the box.
-*
-* Pure + injectable: `makeDbWatchdog` takes the probe / exit / clock as deps so the
-* decision logic is unit-tested with no real DB, timers, or `process.exit`.
-*/
-/** Reject if `p` hasn't settled within `ms`. The underlying promise keeps running
-*  (we can't cancel a wedged query) — bounded by the exit after `failureThreshold`. */
-function withDeadline(p, ms, setTimer, clearTimer) {
-	return new Promise((resolve, reject) => {
-		const h = setTimer(() => reject(/* @__PURE__ */ new Error(`db ping timed out after ${ms}ms`)), ms);
-		p.then((v) => {
-			clearTimer(h);
-			resolve(v);
-		}, (e) => {
-			clearTimer(h);
-			reject(e instanceof Error ? e : new Error(String(e)));
-		});
-	});
-}
-function makeDbWatchdog(deps) {
-	const { probe, exit, timeoutMs, failureThreshold, setTimer = (fn, ms) => setTimeout(fn, ms), clearTimer = (h) => clearTimeout(h), log = logger } = deps;
-	let consecutive = 0;
-	let running = false;
-	let done = false;
-	async function tick() {
-		if (running || done) return;
-		running = true;
-		try {
-			await withDeadline(Promise.resolve().then(probe), timeoutMs, setTimer, clearTimer);
-			consecutive = 0;
-		} catch (err) {
-			consecutive += 1;
-			log.warn({
-				consecutive,
-				failureThreshold,
-				err: String(err)
-			}, "db watchdog: liveness ping failed");
-			if (consecutive >= failureThreshold) {
-				done = true;
-				log.error({ consecutive }, "db watchdog: database unreachable for too long — exiting so the platform restarts with a fresh pool");
-				exit(1);
-			}
-		} finally {
-			running = false;
-		}
-	}
-	return {
-		tick,
-		failures: () => consecutive
-	};
-}
-/**
-* Start the watchdog on a repeating interval. Returns a stop function (cleared on
-* the boot AbortController). The interval is `unref`'d so it never keeps the
-* process alive on its own.
-*/
-function startDbWatchdog(deps) {
-	const wd = makeDbWatchdog(deps);
-	const handle = setInterval(() => void wd.tick(), deps.intervalMs);
-	handle.unref?.();
-	return () => clearInterval(handle);
-}
-/**
 * 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
@@ -3865,11 +5656,11 @@ function startDbWatchdog(deps) {
 * from any server-side entry (the standalone machine server / TanStack server
 * fns); the first call boots, the rest share the same instance.
 */
-var boot_exports = /* @__PURE__ */ __exportAll$1({
+var boot_exports = /* @__PURE__ */ __exportAll({
 	ensureServer: () => ensureServer,
-	getArtifactSync: () => getArtifactSync,
 	getCliGateway: () => getCliGateway,
-	getGateway: () => getGateway
+	getGateway: () => getGateway,
+	getLoopFiles: () => getLoopFiles
 });
 var g = globalThis;
 function ensureServer() {
@@ -3882,7 +5673,6 @@ function ensureServer() {
 	return p;
 }
 async function boot() {
-	loginGateEnabled();
 	await runMigrations();
 	await repairTerminalRunLeases();
 	const abort = new AbortController();
@@ -3895,40 +5685,19 @@ 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);
 	sweep.unref?.();
 	abort.signal.addEventListener("abort", () => clearInterval(sweep), { once: true });
-	const gc = setInterval(() => void gateway.maintainStorage().catch((err) => logger.error({ err: String(err) }, "gc tick failed")), gcIntervalMs());
+	const gc = setInterval(() => void gateway.maintainStorage().catch((err) => logger.error({ err: String(err) }, "gc tick failed")), GC_INTERVAL_MS);
 	gc.unref?.();
 	abort.signal.addEventListener("abort", () => clearInterval(gc), { once: true });
-	if (dbWatchdogEnabled()) {
-		const intervalMs = dbWatchdogIntervalMs();
-		const timeoutMs = dbWatchdogTimeoutMs();
-		const failureThreshold = dbWatchdogFailureThreshold();
-		logger.info({
-			intervalMs,
-			timeoutMs,
-			failureThreshold
-		}, "db watchdog: armed");
-		const stopWatchdog = startDbWatchdog({
-			probe: () => db.execute(sql`select 1`),
-			exit: (code) => process.exit(code),
-			intervalMs,
-			timeoutMs,
-			failureThreshold
-		});
-		abort.signal.addEventListener("abort", () => stopWatchdog(), { once: true });
-	}
 	logger.info("pievo server booted");
 	return {
 		scheduler,
 		gateway,
-		artifactSync,
 		cliGateway,
 		abort,
 		shutdown
@@ -3937,11 +5706,11 @@ async function boot() {
 async function getGateway() {
 	return (await ensureServer()).gateway;
 }
-async function getArtifactSync() {
-	return (await ensureServer()).artifactSync;
+async function getLoopFiles() {
+	return (await ensureServer()).gateway.loopFiles;
 }
 async function getCliGateway() {
 	return (await ensureServer()).cliGateway;
 }
 //#endregion
-export { daemonNeedsUpdate as a, readByteBody as c, statusDefinitionsFromLoop as d, validOptionalPollString as f, validateLoopEdit as h, boot_C472kLwY_exports as i, readJsonBody as l, validPollWireId as m, MIN_DAEMON_VERSION as n, ensureServer as o, validPollCurrentRun as p, POLL_HTTP_BODY_FIELDS as r, getArtifactSync as s, MACHINE_BODY_CAP as t, scheduleFromLoop as u };
+export { listRuns as A, requestDeleteLoop as B, getRun as C, listArtifacts as D, isOutdated as E, machinePresence as F, tryDeleteLoop as G, sha256 as H, mintDeviceToken as I, validateLoopTags as J, updateLoop as K, pauseLoop as L, loopTags_CnVLi70h_exports as M, loopsForMachine as N, listLoops as O, machineIdFromToken as P, recentLoopUsage as R, getMachine as S, hasRunningRun as T, startLoop as U, requestRunCancel as V, stopLoop as W, createMachine as _, canonicalLoopSummary as a, getArtifactFile as b, getLoopFiles as c, validOptionalPollString as d, validPollCurrentRun as f, countRuns as g, CODING_AGENTS as h, canonicalLoopEnvelope as i, listRunsBefore as j, listMachines as k, readByteBody as l, validateLoopEdit as m, POLL_HTTP_BODY_FIELDS as n, daemonNeedsUpdate as o, validPollWireId as p, updateMachine as q, boot_DmpKtb0A_exports as r, ensureServer as s, MIN_DAEMON_VERSION as t, readJsonBody as u, forceDeleteLoop as v, hasPendingRun as w, getLoop as x, forceDeleteMachine as y, reconciliationStatesForRuns as z };