@kky42/pievo-server 4.1.0 → 4.2.0

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

@@ -11,14 +11,14 @@ import { fileURLToPath } from "node:url";
 import path from "node:path";
 import os from "node:os";
 import fs$1 from "node:fs/promises";
-//#region node_modules/.nitro/vite/services/ssr/assets/loopTags-CnVLi70h.js
-var loopTags_CnVLi70h_exports = /* @__PURE__ */ __exportAll$1({
+//#region node_modules/.nitro/vite/services/ssr/assets/loopTags-Bi7Bm7v8.js
+var loopTags_Bi7Bm7v8_exports = /* @__PURE__ */ __exportAll$1({
 	$: () => loopIdsWithSnapshots,
-	$t: () => BLOB_GC_GRACE_MS,
+	$t: () => logger_exports,
 	A: () => enqueueRun,
 	At: () => updateMachine,
 	B: () => getRun,
-	Bt: () => loopFileNames,
+	Bt: () => loopFileIssue,
 	C: () => buildLoopManifest,
 	Ct: () => setMachineOnline,
 	D: () => createLoop,
@@ -26,47 +26,47 @@ var loopTags_CnVLi70h_exports = /* @__PURE__ */ __exportAll$1({
 	E: () => countRuns,
 	Et: () => stopLoop,
 	F: () => getArtifactFile,
-	Ft: () => MEMORY_CHAR_CAP,
+	Ft: () => LoopFiles,
 	G: () => initializeCronCadence,
-	Gt: () => closeClient,
+	Gt: () => createBlobStore,
 	H: () => getTerminalReportIncidents,
-	Ht: () => sha256Buf,
+	Ht: () => loopFiles_exports,
 	I: () => getExactTerminalReportIncident,
-	It: () => MEMORY_FILE,
+	It: () => MEMORY_CHAR_CAP,
 	J: () => listLoops,
-	Jt: () => runs,
+	Jt: () => runMigrations,
 	K: () => lastRun,
-	Kt: () => db,
+	Kt: () => closeClient,
 	L: () => getLoop,
-	Lt: () => fileLimitLabel,
+	Lt: () => MEMORY_FILE,
 	M: () => finalizeRunningRun,
-	Mt: () => EMPTY_SHA256,
+	Mt: () => ARTIFACT_EXTENSIONS,
 	N: () => forceDeleteLoop,
-	Nt: () => LOOP_FILE_BYTE_CAP,
+	Nt: () => EMPTY_SHA256,
 	O: () => createMachine,
 	Ot: () => tryDeleteLoop,
 	P: () => forceDeleteMachine,
-	Pt: () => LoopFiles,
+	Pt: () => LOOP_FILE_BYTE_CAP,
 	Q: () => liveBlobRefs,
-	Qt: () => logger_exports,
+	Qt: () => logger,
 	R: () => getMachine,
-	Rt: () => isValidHash,
+	Rt: () => fileLimitLabel,
 	S: () => blobSizes,
 	St: () => runningRunsForMachine,
 	T: () => countRunSnapshots,
 	Tt: () => startLoop,
 	U: () => hasPendingRun,
-	Ut: () => validArtifactName,
+	Ut: () => sha256Buf,
 	V: () => getRunSnapshot,
-	Vt: () => loopFiles_exports,
+	Vt: () => loopFileNames,
 	W: () => hasRunningRun,
-	Wt: () => createBlobStore,
+	Wt: () => validArtifactName,
 	X: () => listRuns,
-	Xt: () => coerceCodingAgent,
+	Xt: () => CODING_AGENTS,
 	Y: () => listMachines,
-	Yt: () => CODING_AGENTS,
+	Yt: () => runs,
 	Z: () => listRunsBefore,
-	Zt: () => logger,
+	Zt: () => coerceCodingAgent,
 	_: () => acknowledgeRetiredReport,
 	_t: () => releaseAbsentReconciliations,
 	a: () => TERMINAL_GRACE_MS,
@@ -77,7 +77,7 @@ var loopTags_CnVLi70h_exports = /* @__PURE__ */ __exportAll$1({
 	ct: () => putRunSnapshot,
 	d: () => readNewIdempotency,
 	dt: () => reclaimRun,
-	en: () => GC_INTERVAL_MS,
+	en: () => BLOB_GC_GRACE_MS,
 	et: () => loopsForMachine,
 	f: () => recordNewIdempotency,
 	ft: () => reconcileReclaimedRun,
@@ -96,19 +96,20 @@ var loopTags_CnVLi70h_exports = /* @__PURE__ */ __exportAll$1({
 	m: () => retireLease,
 	mt: () => recordBlob,
 	n: () => isOutdated,
+	nn: () => __exportAll,
 	nt: () => pauseLoop,
 	o: () => connectKeyValid,
 	ot: () => pruneRunSnapshots,
 	p: () => resolveLease,
 	pt: () => reconciliationStatesForRuns,
 	q: () => listArtifacts,
-	qt: () => runMigrations,
+	qt: () => db,
 	r: () => isValidSemver,
 	rt: () => pauseLoopState,
 	s: () => isDeviceTokenShape,
 	st: () => putReportReceiptIfAbsent,
 	t: () => validateLoopTags,
-	tn: () => __exportAll,
+	tn: () => GC_INTERVAL_MS,
 	tt: () => openRuns,
 	u: () => pruneExpiredLeases,
 	ut: () => recentLoopUsage,
@@ -121,7 +122,7 @@ var loopTags_CnVLi70h_exports = /* @__PURE__ */ __exportAll$1({
 	y: () => advanceDueSchedules,
 	yt: () => requestDeleteLoop,
 	z: () => getReportReceipt,
-	zt: () => loopFileIssue
+	zt: () => isValidHash
 });
 var import_pino = /* @__PURE__ */ __toESM(require_pino());
 var import_pino_pretty = /* @__PURE__ */ __toESM(require_pino_pretty());
@@ -153,9 +154,9 @@ var BLOB_GC_GRACE_MS = 3600 * 1e3;
 /** Storage-maintenance cadence (prune snapshots, then GC blobs). 15 minutes. */
 var GC_INTERVAL_MS = 900 * 1e3;
 /**
-* Uses pino-pretty as a *synchronous* destination stream (not a worker-thread
-* transport) so logs flush before process.exit() in the one-shot CLIs. Writes to
-* stderr (fd 2) to keep stdout clean for QR codes and human CLI output.
+* pino-pretty as a synchronous destination stream (not a worker-thread transport)
+* so logs flush before process.exit() in the one-shot CLIs. Writes to stderr so
+* stdout carries only CLI output.
 */
 var logger_exports = /* @__PURE__ */ __exportAll({ logger: () => logger });
 var level = (process.env.PIEVO_LOG_LEVEL || "info").toLowerCase();
@@ -166,17 +167,9 @@ var stream = (0, import_pino_pretty.default)({
 	ignore: "pid,hostname"
 });
 var logger = (0, import_pino.default)({ level }, stream);
-/** The coding agent a loop is bound to AND executed with (BYOA on the owner's
-*  machine): `claude-code` → Claude Code, `codex` → `codex exec`, `pi` → Pi.
-*  Non-Claude agents may still have thinner daemon telemetry until stream
-*  integration lands; execution itself is real for every value.
-*
-*  Runtime SINGLE SOURCE (anti-drift): every server consumer DERIVES from this
-*  array — the `CodingAgent` type here, the `db/schema.ts` `CodingAgent` type AND
-*  the `loops.agent` column enum, the edit validator (`coerceCodingAgent`), and the
-*  web agent `<select>` (LoopForm). So widening the set is a one-line edit HERE with
-*  no other server change (the daemon's own enum in `packages/daemon/src/create.ts`
-*  is a separate package, widened alongside). */
+/** Single source for coding agents: server types, the `loops.agent` column enum,
+*  validators, and the dashboard select all derive from this array. The daemon
+*  keeps its own copy in `packages/daemon/src/create.ts`; widen both together. */
 var CODING_AGENTS = [
 	"claude-code",
 	"codex",
@@ -196,10 +189,6 @@ var RESERVED_LOOP_TAGS = [
 * Pievo is single-user: no row carries an owner. Timestamp values are ISO
 * strings; JSON columns use `jsonb().$type<>()`.
 */
-/** `skipped`: a pending run retired without executing (pause/retention cleanup,
-*  queue coalescing, or the offline catch-up window elapsed).
-*  Neither success nor failure — excluded from the failure streak (it rides
-*  phase `canceled`, and the streak counts only phase `error`). */
 var machines = pgTable("machines", {
 	id: text("id").primaryKey(),
 	name: text("name").notNull(),
@@ -231,8 +220,8 @@ var loops = pgTable("loops", {
 	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`. */
+	/** Configured artifact names, in addition to the always-present MEMORY.md.
+	*  See `gateway/loopFiles.ts`. */
 	artifacts: jsonb("artifacts").$type().notNull().default([]),
 	cron: text("cron").notNull(),
 	scheduleMode: text("schedule_mode", { enum: ["cron", "continuous"] }).notNull(),
@@ -249,11 +238,8 @@ var loops = pgTable("loops", {
 	pauseCause: jsonb("pause_cause").$type(),
 	model: text("model"),
 	reasoningEffort: text("reasoning_effort"),
-	/** Coding agent this loop is BOUND TO and EXECUTED with: the daemon's
-	*  `buildAgentSpawn` branches on this value (`claude-code` → claude,
-	*  `codex` → `codex exec`, `pi` → Pi print mode). Measured from the creating CLI's env when
-	*  detectable, else the declared/selected value. The text column carries
-	*  both a TypeScript enum and a database CHECK constraint. */
+	/** The daemon launches this agent for every run (`buildAgentSpawn`). Enforced by
+	*  both the TypeScript enum and a database CHECK constraint. */
 	agent: text("agent", { enum: CODING_AGENTS }).notNull(),
 	enabled: boolean("enabled").notNull().default(true),
 	nextRunAt: text("next_run_at"),
@@ -281,6 +267,9 @@ var runs = pgTable("runs", {
 	model: text("model"),
 	reasoningEffort: text("reasoning_effort"),
 	runIndex: integer("run_index"),
+	/** A pending run retired without executing (pause, retention cleanup, queue
+	*  coalescing, or an elapsed offline catch-up window) is `canceled`, not `error`,
+	*  so it never counts toward the failure streak. */
 	phase: text("phase", { enum: [
 		"pending",
 		"running",
@@ -300,6 +289,9 @@ var runs = pgTable("runs", {
 		"block"
 	] }),
 	message: text("message"),
+	/** Owner-facing reason from the final response's ATTENTION line. Independent
+	*  of status: it never pauses the loop. */
+	attention: text("attention"),
 	durationMs: integer("duration_ms"),
 	exitCode: integer("exit_code"),
 	finalText: text("final_text"),
@@ -403,7 +395,6 @@ var blobs = pgTable("blobs", {
 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"),
@@ -486,7 +477,6 @@ function migrationsDir() {
 	if (fs.existsSync(builtDir)) return builtDir;
 	return devDir;
 }
-/** Apply generated migrations in-process (idempotent). */
 async function runMigrations() {
 	const dir = migrationsDir();
 	if (!fs.existsSync(dir)) return;
@@ -637,7 +627,7 @@ function createBlobStore() {
 * 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
+* text/code artifact names. The server is authoritative: bytes live in the
 * content-addressed BlobStore and the current version of each name is an
 * `artifact_files` row. For each run the daemon downloads the current files into
 * a private run directory, and the terminal report carries the changed versions
@@ -651,6 +641,7 @@ function createBlobStore() {
 */
 var loopFiles_exports = /* @__PURE__ */ __exportAll({
 	ARTIFACT_BYTE_CAP: () => ARTIFACT_BYTE_CAP,
+	ARTIFACT_EXTENSIONS: () => ARTIFACT_EXTENSIONS,
 	EMPTY_SHA256: () => EMPTY_SHA256,
 	LOOP_FILE_BYTE_CAP: () => LOOP_FILE_BYTE_CAP,
 	LoopFiles: () => LoopFiles,
@@ -668,26 +659,107 @@ 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;
+/** 256 KB bounds a run's upload and keeps dashboard rendering smooth. */
+var ARTIFACT_BYTE_CAP = 256 * 1024;
+var ARTIFACT_LIMIT_LABEL = `${ARTIFACT_BYTE_CAP / 1024} KB`;
 /** sha256 of zero bytes: the version of a loop file that has never been written. */
 var EMPTY_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
-var ARTIFACT_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}\.(md|html)$/;
+/** Text/code formats accepted as artifacts. Loop files are NUL-free text, so
+*  binary formats (images, PDFs, archives) are deliberately absent; `.svg` is
+*  text and renders through the hardened inline image route. */
+var ARTIFACT_EXTENSIONS = [
+	"md",
+	"markdown",
+	"mdx",
+	"html",
+	"htm",
+	"txt",
+	"text",
+	"rst",
+	"adoc",
+	"org",
+	"sh",
+	"bash",
+	"zsh",
+	"fish",
+	"ps1",
+	"bat",
+	"cmd",
+	"py",
+	"rb",
+	"pl",
+	"lua",
+	"r",
+	"js",
+	"mjs",
+	"cjs",
+	"ts",
+	"tsx",
+	"jsx",
+	"go",
+	"rs",
+	"java",
+	"kt",
+	"kts",
+	"scala",
+	"c",
+	"h",
+	"cc",
+	"cpp",
+	"hpp",
+	"cs",
+	"php",
+	"swift",
+	"dart",
+	"ex",
+	"exs",
+	"erl",
+	"hs",
+	"clj",
+	"cljs",
+	"json",
+	"jsonl",
+	"yaml",
+	"yml",
+	"toml",
+	"xml",
+	"csv",
+	"tsv",
+	"svg",
+	"css",
+	"scss",
+	"sass",
+	"less",
+	"sql",
+	"ini",
+	"conf",
+	"cfg",
+	"env",
+	"properties",
+	"diff",
+	"patch",
+	"tex",
+	"log"
+];
+var ARTIFACT_EXTENSION_SET = new Set(ARTIFACT_EXTENSIONS);
+var ARTIFACT_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}\.([A-Za-z0-9]{1,16})$/;
 function sha256Buf(bytes) {
 	return createHash("sha256").update(bytes).digest("hex");
 }
 function isValidHash(hash) {
 	return typeof hash === "string" && /^[0-9a-f]{64}$/.test(hash);
 }
-/** A plain file name (no directories) ending in .md or .html, other than MEMORY.md. */
+/** A plain text/code file name (no directories) other than MEMORY.md. */
 function validArtifactName(name) {
-	return typeof name === "string" && ARTIFACT_NAME_RE.test(name) && name.toLowerCase() !== "MEMORY.md".toLowerCase();
+	if (typeof name !== "string" || name.toLowerCase() === "MEMORY.md".toLowerCase()) return false;
+	const match = ARTIFACT_NAME_RE.exec(name);
+	return match !== null && ARTIFACT_EXTENSION_SET.has(match[1].toLowerCase());
 }
 function loopFileNames(loop) {
 	return [MEMORY_FILE, ...loop.artifacts];
 }
 function fileLimitLabel(name) {
-	return name === "MEMORY.md" ? `${MEMORY_CHAR_CAP} characters` : "2 MB";
+	return name === "MEMORY.md" ? `${MEMORY_CHAR_CAP} characters` : ARTIFACT_LIMIT_LABEL;
 }
 /** Why `bytes` cannot become the next version of `name`, or undefined if it can. */
 function loopFileIssue(name, bytes) {
@@ -697,7 +769,7 @@ function loopFileIssue(name, bytes) {
 		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`;
+	if (bytes.length > 262144) return `${name}: ${(bytes.length / 1024).toFixed(1)} KB exceeds the ${ARTIFACT_LIMIT_LABEL} limit`;
 }
 /** The largest byte size any loop file can have (a code point is at most 4 bytes). */
 var LOOP_FILE_BYTE_CAP = Math.max(ARTIFACT_BYTE_CAP, MEMORY_CHAR_CAP * 4);
@@ -721,10 +793,7 @@ var LoopFiles = class {
 		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.
-*/
+/** Data-access layer over Drizzle. Loop-locked state transitions live here. */
 var store_exports = /* @__PURE__ */ __exportAll({
 	TERMINAL_REPORT_GRACE_MS: () => TERMINAL_REPORT_GRACE_MS,
 	acknowledgeRetiredReport: () => acknowledgeRetiredReport,
@@ -1928,19 +1997,15 @@ async function countRunSnapshots() {
 	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.
+* Machine and run credentials. A device token (`dk_…`) identifies a machine whose
+* id is derived from it (`m-sha256(token)[:16]`). A run lease (`rk_…`) is minted per
+* delivery and authorizes only that run's loop-file transfer and terminal report;
+* its lifecycle is the state machine on `RunLease`.
 *
-* Leases and connect-key bindings are DURABLE (run_leases / connect_keys
-* tables): they must survive a deploy, or every restart 401s the in-flight
-* runs' callbacks/finalize and prevents a freshly connected machine from
-* enrolling. The 15-minute `new` idempotency window stays in-process;
-* losing it only degrades retry deduplication, never persisted data.
+* Leases and connect-key bindings are durable so a restart neither rejects
+* in-flight reports nor blocks a just-connected machine from enrolling. The
+* 15-minute `new` idempotency window stays in memory; losing it on restart only
+* weakens retry deduplication.
 */
 var tokens_exports = /* @__PURE__ */ __exportAll({
 	CONNECT_KEY_TTL_MS: () => CONNECT_KEY_TTL_MS,
@@ -2203,8 +2268,8 @@ function validateLoopTags(value) {
 	};
 }
 //#endregion
-//#region node_modules/.nitro/vite/services/ssr/assets/boot-DmpKtb0A.js
-var boot_DmpKtb0A_exports = /* @__PURE__ */ __exportAll$1({
+//#region node_modules/.nitro/vite/services/ssr/assets/boot-CecCDRoH.js
+var boot_CecCDRoH_exports = /* @__PURE__ */ __exportAll$1({
 	_: () => validOptionalPollString,
 	a: () => POLL_HTTP_BODY_FIELDS,
 	c: () => MIN_DAEMON_VERSION,
@@ -2296,11 +2361,8 @@ function validOptionalPollString(value, cap) {
 function nowIso() {
 	return (/* @__PURE__ */ new Date()).toISOString();
 }
-/** Strip NUL (U+0000) from a wire string: Postgres text/jsonb columns REJECT the
-*  NUL byte (SQLite tolerated it), so a daemon-supplied string carrying one would
-*  throw mid-finalize on the DB write. The single sanitizing primitive behind
-*  `clipText` - and used directly by `cli.ts`
-*  (parseFlags/validateState, the same one-chokepoint discipline). */
+/** Postgres text/jsonb columns reject NUL, so a daemon-supplied string carrying
+*  one would fail mid-finalize. The single sanitizer behind `clipText` and `cli.ts`. */
 function stripNul(s) {
 	return s.replace(/\u0000/g, "");
 }
@@ -2311,13 +2373,14 @@ function clipText(s, cap) {
 *  directory before launch (and exports as an env var of the same name). */
 var LOOP_DIR_PLACEHOLDER = "$PIEVO_LOOP_DIR";
 var STATUS_LINE_RE = /^STATUS:\s*(keep|no-change|block)\.?$/i;
+var ATTENTION_LINE_RE = /^ATTENTION:\s*(.*)$/i;
 /**
 * Deliver the user's prompt unchanged, followed by the status definitions, the
 * loop-file contract, and the final-line status contract. The run index
 * intentionally remains an internal history fact.
 */
 function buildRunTask(loop, previousNotices = []) {
-	const files = [`- ${MEMORY_FILE}: this loop's 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 files = [`- ${MEMORY_FILE}: this loop's long-term experience (max ${MEMORY_CHAR_CAP} characters). Read it first and follow it. Before finishing, record only lessons this run learned the hard way that make later runs faster or safer: a pitfall hit, a workaround found, an environment fact discovered. One line each; correct or delete lessons that proved wrong. Never restate the task or these instructions, and never store state, results, baselines, trends, or run logs (those go in an artifact). Most runs add nothing.`, ...loop.artifacts.map((name) => `- ${name}: artifact shown on the Pievo dashboard (max ${fileLimitLabel(name)}). Update it only as the task above asks.`)];
 	const notices = previousNotices.length ? `\n\nNotices from the previous run:\n${previousNotices.map((notice) => `- ${notice}`).join("\n")}` : "";
 	return `${loop.prompt}
 
@@ -2325,18 +2388,23 @@ Status definitions:
 - keep: ${loop.statusKeep}
 - no-change: ${loop.statusNoChange}
 - block: ${loop.statusBlock}
+A block pauses the loop until the owner restarts it.
 
 Loop files in ${LOOP_DIR_PLACEHOLDER}:
 ${files.join("\n")}
 A file over its limit is rejected and its previous version kept. Other files in that directory are discarded.${notices}
 
-End your final response with a short summary, then exactly one last line:
+Be concise in everything you write: lead with what changed or needs action; prefer tables and short lists; no filler or restated instructions.
+
+Your final response is only: a summary of at most five short lines (no headings, no repeated tables or file contents); if the owner should look at something, one line \`ATTENTION: <reason>\`; then exactly one last line:
 STATUS: keep|no-change|block`;
 }
+var bareLine = (line) => line.trim().replace(/^[*_`>\s]+|[*_`\s]+$/g, "");
 /**
-* Split a provider's final response into the reported status 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.
+* Split a provider's final response into the reported status, an optional
+* attention reason from the ATTENTION lines just above it, and the summary. The final
+* non-empty line must be the status line; markdown emphasis or code ticks around
+* either line are tolerated because models add them unprompted.
 */
 function parseFinalStatus(finalText) {
 	if (!finalText) return void 0;
@@ -2344,12 +2412,26 @@ function parseFinalStatus(finalText) {
 	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);
+	const match = STATUS_LINE_RE.exec(bareLine(lines[index]));
 	if (!match) return void 0;
+	const status = match[1].toLowerCase();
+	const reasons = [];
+	let end = index;
+	for (;;) {
+		let previous = end;
+		while (previous > 0 && lines[previous - 1].trim() === "") previous--;
+		const attentionMatch = previous > 0 ? ATTENTION_LINE_RE.exec(bareLine(lines[previous - 1])) : null;
+		if (!attentionMatch) break;
+		end = previous - 1;
+		const reason = attentionMatch[1].trim();
+		if (reason && !/^(none|n\/a|-)$/i.test(reason)) reasons.unshift(reason);
+	}
+	const joined = reasons.join("; ");
+	const attention = joined ? joined.length > 200 ? `${joined.slice(0, 199)}…` : joined : null;
 	return {
-		status: match[1].toLowerCase(),
-		message: lines.slice(0, index).join("\n").trim()
+		status,
+		message: lines.slice(0, end).join("\n").trim(),
+		attention
 	};
 }
 async function buildDelivery(loop, queuedRun, runToken, roots) {
@@ -2373,31 +2455,11 @@ async function buildDelivery(loop, queuedRun, runToken, roots) {
 	};
 }
 /**
-* Loop-file storage retention + garbage collection — the policy that keeps the
-* local byte store from growing monotonically.
-*
-* 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:
-*
-*   1. pruneSnapshots() — bound the per-loop run-snapshot history to a window, so
-*      old snapshots stop pinning the blobs they referenced for diffs.
-*   2. gcBlobs()        — delete blob bytes no LIVE row needs: a blob is collected
-*      only when NO artifact_files row AND NO retained run_snapshot references its
-*      hash. CORRECTNESS over aggressiveness — a still-referenced blob is never
-*      deleted; a leaked blob is only a cost bug the next pass reclaims.
-*
-* Concurrency: gcBlobs is safe 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 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.
+* Loop-file storage retention. Blob bytes are content-addressed and shared, so
+* replacing a file never frees its old blob by itself. pruneSnapshots() bounds
+* per-loop snapshot history; gcBlobs() then deletes bytes no file row and no
+* retained snapshot references. Correctness wins over aggressiveness: a leaked
+* blob is a storage cost the next pass reclaims, a deleted live blob is data loss.
 */
 var log$2 = logger.child({ mod: "retention" });
 /**
@@ -2411,28 +2473,14 @@ async function pruneSnapshots(keep = 20) {
 	return pruned;
 }
 /**
-* Reclaim unreferenced blob bytes. Returns the number of blobs collected.
-*
-* Algorithm:
-*   1. Compute the live keep-set (all hashes any artifact_files row / retained
-*      snapshot references) and the grace-windowed candidate list — both reads are
-*      synchronous (interleave-free under the single-threaded event loop).
-*   2. Garbage = candidates not in the keep-set.
-*   3. For each garbage hash, in order:
-*      a. Pre-delete guard: if a sync re-referenced it since the keep-set was
-*         computed, skip it — leaving both its bytes AND metadata row intact
-*         (a consistent live blob, nothing to heal). The guard is two O(1) checks:
-*         an indexed artifact_files point query (always fresh) plus membership in a
-*         snapshot-hash Set deserialized ONCE per pass and rebuilt only when the
-*         snapshot row count changes (a report() raced us) — never the old
-*         per-candidate full snapshot scan (which was O(garbage × snapshots), since
-*         genuine garbage always misses the file check and fell through to it).
-*      b. Otherwise delete the BYTES (the await), then drop the metadata row
-*         UNCONDITIONALLY. Bytes-before-metadata is the data-loss fix: if a sync
-*         raced the byte delete (re-referencing the hash + recreating the blobs
-*         row mid-await), dropping the metadata still leaves blobExists()=false,
-*         so that file re-uploads its bytes on the next sync. We never leave a
-*         live blobs row pointing at deleted bytes.
+* Reclaim unreferenced blob bytes; returns the number collected. Safe alongside
+* owner writes and run uploads because of three guards:
+*  - grace window: blobs whose metadata row is younger than `graceMs` are skipped;
+*  - per-candidate re-check right before deletion: an indexed file-row lookup plus
+*    a snapshot-hash set rebuilt only when the snapshot count changes (a concurrent
+*    report), instead of an O(garbage x snapshots) scan;
+*  - bytes before metadata: the metadata row is dropped after the bytes even if a
+*    writer raced the delete, so blobExists() is false and that writer re-uploads.
 */
 async function gcBlobs(blobStore, graceMs = BLOB_GC_GRACE_MS) {
 	const refs = await liveBlobRefs();
@@ -2816,7 +2864,7 @@ function validateArtifactNames(value) {
 	for (const entry of value) {
 		if (!validArtifactName(entry)) return {
 			ok: false,
-			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)}`
+			detail: `artifact must be a plain text/code file name other than ${MEMORY_FILE} (supported extensions: ${ARTIFACT_EXTENSIONS.join(", ")}; letters, digits, . _ -; at most 64 characters before the extension): ${JSON.stringify(entry)}`
 		};
 		const key = entry.toLowerCase();
 		if (seen.has(key)) return {
@@ -3077,22 +3125,16 @@ var validPollWireId = (value) => typeof value === "string" && value.length <= 20
 var validPollCurrentRun = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 2 && Object.prototype.hasOwnProperty.call(value, "runId") && Object.prototype.hasOwnProperty.call(value, "stage") && validPollWireId(value.runId) && (value.stage === "executing" || value.stage === "reporting");
 var validPollInfo = (value) => value === void 0 || value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).every((key) => POLL_INFO_FIELDS.has(key)) && validOptionalPollString(value.host, 524288) && validOptionalPollString(value.platform, 524288) && validOptionalPollString(value.arch, 524288) && validOptionalPollString(value.version, 64);
 /**
-* Machine gateway - the run-lifecycle core of the HTTP surface the daemon talks
-* to (poll transport: short-poll while a run is in flight, opt-in server-held
-* long-poll while idle). Framework-agnostic like the rest of the gateway
-* (return `{ status, body }` so the methods can be mounted on a plain http
-* server or TanStack server routes):
+* Machine gateway: the run-lifecycle core the daemon talks to. Methods return
+* transport-free `{ status, body }` results for the thin route shells:
 *
-*   POST /api/machine/poll   (Bearer device token) → claim pending runs, deliver
-*   POST /machine/report     (Bearer run token)    → finalize a run
-*   GET|PUT /api/machine/run-files/:name (Bearer run token) → loop-file transfer
+*   POST /api/machine/poll                (device token) claim and deliver runs
+*   POST /machine/report                  (run token)    finalize a run
+*   GET|PUT /api/machine/run-files/:name  (run token)    loop-file transfer
 *
-* plus owner create/list/edit methods and retention.
-* Also exposes `dispatcher` (a `Dispatcher` for the Scheduler: "is the machine
-* online?") and `sweep()` (mark stale machines offline, reclaim stuck runs).
-* CLI verb dispatch at `/api/machine/cli` lives in `gateway/cli.ts`
-* (`CliGateway`), which reuses this class's owner methods;
-* canonical loop configuration validation lives in `gateway/loopConfig.ts`.
+* Idle polls may be held open (long-poll) until the scheduler's dispatcher wakes
+* them. `sweep()` marks stale machines offline and reclaims silent runs. CLI verbs
+* live in `cli.ts`; loop config validation lives in `loopConfig.ts`.
 */
 var log$1 = logger.child({ mod: "gateway" });
 var ONLINE_TTL_MS = 3e4;
@@ -3269,6 +3311,7 @@ function reportOutcome(body) {
 		patch: {
 			status: parsed.status,
 			message: clipText(parsed.message, 2e3) || null,
+			attention: parsed.attention,
 			error: null
 		}
 	};
@@ -3352,7 +3395,6 @@ var MachineGateway = class {
 		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
@@ -3430,20 +3472,12 @@ var MachineGateway = class {
 		await pruneExpiredLeases(now);
 		for (const loop of await listLoops()) if (loop.deleteRequestedAt) await tryDeleteLoop(loop.id);
 	}
-	/** Finalize one stuck run as an error (the sweep's reclaim path): persist the
-	*  failure, TERMINALIZE its run lease (flip it to `terminal-grace` rather than
-	*  retiring it outright), while preserving a bounded reconciliation window.
-	*
-	*  Why terminalize, not retire: the usual cause is a laptop that merely fell
-	*  ASLEEP mid-run. When it wakes, claude finishes and the daemon delivers the real
-	*  (often SUCCESSFUL) result. Retiring the lease here would 401 that late report
-	*  and strand the run as a permanent false failure with its message lost (the
-	*  investigated bug). So the lease survives a bounded grace window
-	*  (`TERMINAL_GRACE_MS`) during which exactly ONE late wake-report may reconcile
-	*  the run — see `report()`'s terminal-grace branch. The credential is still
-	*  bounded: CLI mutations are refused while terminal-grace, and the
-	*  reconciliation retires the lease single-shot. Pending rows are durable inbox
-	*  entries and are never reclaimed by this path. */
+	/** Reclaim one silent running run as an error, but terminalize its lease instead
+	*  of retiring it. The usual cause is a laptop that fell asleep mid-run; on wake
+	*  the daemon delivers the real (often successful) result, and a retired lease
+	*  would 401 it and leave a false failure. During TERMINAL_GRACE_MS exactly one
+	*  late report may reconcile the run (see `report()`); CLI mutations stay refused.
+	*  Pending rows are durable queue entries and never reach this path. */
 	async reclaimRun(run, reason) {
 		if (run.phase !== "running") return;
 		const at = nowIso();
@@ -3629,11 +3663,8 @@ var MachineGateway = class {
 			waiter.cancel();
 		}
 	}
-	/**
-	* Whether this machine (by device token) currently has a live daemon — so
-	* Claude Code can avoid starting a duplicate. `online` is fresh-checked against
-	* the poll TTL, not just the stored flag.
-	*/
+	/** Whether this machine has a live daemon. `online` is fresh-checked against the
+	*  poll TTL, not just the stored flag. */
 	async status(deviceToken) {
 		const auth = await authenticateDeviceToken(deviceToken, { allowUnknown: true });
 		if (!auth.ok) return auth.response;
@@ -4694,6 +4725,7 @@ function normalizedListRun(run) {
 		terminalAt: run.ts,
 		phase: run.phase,
 		status: run.status ?? null,
+		attention: run.attention ?? null,
 		durationMs: run.durationMs ?? null,
 		tokenUsage: totalTokenUsage(run.usage ?? null),
 		message: message.value,
@@ -4748,6 +4780,7 @@ async function listHistory(loop, q) {
 		"terminal",
 		"phase",
 		"status",
+		"attention",
 		"durationMs",
 		"tokenUsage",
 		"message",
@@ -4757,6 +4790,7 @@ async function listHistory(loop, q) {
 		fmt(run.ts),
 		run.phase,
 		run.status ?? null,
+		run.attention ?? null,
 		run.durationMs ?? null,
 		totalTokenUsage(run.usage ?? null),
 		run.message ? truncate(run.message, 500, "use --run for detail").value : null,
@@ -4804,6 +4838,7 @@ async function detailHistory(loop, q) {
 		terminalAt: TERMINAL_PHASES.includes(run.phase) ? run.ts : null,
 		phase: run.phase,
 		status: run.status ?? null,
+		attention: run.attention ?? null,
 		durationMs: run.durationMs ?? null,
 		tokenUsage: totalTokenUsage(run.usage ?? null),
 		message: message.value,
@@ -4830,6 +4865,7 @@ async function detailHistory(loop, q) {
 		["terminalAt", detail.terminalAt],
 		["phase", detail.phase],
 		["status", detail.status],
+		["attention", detail.attention],
 		["durationMs", detail.durationMs],
 		["tokenUsage", detail.tokenUsage],
 		["message", detail.message],
@@ -4853,18 +4889,10 @@ async function readLoopHistory(loop, flags) {
 	return parsed.value.mode === "detail" ? detailHistory(loop, parsed.value) : listHistory(loop, parsed.value);
 }
 /**
-* CLI dispatch - the credential-keyed verb router half of the machine gateway,
-* split out of `MachineGateway` (which keeps poll/report/sweep/owner verbs).
-* Same wire surface, framework-agnostic like the rest of the gateway
-* (`{ status, body }` results):
-*
-*   POST /api/machine/cli  (Bearer device OR run credential) → unified dispatch
-*
-* The verb router keys authority on credential type first (`dk_` device prefix
-* vs `rk_` run lease) and reuses the core gateway
-* methods (`createLoop`/`editLoop`) through the injected `MachineGateway`,
-* plus the credential-neutral history module. Run credentials authorize no CLI
-* verb: a run reports through its final response, not a callback.
+* `/api/machine/cli` verb router. Authority keys on credential type: a device
+* (`dk_`) token gets owner verbs over loops bound to its machine, reusing
+* `MachineGateway`'s owner methods; a run (`rk_`) token gets no verb, because a
+* run reports only through its final response.
 */
 var cliLog = logger.child({ mod: "cli" });
 var CliGateway = class {
@@ -4878,14 +4906,6 @@ var CliGateway = class {
 		this.forceDeleteLoop = deps.forceDeleteLoop ?? forceDeleteLoop;
 		this.destructiveLog = deps.destructiveLog ?? ((event) => cliLog.warn(event, "force-delete: destructive server authority removal"));
 	}
-	/**
-	* The unified CLI endpoint. It is a ROUTER in front of the gateway logic that
-	* already exists — never a rewrite — that keys authority on the credential type:
-	*   · DEVICE credential (`dk_`-prefixed) → owner authority over any loop bound to
-	*     the machine: `new`→createLoop, `loops`→listLoops, `edit`→editLoop,
-	*     `log`→readLoopHistory, `show`→describe, `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));
 	}
@@ -5648,14 +5668,8 @@ var Scheduler = class {
 function msg(err) {
 	return err instanceof Error ? err.message : String(err);
 }
-/**
-* Server boot — idempotent one-time init of the in-process backend: apply
-* migrations, wire the machine gateway's dispatcher into the Scheduler, start
-* the Scheduler + an offline-sweep interval. Guarded on `globalThis` so it
-* survives dev HMR and runs at most once per process. Call `ensureServer()`
-* from any server-side entry (the standalone machine server / TanStack server
-* fns); the first call boots, the rest share the same instance.
-*/
+/** One-time, idempotent in-process backend boot (migrations, scheduler, sweep and
+* storage-maintenance intervals). Guarded on `globalThis` to survive dev HMR. */
 var boot_exports = /* @__PURE__ */ __exportAll({
 	ensureServer: () => ensureServer,
 	getCliGateway: () => getCliGateway,
@@ -5713,4 +5727,4 @@ async function getCliGateway() {
 	return (await ensureServer()).cliGateway;
 }
 //#endregion
-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 };
+export { listRuns as A, reconciliationStatesForRuns as B, getRun as C, listArtifacts as D, isOutdated as E, machineIdFromToken as F, stopLoop as G, requestRunCancel as H, machinePresence as I, updateMachine as J, tryDeleteLoop as K, mintDeviceToken as L, loopFileNames as M, loopTags_Bi7Bm7v8_exports as N, listLoops as O, loopsForMachine as P, pauseLoop as R, getMachine as S, hasRunningRun as T, sha256 as U, requestDeleteLoop as V, startLoop as W, validateLoopTags as Y, createMachine as _, canonicalLoopSummary as a, getArtifactFile as b, getLoopFiles as c, validOptionalPollString as d, validPollCurrentRun as f, countRuns as g, CODING_AGENTS as h, canonicalLoopEnvelope as i, listRunsBefore as j, listMachines as k, readByteBody as l, validateLoopEdit as m, POLL_HTTP_BODY_FIELDS as n, daemonNeedsUpdate as o, validPollWireId as p, updateLoop as q, boot_CecCDRoH_exports as r, ensureServer as s, MIN_DAEMON_VERSION as t, readJsonBody as u, forceDeleteLoop as v, hasPendingRun as w, getLoop as x, forceDeleteMachine as y, recentLoopUsage as z };