@kky42/pievo-server 2.2.0 → 2.4.1

package/.output/server/_ssr/router-lMkobh5r.mjs

@@ -0,0 +1,618 @@
+import { j as sql } from "../_libs/drizzle-orm+postgres.mjs";
+import { A as ensureServer, Dt as readJsonBody, Et as readByteBody, Yt as validOptionalPollString, l as MACHINE_BODY_CAP } from "./boot-BbWxaF-z.mjs";
+import { h as require_jsx_runtime } from "../_libs/@base-ui/react+[...].mjs";
+import { c as createFileRoute, i as HeadContent, l as createRootRoute, o as createRouter, r as Scripts } from "../_libs/@tanstack/react-router+[...].mjs";
+import { t as Route$14 } from "./invite._token-BliJIGk4.mjs";
+import { r as imageMime, t as Route$15 } from "./artifactKind-ByzVa7fg.mjs";
+import { t as Route$16 } from "./loops._loopId_.runs._runId-a_SyY8rX.mjs";
+import { t as Route$17 } from "./routes-CRHc9cLG.mjs";
+import { t as Route$18 } from "./t._teamId-QD2nN0wn.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/router-lMkobh5r.js
+var import_jsx_runtime = require_jsx_runtime();
+var app_default = "/assets/app-BAgHQVvr.css";
+var Route$13 = createRootRoute({
+	head: () => ({
+		meta: [
+			{ charSet: "utf-8" },
+			{
+				name: "viewport",
+				content: "width=device-width, initial-scale=1"
+			},
+			{ title: "Pievo" }
+		],
+		links: [{
+			rel: "stylesheet",
+			href: app_default
+		}, {
+			rel: "icon",
+			type: "image/svg+xml",
+			href: "/favicon.svg"
+		}]
+	}),
+	shellComponent: RootDocument
+});
+function RootDocument({ children }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("html", {
+		lang: "en",
+		suppressHydrationWarning: true,
+		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("head", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(HeadContent, {}) }), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("body", {
+			className: "dot-grid-subtle bg-paper font-sans text-primary antialiased",
+			suppressHydrationWarning: true,
+			children: [children, /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Scripts, {})]
+		})]
+	});
+}
+var TokenBucketLimiter = class {
+	capacity;
+	refillPerSec;
+	maxKeys;
+	buckets = /* @__PURE__ */ new Map();
+	constructor(capacity, refillPerSec, maxKeys = 2e4) {
+		this.capacity = capacity;
+		this.refillPerSec = refillPerSec;
+		this.maxKeys = maxKeys;
+	}
+	/** Consume one token for `key`. Returns true if allowed, false if the bucket is dry. */
+	allow(key, now = Date.now()) {
+		let b = this.buckets.get(key);
+		if (!b) {
+			if (this.buckets.size >= this.maxKeys) this.evictOldest();
+			b = {
+				tokens: this.capacity,
+				last: now
+			};
+			this.buckets.set(key, b);
+		}
+		const elapsedSec = Math.max(0, (now - b.last) / 1e3);
+		b.tokens = Math.min(this.capacity, b.tokens + elapsedSec * this.refillPerSec);
+		b.last = now;
+		if (b.tokens >= 1) {
+			b.tokens -= 1;
+			return true;
+		}
+		return false;
+	}
+	/** Drop the least-recently-touched key (bounded memory under a distinct-key flood). */
+	evictOldest() {
+		let oldestKey;
+		let oldest = Number.POSITIVE_INFINITY;
+		for (const [k, b] of this.buckets) if (b.last < oldest) {
+			oldest = b.last;
+			oldestKey = k;
+		}
+		if (oldestKey !== void 0) this.buckets.delete(oldestKey);
+	}
+	/** Test seam — forget all state. */
+	reset() {
+		this.buckets.clear();
+	}
+};
+/** Parse a positive-number env override, falling back to `dflt` on absent/invalid. */
+function envNum(name, dflt) {
+	const raw = process.env[name]?.trim();
+	if (!raw) return dflt;
+	const n = Number(raw);
+	return Number.isFinite(n) && n > 0 ? n : dflt;
+}
+/**
+* Per-IP: default 240 burst + 8/sec sustained (≈480 req/min). One daemon does
+* ~20 polls/min plus sync bursts; this comfortably covers a dozen daemons behind a
+* shared NAT while still capping a single-IP flood.
+*/
+var ipLimiter = new TokenBucketLimiter(envNum("PIEVO_RL_IP_BURST", 240), envNum("PIEVO_RL_IP_PER_SEC", 8));
+/**
+* Per-token (per-machine): default 120 burst + 4/sec sustained. A single daemon
+* never approaches this; it bounds one credential's share of the process.
+*/
+var tokenLimiter = new TokenBucketLimiter(envNum("PIEVO_RL_TOKEN_BURST", 120), envNum("PIEVO_RL_TOKEN_PER_SEC", 4));
+/** Whether rate limiting is active. Off by default in tests unless opted in, so the
+*  large existing suites don't trip it; ON in a real server process. */
+function rateLimitEnabled() {
+	const flag = process.env.PIEVO_RATE_LIMIT?.trim().toLowerCase();
+	if (flag === "0" || flag === "false" || flag === "off") return false;
+	if (flag === "1" || flag === "true" || flag === "on") return true;
+	return process.env.VITEST !== "true";
+}
+/**
+* Best-effort client IP from the request, honoring the usual proxy headers (Fly
+* sets `Fly-Client-IP`; a generic proxy sets `X-Forwarded-For`). Falls back to a
+* single shared key so a missing IP still shares ONE bucket (fail-closed: unknown
+* origins can't each get a private allowance). Only the FIRST `X-Forwarded-For` hop
+* is trusted (the client-facing edge appends left-to-right).
+*/
+function clientIp(request) {
+	const h = request.headers;
+	const fly = h.get("fly-client-ip");
+	if (fly) return fly.trim();
+	const xff = h.get("x-forwarded-for");
+	if (xff) {
+		const first = xff.split(",")[0]?.trim();
+		if (first) return first;
+	}
+	const real = h.get("x-real-ip");
+	if (real) return real.trim();
+	return "unknown";
+}
+/**
+* A 429 response with a Retry-After hint. Carries `text` + `exitCode` alongside
+* `error` so `/api/machine/cli` can print the response directly.
+*/
+function tooMany() {
+	return Response.json({
+		error: "rate limited — slow down",
+		text: "rate limited — slow down",
+		exitCode: 1
+	}, {
+		status: 429,
+		headers: { "retry-after": "1" }
+	});
+}
+/**
+* Enforce the machine-route rate limits for one request. Call it at the top of a
+* machine route handler, right after reading the Bearer token (pass it so a valid
+* daemon keys off its own per-machine bucket). Returns a 429 `Response` to return
+* verbatim, or null to proceed. Both tiers apply: the per-IP flood guard always,
+* and the per-token fairness tier whenever a credential is present. (The byte-
+* ingress routes are exempt entirely and simply do not call this — see the module
+* doc.)
+*/
+function machineRouteLimit(request, token, opts = {}) {
+	if (!rateLimitEnabled()) return null;
+	const now = opts.now ?? Date.now();
+	if (!ipLimiter.allow(clientIp(request), now)) return tooMany();
+	if (token && !tokenLimiter.allow(token, now)) return tooMany();
+	return null;
+}
+/** POST /machine/report — finalize a run (Bearer run token). */
+var Route$12 = createFileRoute("/machine/report")({ server: { handlers: { POST: async ({ request }) => {
+	const auth = request.headers.get("authorization") ?? "";
+	const token = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+	const limited = machineRouteLimit(request, token || void 0);
+	if (limited) return limited;
+	if (!token) return Response.json({ error: "missing token" }, { status: 401 });
+	const parsed = await readJsonBody(request, MACHINE_BODY_CAP);
+	if (parsed.kind === "too-large") return Response.json({ error: "body too large" }, { status: 413 });
+	const body = parsed.kind === "ok" && parsed.body && typeof parsed.body === "object" ? parsed.body : {};
+	const { getGateway } = await import("./boot-COHf8Gv3.mjs");
+	const r = await (await getGateway()).report(token, body);
+	return Response.json(r.body, { status: r.status });
+} } } });
+/**
+* Deep readiness for process launchers. Unlike /api/health, this waits for the
+* one-time backend boot (migrations, blob-store selection, and scheduler start).
+* The per-launch nonce lets a launcher reject a different process already bound
+* to the requested port.
+*/
+async function readyResponse(ensure = ensureServer, env = process.env) {
+	await ensure();
+	return Response.json({
+		ok: true,
+		nonce: env.PIEVO_SERVER_LAUNCH_NONCE ?? null
+	});
+}
+var Route$11 = createFileRoute("/api/ready")({ server: { handlers: { GET: () => readyResponse() } } });
+var buildSha = () => process.env.GIT_SHA || "unknown";
+var buildAt = () => process.env.BUILT_AT || "unknown";
+var Route$10 = createFileRoute("/api/health")({ server: { handlers: { GET: async () => Response.json({
+	ok: true,
+	sha: buildSha(),
+	builtAt: buildAt()
+}) } } });
+var bootstrap_default = "# Pievo — connect this machine and create a scheduled prompt\n\nYou're reading this because the user pasted a Pievo capture snippet (`Fetch\n<server-url>/api/bootstrap and help me build a loop.`). Their Pievo web tab is waiting\nfor the machine and new loop. Work end to end, with short confirmations rather than a\nlong interview.\n\n## Pasted values\n\nUse these values exactly as supplied:\n\n- **server-url** — the Pievo server base URL.\n- **connect-key** — the one-time machine connection and web-dialog claim.\n- **pievo-cli** *(optional)* — the command prefix for every Pievo invocation. If it is\n  absent, use `pievo` after installing the current package.\n- An optional task description below the values — the requested scheduled prompt.\n\n## 1 · Connect\n\nFetch and follow the connection reference:\n\n```text\n<server-url>/api/skill/references/connect.md\n```\n\nPass the pasted `server-url` and `connect-key` to its daemon start command. Do not\nreplace a supplied custom `pievo-cli` prefix.\n\n## 2 · Create\n\nAfter the daemon reports the machine online, fetch and follow:\n\n```text\n<server-url>/api/skill/references/create.md\n```\n\nThe create reference owns the remaining flow: identify the concrete prompt, confirm\nits exclusive cron or continuous schedule and three status definitions, choose the\nworking directory and coding agent, optionally select exact artifact files, preview the\ncanonical JSON, and run `pievo new`. On this first-capture path, pass the same\n`connect-key` to `pievo new` so the created loop appears in the waiting web dialog.\n\nPievo is a scheduled prompt runner. Configure only the fields listed in the create\nreference. The stored user prompt is delivered unchanged, followed only by Pievo's\ncomplete status/report contract.\n";
+/** GET /api/bootstrap — the first-capture bootstrap doc Claude Code follows (see ComposeModal). */
+var Route$9 = createFileRoute("/api/bootstrap")({ server: { handlers: { GET: () => new Response(bootstrap_default, { headers: {
+	"content-type": "text/markdown; charset=utf-8",
+	"cache-control": "no-cache"
+} }) } } });
+/**
+* POST /api/machine/sync — exact artifact sync (Bearer DEVICE token). The daemon
+* posts the complete configured-path manifest after a run; the server reconciles
+* artifact_files and replies with needHashes for raw blob PUTs.
+* The manifest route retains its dedicated 32 MB JSON-body limit.
+*
+* This byte-ingress route is deliberately NOT rate limited (same rationale as the
+* blob PUT): it requires a valid registered device token (unknown ⇒ 401) and is
+* already bounded by the exact-path/hash handshake and 32MB sync-body cap, so a
+* limiter would only throttle a legitimate large sync.
+*/
+var Route$8 = createFileRoute("/api/machine/sync")({ server: { handlers: { POST: async ({ request }) => {
+	const auth = request.headers.get("authorization") ?? "";
+	const token = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+	if (!token) return Response.json({ error: "missing device token" }, { status: 401 });
+	const { SYNC_BODY_CAP, parseArtifactSyncBody } = await import("./artifacts-BhQvaGjF.mjs");
+	const parsed = await readJsonBody(request, SYNC_BODY_CAP);
+	if (parsed.kind === "too-large") return Response.json({ error: "sync body too large" }, { status: 413 });
+	if (parsed.kind === "invalid") return Response.json({ error: "invalid JSON" }, { status: 400 });
+	const body = parseArtifactSyncBody(parsed.body);
+	if (!body) return Response.json({ error: "invalid sync body" }, { status: 400 });
+	const { getArtifactSync } = await import("./boot-COHf8Gv3.mjs");
+	const r = await (await getArtifactSync()).sync(token, body);
+	return Response.json(r.body, { status: r.status });
+} } } });
+/** GET /api/machine/status — is this machine's daemon live? (Bearer device token) */
+var Route$7 = createFileRoute("/api/machine/status")({ server: { handlers: { GET: async ({ request }) => {
+	const auth = request.headers.get("authorization") ?? "";
+	const token = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+	const limited = machineRouteLimit(request, token || void 0);
+	if (limited) return limited;
+	if (!token) return Response.json({ error: "missing device token" }, { status: 401 });
+	const { getGateway } = await import("./boot-COHf8Gv3.mjs");
+	const r = await (await getGateway()).status(token);
+	return Response.json(r.body, { status: r.status });
+} } } });
+var POLL_BODY_FIELDS = new Set([
+	"host",
+	"platform",
+	"arch",
+	"version",
+	"protocolVersion",
+	"currentRuns",
+	"daemonInstanceId",
+	"recoveryComplete"
+]);
+var validWireId = (value) => typeof value === "string" && value.length <= 200 && value.trim().length > 0 && !value.includes("\0");
+var validCurrentRun = (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") && validWireId(value.runId) && (value.stage === "executing" || value.stage === "reporting");
+/** Reject non-object bodies, additions, coercible types, over-cap strings, and
+* NUL-bearing text before the gateway is loaded or any state can mutate. */
+function parsePollBody(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+	if (Object.keys(value).some((key) => !POLL_BODY_FIELDS.has(key))) return null;
+	const body = value;
+	if (!validOptionalPollString(body.host, 524288) || !validOptionalPollString(body.platform, 524288) || !validOptionalPollString(body.arch, 524288) || !validOptionalPollString(body.version, 64)) return null;
+	if (body.protocolVersion !== void 0 && (typeof body.protocolVersion !== "number" || !Number.isInteger(body.protocolVersion))) return null;
+	if (body.currentRuns !== void 0 && (!Array.isArray(body.currentRuns) || body.currentRuns.some((run) => !validCurrentRun(run)))) return null;
+	if (body.daemonInstanceId !== void 0 && !validWireId(body.daemonInstanceId)) return null;
+	if (body.recoveryComplete !== void 0 && typeof body.recoveryComplete !== "boolean") return null;
+	return body;
+}
+/** Keep the HTTP adapter's protocol forwarding independently testable. */
+function gatewayPollRequest(body) {
+	return {
+		protocolVersion: body.protocolVersion,
+		currentRuns: body.currentRuns,
+		daemonInstanceId: body.daemonInstanceId,
+		recoveryComplete: body.recoveryComplete,
+		info: {
+			host: body.host,
+			platform: body.platform,
+			arch: body.arch,
+			version: body.version
+		}
+	};
+}
+/** POST /api/machine/poll — daemon claims this machine's pending runs (Bearer device token). */
+var Route$6 = createFileRoute("/api/machine/poll")({ server: { handlers: { POST: async ({ request }) => {
+	const auth = request.headers.get("authorization") ?? "";
+	const token = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+	const limited = machineRouteLimit(request, token || void 0);
+	if (limited) return limited;
+	if (!token) return Response.json({ error: "missing device token" }, { status: 401 });
+	const parsed = await readJsonBody(request, MACHINE_BODY_CAP);
+	if (parsed.kind === "too-large") return Response.json({ error: "body too large" }, { status: 413 });
+	if (parsed.kind !== "ok") return Response.json({ error: "invalid JSON body" }, { status: 400 });
+	const body = parsePollBody(parsed.body);
+	if (!body) return Response.json({ error: "unknown or invalid poll body fields" }, { status: 400 });
+	const { getGateway } = await import("./boot-COHf8Gv3.mjs");
+	const r = await (await getGateway()).pollV4Wait(token, gatewayPollRequest(body));
+	return Response.json(r.body, { status: r.status });
+} } } });
+function parseCliBody(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+	const body = value;
+	if (Object.keys(body).length !== 1 || !Object.prototype.hasOwnProperty.call(body, "argv")) return null;
+	if (!Array.isArray(body.argv) || body.argv.some((entry) => typeof entry !== "string")) return null;
+	return { argv: body.argv };
+}
+/**
+* POST /api/machine/cli — the ONE unified CLI dispatch (Bearer credential + `{argv}`).
+* `CliGateway.cli()` branches by credential type: a `dk_` device token takes owner
+* commands, while an `rk_` run credential can only report its run. Uses the standard
+* 2MB machine JSON body cap.
+*/
+var Route$5 = createFileRoute("/api/machine/cli")({ server: { handlers: { POST: async ({ request }) => {
+	const auth = request.headers.get("authorization") ?? "";
+	const token = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+	const limited = machineRouteLimit(request, token || void 0);
+	if (limited) return limited;
+	if (!token) return Response.json({ error: "missing credential" }, { status: 401 });
+	const parsed = await readJsonBody(request, MACHINE_BODY_CAP);
+	if (parsed.kind === "too-large") return Response.json({ error: "body too large" }, { status: 413 });
+	const body = parsed.kind === "ok" ? parseCliBody(parsed.body) : null;
+	if (!body) return Response.json({ error: "body must be exactly {argv:string[]}" }, { status: 400 });
+	const { getCliGateway } = await import("./boot-COHf8Gv3.mjs");
+	const r = await (await getCliGateway()).cli(token, body.argv);
+	return Response.json(r.body, { status: r.status });
+} } } });
+/**
+* DB-touching liveness probe — the ONE home for the wedged-pool incident rationale
+* (db/index.ts and the Fly checks point here). Unlike /api/health (which never
+* touches the DB and so reported `ok` right through a ~5.5h outage while a dead
+* postgres-js pool masked it), this runs a trivial `select 1` through the runtime
+* pool.
+*
+* This route SURFACES a wedged pool (Fly's check goes critical, which de-routes the
+* machine); it does NOT by itself recover it. Fly's failing `[http_service.checks]`
+* only pull the machine from load balancing — they never restart the VM (the
+* 2026-07-12 outage: pool wedged, check critical, box down ~9h with no auto-restart
+* until a manual `fly machine restart`). The ACTUAL auto-recovery is the in-process
+* DB watchdog (`server/dbWatchdog.ts`), which exits the process on a sustained wedge
+* so Fly's `restart.policy = "on-failure"` brings up a fresh pool.
+*
+* A wedged pool makes `select 1` HANG (queued behind stuck connections; the pool's
+* `statement_timeout` is unenforced under the Supabase transaction pooler). So the
+* probe races the query against a hard client-side deadline (`PROBE_TIMEOUT_MS`, <
+* Fly's 10s check timeout) and returns a fast 503 instead of eating the full timeout
+* "awaiting headers". 200 → DB reachable; 503 → the query failed or timed out.
+* Drizzle imported inside the handler so it stays out of the client bundle.
+*/
+var PROBE_TIMEOUT_MS = 5e3;
+var Route$4 = createFileRoute("/api/health/db")({ server: { handlers: { GET: async () => {
+	try {
+		const { db } = await import("./db-dw61xIt1.mjs");
+		const ping = db.execute(sql`select 1`);
+		const timeout = new Promise((_, reject) => {
+			setTimeout(() => reject(/* @__PURE__ */ new Error(`db ping timed out after ${PROBE_TIMEOUT_MS}ms`)), PROBE_TIMEOUT_MS).unref?.();
+		});
+		await Promise.race([ping, timeout]);
+		return Response.json({
+			ok: true,
+			db: "up"
+		});
+	} catch (err) {
+		return Response.json({
+			ok: false,
+			db: "down",
+			error: err instanceof Error ? err.message : String(err)
+		}, { status: 503 });
+	}
+} } } });
+/** Better Auth handler — GET/POST /api/auth/* (OAuth callbacks, session, sign-out). */
+var Route$3 = createFileRoute("/api/auth/$")({ server: { handlers: {
+	GET: async ({ request }) => (await import("./auth-CPCDf6Wr.mjs")).auth.handler(request),
+	POST: async ({ request }) => (await import("./auth-CPCDf6Wr.mjs")).auth.handler(request)
+} } });
+var REFERENCES = {
+	"connect.md": "# Connect a machine\n\nUse the **pievo-cli** command prefix supplied by the user; otherwise use `pievo`.\nA first-capture snippet supplies a **server-url** and one-time **connect-key**. Use\nboth verbatim.\n\nIf no custom command prefix was supplied, install the current CLI:\n\n```bash\nnpm install -g @kky42/pievo@latest\n```\n\nStart the daemon:\n\n```bash\n<pievo-cli> daemon start --server-url <server-url> --connect-key <connect-key>\n```\n\nThe command is idempotent: it reuses this machine's identity, starts one detached\ndaemon if needed, and waits for the server to see it online. It exits successfully\nwith `daemon online …` or `daemon already running …`. If it cannot connect, follow\nthe printed log path rather than guessing credentials or server settings.\n\nOnce connected, continue with `create.md` when the user wants a new loop. Existing\nconnections normally need no server URL or key on later `pievo` commands.\n",
+	"create.md": "# Create a loop\n\nA Pievo loop runs one server-stored prompt with one selected coding agent in a fixed\nworking directory. Use the **pievo-cli** prefix supplied by the user (default `pievo`).\nIf this machine is not connected, follow `connect.md` first.\n\n## 1 · Identify the prompt\n\nStart from concrete evidence in the current session:\n\n- If the user just completed or described a recurring task, turn that task into a\n  standalone prompt grounded in its real paths, commands, URLs, constraints, and\n  expected result.\n- If there is no task yet, inspect the project, propose a few useful scheduled prompts,\n  and let the user choose. Do not invent and create one silently.\n\nThe stored `prompt` is sent unchanged. Make it self-contained for a fresh coding-agent\nprocess, but do not add Pievo runtime instructions: the server appends the complete\nstatus definitions and required `pievo report` command.\n\n## 2 · Confirm schedule and outcomes\n\nBefore creating, propose any missing choices in one short message and get confirmation:\n\n- **Schedule:** use cron for wall-clock work or continuous for a fixed delay after the\n  prior run finishes. For cron, confirm the timezone and whether an occurrence while a\n  run is still open should `skip` or `queue-one` coalesced follow-up. Continuous never\n  overlaps.\n- **Statuses:** define what `keep`, `no-change`, and `block` mean for this task. All\n  three definitions are required and must be non-empty. `block` means owner attention\n  is required and pauses the loop.\n- **Artifacts:** if the user wants files visible in Pievo, list exact paths relative to\n  `workdir`. Use stable filenames. Globs, absolute paths, traversal, and directories\n  are not supported. Missing or unreadable files do not fail a run.\n\n## 3 · Author the canonical config\n\nCron example:\n\n```json\n{\n  \"name\": \"Daily dependency check\",\n  \"schedule\": {\n    \"mode\": \"cron\",\n    \"cron\": \"0 9 * * *\",\n    \"timezone\": \"America/Los_Angeles\",\n    \"overlap\": \"skip\"\n  },\n  \"workdir\": \"/absolute/path/to/project\",\n  \"agent\": \"claude-code\",\n  \"model\": null,\n  \"reasoningEffort\": null,\n  \"prompt\": \"Inspect the repository's open dependency updates. Verify each update against its exact diff and current checks, then write any safe action or reason to defer it to dependency-check.md.\",\n  \"statusDefinitions\": {\n    \"keep\": \"A verified action or useful finding was produced.\",\n    \"noChange\": \"The check completed and found no actionable change.\",\n    \"block\": \"Owner input or unavailable access prevents a safe decision.\"\n  },\n  \"artifacts\": [\"dependency-check.md\"],\n  \"enabled\": true\n}\n```\n\nContinuous schedule shape:\n\n```json\n{\n  \"mode\": \"continuous\",\n  \"delayMinutes\": 30\n}\n```\n\nRules:\n\n- Required: `name`, `schedule`, absolute `workdir`, `agent`, non-empty `prompt`, and\n  all three `statusDefinitions`.\n- `agent` is `claude-code` or `codex`.\n- `model` and `reasoningEffort` are optional strings. Omit them or use `null` to let\n  the selected coding-agent CLI use its default.\n- `artifacts` is optional and contains only exact workdir-relative file paths.\n- `enabled` is optional and defaults to `true`.\n- Cron and continuous are exclusive shapes. Do not mix their fields.\n\n## 4 · Validate, then create\n\nPreview the exact config first:\n\n```bash\n<pievo-cli> new --json '<config>' --dry-run\n```\n\nFix every rejection. Then create it:\n\n```bash\n<pievo-cli> new --json '<config>'\n```\n\nOn a first-capture flow, include the pasted claim so the web dialog resolves:\n\n```bash\n<pievo-cli> new --json '<config>' --connect-key <connect-key>\n```\n\nOn success, tell the user the loop name, schedule, working directory, selected agent,\nand whether any artifact files were configured.\n",
+	"update.md": "# Edit an existing loop\n\nUse the same **pievo-cli** prefix used to connect the machine (default `pievo`). The\nmachine's persisted device credential authorizes edits to loops bound to it.\n\nFind the loop and inspect its current editable envelope:\n\n```bash\n<pievo-cli> loops\n<pievo-cli> show <loop-id> --json\n```\n\nPatch only the requested fields with one JSON object. Preview before applying:\n\n```bash\n<pievo-cli> edit <loop-id> --json '<patch>' --dry-run\n<pievo-cli> edit <loop-id> --json '<patch>'\n```\n\nAccepted fields are:\n\n| field | value |\n|---|---|\n| `name` | non-empty string |\n| `schedule` | complete cron or continuous schedule object |\n| `workdir` | absolute working-directory path |\n| `agent` | `claude-code` or `codex` |\n| `model` | string or `null` for provider default |\n| `reasoningEffort` | string or `null` for provider default |\n| `prompt` | non-empty string, preserved as written |\n| `statusDefinitions` | complete `{keep,noChange,block}` object with non-empty strings |\n| `artifacts` | array of exact paths relative to `workdir` |\n| `enabled` | boolean |\n\nSchedule examples:\n\n```bash\n<pievo-cli> edit <loop-id> --json '{\"schedule\":{\"mode\":\"cron\",\"cron\":\"0 9 * * 1-5\",\"timezone\":\"Europe/London\",\"overlap\":\"queue-one\"}}'\n<pievo-cli> edit <loop-id> --json '{\"schedule\":{\"mode\":\"continuous\",\"delayMinutes\":15}}'\n```\n\nOther examples:\n\n```bash\n<pievo-cli> edit <loop-id> --json '{\"prompt\":\"Run the verified release check and summarize only actionable findings.\"}'\n<pievo-cli> edit <loop-id> --json '{\"statusDefinitions\":{\"keep\":\"A verified action was completed.\",\"noChange\":\"The check completed with nothing actionable.\",\"block\":\"Owner input is required.\"}}'\n<pievo-cli> edit <loop-id> --json '{\"artifacts\":[\"release-check.md\"]}'\n<pievo-cli> edit <loop-id> --json '{\"model\":null,\"reasoningEffort\":null}'\n```\n\nImportant constraints:\n\n- Replacing `schedule` requires one complete exclusive shape. Cron requires `cron`,\n  `timezone`, and `overlap`; continuous requires only `delayMinutes`.\n- Replacing `statusDefinitions` requires all three definitions.\n- Artifact entries are exact stable file paths, not globs. They must be relative to\n  `workdir` and cannot traverse outside it.\n- The server validates every field and rejects unknown keys without mutating the loop.\n- Pievo appends the runtime report contract to `prompt`; do not duplicate it in the\n  stored prompt.\n\nRun once is intentionally a Web action: use **Run once** on the loop detail page.\nFor Pause, Start, Stop, Delete, and history, use `<pievo-cli> --help` and the\nrelevant command's `--help` instead of treating lifecycle operations as\nprompt-authoring fields.\n"
+};
+var PREFIX$1 = "/api/skill/references/";
+/**
+* GET /api/skill/references/:file — serve one pievo skill reference file. Path-safe:
+* only an exact, single-segment name from the static REFERENCES map resolves; anything
+* else (nested paths, traversal, unknown names) is 404. The server only reads bytes it
+* shipped — no filesystem access, no user input reaches disk (zero-exec invariant holds).
+*/
+var Route$2 = createFileRoute("/api/skill/references/$")({ server: { handlers: { GET: ({ request }) => {
+	const pathname = new URL(request.url).pathname;
+	if (!pathname.startsWith(PREFIX$1)) return Response.json({ error: "not found" }, { status: 404 });
+	const name = pathname.slice(22);
+	const body = Object.prototype.hasOwnProperty.call(REFERENCES, name) ? REFERENCES[name] : void 0;
+	if (body === void 0) return Response.json({ error: "not found" }, { status: 404 });
+	return new Response(body, { headers: {
+		"content-type": "text/markdown; charset=utf-8",
+		"cache-control": "no-cache"
+	} });
+} } } });
+/**
+* `decodeURIComponent` that returns null on malformed percent-encoding instead
+* of throwing a URIError (which would escape a route handler as a 500). Shared
+* by the routes that decode path segments; the policy is uniform — ANY
+* malformed segment is the caller's clean 400, never silently kept raw.
+*/
+function safeDecode(s) {
+	try {
+		return decodeURIComponent(s);
+	} catch {
+		return null;
+	}
+}
+/**
+* PUT /api/machine/blob/:hash — upload one content-addressed blob's raw bytes
+* (Bearer DEVICE token). The server recomputes sha256(body) and rejects a
+* mismatch before storing in the byte store. The hash is read from the URL (the daemon PUTs
+* exactly the hashes the sync handshake returned in needHashes).
+*
+* This byte-ingress route is deliberately NOT rate limited: it requires a valid
+* registered device token (unknown ⇒ 401, not an unauthenticated surface) and is
+* already bounded by the sync hash-handshake (the server only accepts hashes it
+* asked THIS machine for) plus the per-file 10MB byte cap. A
+* large first sync bursts many concurrent PUTs on one token, so any limiter would
+* only throttle legitimate uploads without adding real protection.
+*/
+var Route$1 = createFileRoute("/api/machine/blob/$hash")({ server: { handlers: { PUT: async ({ request }) => {
+	const auth = request.headers.get("authorization") ?? "";
+	const token = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+	if (!token) return Response.json({ error: "missing device token" }, { status: 401 });
+	const hash = safeDecode(new URL(request.url).pathname.split("/").pop() ?? "");
+	if (hash === null) return Response.json({ error: "bad hash" }, { status: 400 });
+	const { BLOB_CAP } = await import("./artifacts-BhQvaGjF.mjs");
+	const body = await readByteBody(request, BLOB_CAP);
+	if (body.kind === "too-large") return Response.json({ error: "blob exceeds size cap" }, { status: 413 });
+	if (body.kind === "invalid") return Response.json({ error: "could not read blob body" }, { status: 400 });
+	const buf = Buffer.from(body.bytes.buffer, body.bytes.byteOffset, body.bytes.byteLength);
+	const { getArtifactSync } = await import("./boot-COHf8Gv3.mjs");
+	const r = await (await getArtifactSync()).putBlob(token, hash, buf);
+	return Response.json(r.body, { status: r.status });
+} } } });
+/**
+* GET /api/artifact/:loopId/:path - stream one of a loop's live-synced artifact
+* blobs. Two dispositions:
+*  - default: `attachment` (the download affordance for binary/oversize files;
+*    text is shown inline via getArtifact).
+*  - `?view=inline`: for a KNOWN image type only (the `imageMime` allowlist),
+*    served `inline` with the real image content-type so an <img> can render it.
+*    Hardened against a direct navigation turning the byte stream into a scripted
+*    document on the app origin: `X-Content-Type-Options: nosniff` pins the type
+*    and `Content-Security-Policy: sandbox` loads it in an opaque origin with no
+*    scripts - so an inline SVG can't run script against the session even if the
+*    URL is opened directly. Non-image inline requests fall back to attachment.
+*
+* Authed via the WEB SESSION (not a machine token) and scoped to the loop's team,
+* mirroring the server fns' `ownedLoop` gate. Path-safe: the relative path is
+* normalized + traversal-rejected before it ever reaches a blob, and blob keys
+* are content hashes, never the user path. Reads stream from the BlobStore
+* (local by default, R2 when configured); the route never writes.
+*/
+var PREFIX = "/api/artifact/";
+var Route = createFileRoute("/api/artifact/$loopId/$")({ server: { handlers: { GET: async ({ request }) => {
+	const pathname = new URL(request.url).pathname;
+	if (!pathname.startsWith(PREFIX)) return Response.json({ error: "not found" }, { status: 404 });
+	const after = pathname.slice(14);
+	const slash = after.indexOf("/");
+	if (slash < 0) return Response.json({ error: "missing path" }, { status: 400 });
+	const loopId = safeDecode(after.slice(0, slash));
+	if (loopId === null) return Response.json({ error: "bad loop id" }, { status: 400 });
+	const segments = after.slice(slash + 1).split("/").map((s) => safeDecode(s));
+	if (segments.some((s) => s === null)) return Response.json({ error: "bad path" }, { status: 400 });
+	const relPath = segments.join("/");
+	const loop = await (await import("./store-CirPHuib.mjs")).getLoop(loopId);
+	if (!loop) return Response.json({ error: "not found" }, { status: 404 });
+	const { requestScope, canAccessLoop } = await import("./auth-CPCDf6Wr.mjs");
+	if (!await canAccessLoop(loop.teamId, await requestScope())) return Response.json({ error: "not found" }, { status: 404 });
+	const { readLoopArtifactBytes } = await import("./artifactFiles-CV3OXxRD.mjs");
+	const r = await readLoopArtifactBytes(loopId, relPath);
+	if (r.status !== 200 || !r.bytes) return Response.json({ error: "not found" }, { status: r.status });
+	const filename = (r.filename || "file").replace(/["\\\r\n]/g, "_");
+	const mime = new URL(request.url).searchParams.get("view") === "inline" ? imageMime(relPath) : null;
+	if (mime) return new Response(new Uint8Array(r.bytes), {
+		status: 200,
+		headers: {
+			"content-type": mime,
+			"content-length": String(r.bytes.length),
+			"content-disposition": `inline; filename="${filename}"`,
+			"x-content-type-options": "nosniff",
+			"content-security-policy": "sandbox",
+			"cache-control": "private, no-store"
+		}
+	});
+	return new Response(new Uint8Array(r.bytes), {
+		status: 200,
+		headers: {
+			"content-type": r.binary ? "application/octet-stream" : "text/plain; charset=utf-8",
+			"content-length": String(r.bytes.length),
+			"content-disposition": `attachment; filename="${filename}"`,
+			"cache-control": "private, no-store"
+		}
+	});
+} } } });
+var IndexRoute = Route$17.update({
+	id: "/",
+	path: "/",
+	getParentRoute: () => Route$13
+});
+var TTeamIdRoute = Route$18.update({
+	id: "/t/$teamId",
+	path: "/t/$teamId",
+	getParentRoute: () => Route$13
+});
+var MachineReportRoute = Route$12.update({
+	id: "/machine/report",
+	path: "/machine/report",
+	getParentRoute: () => Route$13
+});
+var LoopsLoopIdRoute = Route$15.update({
+	id: "/loops/$loopId",
+	path: "/loops/$loopId",
+	getParentRoute: () => Route$13
+});
+var InviteTokenRoute = Route$14.update({
+	id: "/invite/$token",
+	path: "/invite/$token",
+	getParentRoute: () => Route$13
+});
+var ApiReadyRoute = Route$11.update({
+	id: "/api/ready",
+	path: "/api/ready",
+	getParentRoute: () => Route$13
+});
+var ApiHealthRoute = Route$10.update({
+	id: "/api/health",
+	path: "/api/health",
+	getParentRoute: () => Route$13
+});
+var ApiBootstrapRoute = Route$9.update({
+	id: "/api/bootstrap",
+	path: "/api/bootstrap",
+	getParentRoute: () => Route$13
+});
+var ApiMachineSyncRoute = Route$8.update({
+	id: "/api/machine/sync",
+	path: "/api/machine/sync",
+	getParentRoute: () => Route$13
+});
+var ApiMachineStatusRoute = Route$7.update({
+	id: "/api/machine/status",
+	path: "/api/machine/status",
+	getParentRoute: () => Route$13
+});
+var ApiMachinePollRoute = Route$6.update({
+	id: "/api/machine/poll",
+	path: "/api/machine/poll",
+	getParentRoute: () => Route$13
+});
+var ApiMachineCliRoute = Route$5.update({
+	id: "/api/machine/cli",
+	path: "/api/machine/cli",
+	getParentRoute: () => Route$13
+});
+var ApiHealthDbRoute = Route$4.update({
+	id: "/db",
+	path: "/db",
+	getParentRoute: () => ApiHealthRoute
+});
+var ApiAuthSplatRoute = Route$3.update({
+	id: "/api/auth/$",
+	path: "/api/auth/$",
+	getParentRoute: () => Route$13
+});
+var LoopsLoopIdRunsRunIdRoute = Route$16.update({
+	id: "/loops/$loopId_/runs/$runId",
+	path: "/loops/$loopId/runs/$runId",
+	getParentRoute: () => Route$13
+});
+var ApiSkillReferencesSplatRoute = Route$2.update({
+	id: "/api/skill/references/$",
+	path: "/api/skill/references/$",
+	getParentRoute: () => Route$13
+});
+var ApiMachineBlobHashRoute = Route$1.update({
+	id: "/api/machine/blob/$hash",
+	path: "/api/machine/blob/$hash",
+	getParentRoute: () => Route$13
+});
+var ApiArtifactLoopIdSplatRoute = Route.update({
+	id: "/api/artifact/$loopId/$",
+	path: "/api/artifact/$loopId/$",
+	getParentRoute: () => Route$13
+});
+var ApiHealthRouteChildren = { ApiHealthDbRoute };
+var rootRouteChildren = {
+	IndexRoute,
+	ApiBootstrapRoute,
+	ApiHealthRoute: ApiHealthRoute._addFileChildren(ApiHealthRouteChildren),
+	ApiReadyRoute,
+	InviteTokenRoute,
+	LoopsLoopIdRoute,
+	MachineReportRoute,
+	TTeamIdRoute,
+	ApiAuthSplatRoute,
+	ApiMachineCliRoute,
+	ApiMachinePollRoute,
+	ApiMachineStatusRoute,
+	ApiMachineSyncRoute,
+	ApiArtifactLoopIdSplatRoute,
+	ApiMachineBlobHashRoute,
+	ApiSkillReferencesSplatRoute,
+	LoopsLoopIdRunsRunIdRoute
+};
+var routeTree = Route$13._addFileChildren(rootRouteChildren)._addFileTypes();
+function getRouter() {
+	return createRouter({
+		routeTree,
+		scrollRestoration: true,
+		defaultPreload: "intent"
+	});
+}
+//#endregion
+export { getRouter };

package/.output/server/_ssr/{routes-DebVUmCS.mjs → routes-CRHc9cLG.mjs}

@@ -1,10 +1,9 @@
 import { c as createFileRoute, p as redirect, s as lazyRouteComponent } from "../_libs/@tanstack/react-router+[...].mjs";
-import { c as getAuthState, d as getDefaultTeam, g as listTemplates } from "./loopApi-8_KgBapr.mjs";
-import { a as authClient } from "./LoopPlaybook-uq_sFfgU.mjs";
-import { n as fetchLiveData } from "./DashboardView-0yoKh8Em.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/routes-DebVUmCS.js
-var $$splitErrorComponentImporter = () => import("./routes-Bx0bRxt9.mjs");
-var $$splitComponentImporter = () => import("./routes-dQCBLTxY.mjs");
+import { d as getAuthState, i as authClient, p as getDefaultTeam } from "./SocialLinks-BTjsnVOm.mjs";
+import { n as fetchLiveData } from "./DashboardView-D_hKsCsv.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/routes-CRHc9cLG.js
+var $$splitErrorComponentImporter = () => import("./routes-DNCZrs8z.mjs");
+var $$splitComponentImporter = () => import("./routes-ufPbrGHs.mjs");
 /**
 * The home route. Under the auth gate it is now a THIN redirect to the explicit
 * team URL (`/t/<lastUsed|personal>`) so the dashboard's team lives in the path
@@ -30,10 +29,7 @@ var Route = createFileRoute("/")({
 		return {
 			mode: "dashboard",
 			auth,
-			initial: {
-				...await fetchLiveData(),
-				templates: await listTemplates()
-			}
+			initial: await fetchLiveData()
 		};
 	},
 	component: lazyRouteComponent($$splitComponentImporter, "component"),