@kky42/pievo-server 2.0.4 → 2.1.0

package/.output/server/_ssr/{artifactFiles-Dl1EaUtJ.mjs → artifactFiles-Cp1IBHne.mjs}

@@ -1,6 +1,6 @@
-import { H as getArtifactFile, Kt as safeRelPath, U as getArtifactSync, yt as listArtifactsWithMeta } from "./boot-BZ-YyUiD.mjs";
-import { t as toArtifactSummary } from "./adapters-N4-yQ1vK.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/artifactFiles-Dl1EaUtJ.js
+import { H as getArtifactFile, Kt as safeRelPath, U as getArtifactSync, yt as listArtifactsWithMeta } from "./boot-DPoPmSLh.mjs";
+import { t as toArtifactSummary } from "./adapters-Bwuh6uek.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/artifactFiles-Cp1IBHne.js
 /**
 * Server-side reads over a loop's live-synced artifacts (Phase 2). Pure helpers
 * (no request/session context) so they're shared by the lazy server fns

package/.output/server/_ssr/artifacts-9G_Ai7vO.mjs

@@ -0,0 +1,2 @@
+import { f as SYNC_BODY_CAP, i as BLOB_CAP } from "./boot-DPoPmSLh.mjs";
+export { BLOB_CAP, SYNC_BODY_CAP };

package/.output/server/_ssr/{auth-CbAfO4Ne.mjs → auth-uQ19WsD1.mjs}

@@ -1,6 +1,6 @@
 import { A as sql, C as or, S as notInArray, _ as isNull$1, b as lte, c as asc, d as eq, f as gt, g as isNotNull, h as inArray, l as desc, m as ilike, o as count, p as gte, u as and, v as like, x as ne, y as lt } from "../_libs/drizzle-orm+postgres.mjs";
-import { At as loginGateEnabled, Ft as normalizePathname, G as getBooleanEnvVar, Gt as resolveBaseURL, J as getEnvVar, M as defu, R as ensureTeam, T as createDefu, W as getBaseURL, X as getHost, Zt as teamIdForUser, _t as isTest, a as BetterAuthError, an as wildcardMatch, ct as isDynamicBaseURLConfig, dt as isProduction, et as getOrigin, ft as isRequestLike, gt as isTeamMember, h as betterFetch, j as db, l as ENV, n as APIError$1, o as BetterCallError, p as ValidationError$1, r as BASE_ERROR_CODES, st as isDevelopment, t as APIError, tt as getProtocol, v as capitalizeFirstLetter, vt as kAPIErrorHeaderSymbol, z as env } from "./boot-BZ-YyUiD.mjs";
-import { C as withSpan, S as shouldPublishLog, _ as logger, a as __getBetterAuthGlobal, b as runWithTransaction, c as createRandomStringGenerator, d as getAuthTables, f as getBetterAuthVersion, g as initGetModelName, h as initGetFieldName, l as generateId$2, m as import_src, n as ATTR_HOOK_TYPE, o as createAdapterFactory, p as getCurrentAdapter, r as ATTR_OPERATION_ID, s as createLogger, t as ATTR_CONTEXT, u as getAsyncLocalStorage, v as queueAfterTransactionHook, x as safeJSONParse, y as runWithAdapter } from "./factory-DNeo3vVt.mjs";
+import { At as loginGateEnabled, Ft as normalizePathname, G as getBooleanEnvVar, Gt as resolveBaseURL, J as getEnvVar, M as defu, R as ensureTeam, T as createDefu, W as getBaseURL, X as getHost, Zt as teamIdForUser, _t as isTest, a as BetterAuthError, an as wildcardMatch, ct as isDynamicBaseURLConfig, dt as isProduction, et as getOrigin, ft as isRequestLike, gt as isTeamMember, h as betterFetch, j as db, l as ENV, n as APIError$1, o as BetterCallError, p as ValidationError$1, r as BASE_ERROR_CODES, st as isDevelopment, t as APIError, tt as getProtocol, v as capitalizeFirstLetter, vt as kAPIErrorHeaderSymbol, z as env } from "./boot-DPoPmSLh.mjs";
+import { C as withSpan, S as shouldPublishLog, _ as logger, a as __getBetterAuthGlobal, b as runWithTransaction, c as createRandomStringGenerator, d as getAuthTables, f as getBetterAuthVersion, g as initGetModelName, h as initGetFieldName, l as generateId$2, m as import_src, n as ATTR_HOOK_TYPE, o as createAdapterFactory, p as getCurrentAdapter, r as ATTR_OPERATION_ID, s as createLogger, t as ATTR_CONTEXT, u as getAsyncLocalStorage, v as queueAfterTransactionHook, x as safeJSONParse, y as runWithAdapter } from "./factory-BtqxMS8a.mjs";
 import { randomBytes, scrypt } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
@@ -1700,7 +1700,7 @@ var JOIN_TYPE_SQL = freeze({
 	Using: "using"
 });
 //#endregion
-//#region node_modules/.nitro/vite/services/ssr/assets/auth-CbAfO4Ne.js
+//#region node_modules/.nitro/vite/services/ssr/assets/auth-uQ19WsD1.js
 /**
 * @internal
 */
@@ -15993,7 +15993,7 @@ var createKyselyAdapter = async (config) => {
 	if ("getConnection" in db) dialect = new MysqlDialect(db);
 	if ("connect" in db) dialect = new PostgresDialect({ pool: db });
 	if ("fileControl" in db) {
-		const { BunSqliteDialect } = await import("./bun-sqlite-dialect-BW9W1_Ps-B67XLJZt.mjs");
+		const { BunSqliteDialect } = await import("./bun-sqlite-dialect-BW9W1_Ps-CqcLCApi.mjs");
 		dialect = new BunSqliteDialect({ database: db });
 	}
 	if ("createSession" in db) {
@@ -16009,12 +16009,12 @@ var createKyselyAdapter = async (config) => {
 			if (error !== null && typeof error === "object" && "code" in error && error.code !== "ERR_UNKNOWN_BUILTIN_MODULE") throw error;
 		}
 		if (DatabaseSync && db instanceof DatabaseSync) {
-			const { NodeSqliteDialect } = await import("./node-sqlite-dialect-BS2OAFJh.mjs");
+			const { NodeSqliteDialect } = await import("./node-sqlite-dialect-ZOyD6D7F.mjs");
 			dialect = new NodeSqliteDialect({ database: db });
 		}
 	}
 	if ("batch" in db && "exec" in db && "prepare" in db) {
-		const { D1SqliteDialect } = await import("./d1-sqlite-dialect-BLC8LXE6-nff_yHzH.mjs");
+		const { D1SqliteDialect } = await import("./d1-sqlite-dialect-BLC8LXE6-AuWb61y8.mjs");
 		dialect = new D1SqliteDialect({ database: db });
 	}
 	return {
@@ -36526,7 +36526,7 @@ async function getBaseAdapter(options, handleDirectDatabase) {
 			acc[key] = [];
 			return acc;
 		}, {});
-		const { memoryAdapter } = await import("./dist-BGjVt6NE.mjs");
+		const { memoryAdapter } = await import("./dist-CtYTvPCD.mjs");
 		adapter = memoryAdapter(memoryDB)(options);
 	} else if (typeof options.database === "function") adapter = options.database(options);
 	else adapter = await handleDirectDatabase(options);
@@ -36540,10 +36540,10 @@ async function getBaseAdapter(options, handleDirectDatabase) {
 }
 async function getAdapter(options) {
 	return getBaseAdapter(options, async (opts) => {
-		const { createKyselyAdapter } = await import("./kysely-adapter-C1ww7PKr.mjs");
+		const { createKyselyAdapter } = await import("./kysely-adapter-bSpTlW7Z.mjs");
 		const { kysely, databaseType, transaction } = await createKyselyAdapter(opts);
 		if (!kysely) throw new BetterAuthError("Failed to initialize database adapter");
-		const { kyselyAdapter } = await import("./kysely-adapter-C1ww7PKr.mjs");
+		const { kyselyAdapter } = await import("./kysely-adapter-bSpTlW7Z.mjs");
 		return kyselyAdapter(kysely, {
 			type: databaseType || "sqlite",
 			debugLogs: opts.database && "debugLogs" in opts.database ? opts.database.debugLogs : false,

package/.output/server/_ssr/{boot-BZ-YyUiD.mjs → boot-DPoPmSLh.mjs}

@@ -13,7 +13,7 @@ import os from "node:os";
 import fs$1 from "node:fs/promises";
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
-//#region node_modules/.nitro/vite/services/ssr/assets/boot-BZ-YyUiD.js
+//#region node_modules/.nitro/vite/services/ssr/assets/boot-DPoPmSLh.js
 var import_pino = /* @__PURE__ */ __toESM(require_pino());
 var import_pino_pretty = /* @__PURE__ */ __toESM(require_pino_pretty());
 function defineErrorCodes(codes) {
@@ -1663,7 +1663,7 @@ var runs = pgTable("runs", {
 	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_role_pending_idx").on(t.loopId, t.role).where(sql`${t.phase} = 'pending'`),
-	uniqueIndex("one_running_run_per_machine").on(t.machineId).where(sql`${t.phase} = 'running'`)
+	uniqueIndex("one_running_run_per_loop").on(t.loopId).where(sql`${t.phase} = 'running'`)
 ]);
 var runLeases = pgTable("run_leases", {
 	/** sha256 hex of the full wire token (`rk_…`, or a pre-Batch-6 bare UUID). */
@@ -2466,8 +2466,11 @@ async function terminalLifecycleTx(tx, currentLoop, run, terminalAt, loopPatch =
 async function getRun(id) {
 	return (await db.select().from(runs).where(eq(runs.id, id)))[0];
 }
-async function runningRunForMachine(machineId) {
-	return (await db.select().from(runs).where(and(eq(runs.machineId, machineId), eq(runs.phase, "running"))).limit(1))[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];
@@ -2892,24 +2895,29 @@ async function initializeCronCadence(at = nowIso$1()) {
 	}
 	return initialized;
 }
-/** Claim and lease mint are one atomic loop-lock transaction. A cancel can win
-* before this commit or delete the inserted lease afterward, but can never race
-* through the historical running-without-a-lease gap. */
-async function claimReadyRunForMachine(machineId, at = nowIso$1()) {
-	const runToken = `rk_${randomBytes(16).toString("hex")}`;
-	const tokenHash = createHash("sha256").update(runToken).digest("hex");
+/** 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;
-		if ((await tx.select({ id: runs.id }).from(runs).where(and(eq(runs.machineId, machineId), eq(runs.phase, "running"))).limit(1))[0]) return void 0;
-		if ((await tx.select({ tokenHash: runLeases.tokenHash }).from(runLeases).where(and(eq(runLeases.machineId, machineId), inArray(runLeases.state, ["active", "terminal-grace"]), or(eq(runLeases.state, "active"), gt(runLeases.expiresAt, at)))).limit(1))[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))).orderBy(sql`case ${runs.role} when 'steer' then 0 when 'evolve' then 1 else 2 end`, asc(runs.createdAt)).limit(1))[0];
+		}).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(sql`case ${runs.role} when 'steer' then 0 when 'evolve' then 1 else 2 end`, 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",
@@ -2926,6 +2934,8 @@ async function claimReadyRunForMachine(machineId, at = nowIso$1()) {
 			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");
 		const structural = run.role === "evolve" || run.role === "steer";
 		await tx.insert(runLeases).values({
 			tokenHash,
@@ -2955,15 +2965,6 @@ async function listRuns(loopId, limit = 30) {
 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();
 }
-/** Latest terminal of any role. For a pending row this is the earliest reliable
-* evidence that a same-loop blocker ended and the daemon could claim again. */
-async function lastTerminalRunAt(loopId) {
-	return (await db.select({ ts: runs.ts }).from(runs).where(and(eq(runs.loopId, loopId), inArray(runs.phase, [
-		"done",
-		"error",
-		"canceled"
-	]))).orderBy(desc(runs.ts)).limit(1))[0]?.ts ?? null;
-}
 /** Newest scheduled (exec) run for a loop — the last-result anchor that a later
 *  evolve/steer must never mask. Null ⇒ no exec run yet. */
 async function lastExecRun(loopId) {
@@ -2981,14 +2982,17 @@ async function countRuns(loopId) {
 async function markPendingRunDeferred(runId, expected, at) {
 	if (expected.requestedBy !== "system") return void 0;
 	return db.transaction(async (tx) => {
-		const observed = (await tx.select({ loopId: runs.loopId }).from(runs).where(eq(runs.id, runId)).limit(1))[0];
+		const observed = (await tx.select({
+			loopId: runs.loopId,
+			machineId: runs.machineId
+		}).from(runs).where(eq(runs.id, runId)).limit(1))[0];
 		if (!observed) return void 0;
+		const machine = (await tx.select({ online: machines.online }).from(machines).where(eq(machines.id, observed.machineId)).limit(1).for("update"))[0];
+		if (!machine || machine.online) 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 current = (await tx.select().from(runs).where(and(eq(runs.id, runId), eq(runs.loopId, loop.id), eq(runs.phase, "pending"), eq(runs.role, "exec"), eq(runs.requestedBy, "system"), eq(runs.updatedAt, expected.updatedAt))).limit(1).for("update"))[0];
 		if (!current || current.deferredAt) return void 0;
-		const machine = (await tx.select({ online: machines.online }).from(machines).where(eq(machines.id, current.machineId)).limit(1).for("update"))[0];
-		if (!machine || machine.online) return void 0;
 		return (await tx.update(runs).set({
 			deferredAt: at,
 			updatedAt: at
@@ -3005,41 +3009,6 @@ async function hasRunningRun(loopId) {
 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];
 }
-/** Recheck a never-claimed pending row from its sweep snapshot under the loop
-* lock. Coalescing/promotion refreshes updatedAt, so stale sweep work loses the
-* CAS before it can turn renewed owner intent into an error. */
-async function reclaimUnclaimedPendingRun(runId, expected, at, timeoutMs, reason, 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 current = (await tx.select().from(runs).where(and(eq(runs.id, runId), eq(runs.loopId, loop.id), eq(runs.phase, "pending"), eq(runs.requestedBy, expected.requestedBy), eq(runs.updatedAt, expected.updatedAt))).limit(1).for("update"))[0];
-		if (!current) return void 0;
-		if (!(await tx.select({ online: machines.online }).from(machines).where(eq(machines.id, current.machineId)).limit(1))[0]?.online) return void 0;
-		const blocker = (await tx.select({ ts: runs.ts }).from(runs).where(and(eq(runs.loopId, loop.id), inArray(runs.phase, [
-			"done",
-			"error",
-			"canceled"
-		]))).orderBy(desc(runs.ts)).limit(1))[0];
-		const running = (await tx.select({ id: runs.id }).from(runs).where(and(eq(runs.loopId, loop.id), eq(runs.phase, "running"))).limit(1))[0];
-		const eligibleAt = Math.max(Date.parse(current.updatedAt), blocker ? Date.parse(blocker.ts) || 0 : 0);
-		if (running || Date.parse(at) - eligibleAt <= timeoutMs) return void 0;
-		const runIndex = await ensureRunIndexTx(tx, current);
-		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, "pending"), eq(runs.requestedBy, expected.requestedBy), eq(runs.updatedAt, expected.updatedAt))).returning())[0];
-		if (!reclaimed) return void 0;
-		return {
-			run: reclaimed,
-			...await terminalLifecycleTx(tx, loop, reclaimed, at, {}, false, failureAutopauseStreak)
-		};
-	});
-}
 /** 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) {
@@ -5367,15 +5336,7 @@ async function schemaKeysInUse(loopId) {
 	}
 	return [...keys];
 }
-/**
-* Lowest daemon package version this server may safely dispatch work to.
-*
-* Keep this as a coarse package-version gate: if a future server changes the
-* prompt/CLI/report protocol incompatibly, bump this constant to the matching
-* daemon release. Unknown versions are treated as incompatible because only
-* daemons that report a version can be known-safe for breaking protocol changes.
-*/
-var MIN_DAEMON_VERSION = "2.0.4";
+var MIN_DAEMON_VERSION = "2.1.0";
 function daemonNeedsUpdate(current, required = MIN_DAEMON_VERSION) {
 	if (!current) return true;
 	if (current === required) return false;
@@ -5453,9 +5414,6 @@ var SESSION_ID_CAP = 200;
 /** A loop's goal (setpoint) is a one-line, checkable statement — clip generously
 *  but keep it a single line's worth (not a document). Shared by createLoop/editLoop. */
 var GOAL_CAP = 2e3;
-/** The 2MB machine-body cap is the primary bound; this generous secondary cap
-* covers machines running thousands of independent loops without query abuse. */
-var MAX_ACTIVE_RUN_IDS = 5e3;
 /** Keep heartbeat throttling safely inside custom short timeout windows. */
 function heartbeatRefreshMs(runTimeoutMs) {
 	if (!Number.isFinite(runTimeoutMs) || runTimeoutMs <= 0) return 1;
@@ -5700,21 +5658,17 @@ var MachineGateway = class {
 	* A RUNNING run that went silent is reclaimed as timed out; a PENDING run on
 	* an OFFLINE machine is NOT failed — it is held as a deferred catch-up (the
 	* pending row is the durable inbox; the daemon's next poll claims it, and later
-	* same-role fires coalesce into it), bounded by DEFERRED_MAX_MS.
-	* Only a pending run a healthy ONLINE machine never claims becomes an error.
+	* same-role fires coalesce into it), bounded by DEFERRED_MAX_MS while offline.
+	* Online pending rows never synthesize an execution error.
 	*/
 	async sweep() {
 		const now = Date.now();
 		for (const m of await listMachines()) if (m.online && (!m.lastSeen || now - Date.parse(m.lastSeen) > 3e4)) await updateMachine(m.id, { online: false });
 		for (const run of await openRuns()) {
-			const blockerAt = run.phase === "pending" ? await lastTerminalRunAt(run.loopId) : null;
-			const age = now - Math.max(Date.parse(run.updatedAt), blockerAt ? Date.parse(blockerAt) || 0 : 0);
 			const pendingLifetime = now - Date.parse(run.createdAt);
 			if (run.phase === "pending") {
 				const machine = await getMachine(run.machineId);
-				if (machine?.online) {
-					if (!await hasRunningRun(run.loopId) && age > RUN_TIMEOUT_MS) await this.reclaimRun(run, "run never claimed");
-				} else if (run.requestedBy === "system" && pendingLifetime > DEFERRED_MAX_MS) await expirePendingRun(run.id, {
+				if (machine?.online) {} else if (run.requestedBy === "system" && pendingLifetime > DEFERRED_MAX_MS) await expirePendingRun(run.id, {
 					requestedBy: run.requestedBy,
 					updatedAt: run.updatedAt
 				}, nowIso(), DEFERRED_MAX_MS, "skipped - the machine stayed offline past the catch-up window");
@@ -5745,15 +5699,12 @@ var MachineGateway = class {
 	*  (`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: agent-api mutations are refused while terminal-grace, and the
-	*  reconciliation retires the lease single-shot. A pending run (no lease minted
-	*  yet) is unaffected — the terminalize is a no-op there. */
+	*  reconciliation retires the lease single-shot. Pending rows are durable inbox
+	*  entries and are never reclaimed by this path. */
 	async reclaimRun(run, reason) {
-		if (run.phase !== "pending" && run.phase !== "running") return;
+		if (run.phase !== "running") return;
 		const at = nowIso();
-		const reclaimed = run.phase === "pending" ? await reclaimUnclaimedPendingRun(run.id, {
-			requestedBy: run.requestedBy,
-			updatedAt: run.updatedAt
-		}, at, RUN_TIMEOUT_MS, reason, AUTOPAUSE_STREAK) : await reclaimRun(run.id, "running", reason, at, TERMINAL_GRACE_MS);
+		const reclaimed = await reclaimRun(run.id, "running", reason, at, TERMINAL_GRACE_MS);
 		if (!reclaimed) return;
 		await this.notifyRunFailure(run.loopId, run.role, reason, reclaimed);
 		if (reclaimed.loop.enabled) this.scheduler.addLoop(reclaimed.loop);
@@ -5788,7 +5739,7 @@ var MachineGateway = class {
 			this.maintenanceRunning = false;
 		}
 	}
-	async poll(deviceToken, info, activeRunIds, watchDigest, claimWork = true) {
+	async pollCore(deviceToken, info, currentRunIds, watchDigest, claimWork = true) {
 		if (!isDeviceTokenShape(deviceToken)) return {
 			status: 401,
 			body: { error: "invalid device token" }
@@ -5835,25 +5786,22 @@ var MachineGateway = class {
 			};
 			if (Object.keys(patch).length) await updateMachine(machineId, patch);
 		}
-		if (Array.isArray(activeRunIds)) {
+		if (Array.isArray(currentRunIds)) {
 			const ids = /* @__PURE__ */ new Set();
-			for (const value of activeRunIds) {
-				if (typeof value === "string") ids.add(value);
-				if (ids.size >= MAX_ACTIVE_RUN_IDS) break;
-			}
+			for (const value of currentRunIds) if (typeof value === "string") ids.add(value);
 			if (ids.size) {
 				const now = Date.now();
 				await refreshRunHeartbeats(machineId, [...ids], new Date(now).toISOString(), new Date(now - HEARTBEAT_STAMP_REFRESH_MS).toISOString());
 			}
 		}
-		const deliveries = [];
+		let delivery = null;
 		if (claimWork) {
 			await this.scheduler.advanceDueSchedules(machineId);
-			const claimed = await claimReadyRunForMachine(machineId);
-			if (claimed) deliveries.push(await buildDelivery(claimed.loop, claimed.run, claimed.runToken, machine.roots ?? []));
+			const claimed = await claimReadyRunForMachine(machineId, void 0, currentRunIds ?? []);
+			if (claimed) delivery = await buildDelivery(claimed.loop, claimed.run, claimed.runToken, machine.roots ?? []);
 		}
 		let cached = this.watchCache.get(machineId);
-		if (!cached || deliveries.length || Date.now() - cached.at > WATCH_CACHE_TTL_MS) {
+		if (!cached || delivery || Date.now() - cached.at > WATCH_CACHE_TTL_MS) {
 			const watch = (await loopsForMachine(machineId)).map((l) => ({
 				loopId: l.id,
 				workdir: l.workdir ?? null,
@@ -5866,22 +5814,22 @@ var MachineGateway = class {
 			};
 			this.watchCache.set(machineId, cached);
 		}
-		if (deliveries.length) log$2.info({
+		if (delivery) log$2.info({
 			machineId,
-			exec: deliveries.length
+			runId: delivery.runId
 		}, "poll: delivered");
 		return {
 			status: 200,
 			body: {
-				deliveries,
+				delivery,
 				watchDigest: cached.digest,
 				...watchDigest === cached.digest ? {} : { watch: cached.watch }
 			}
 		};
 	}
-	/** Breaking protocol-v2 single-flight poll seam. */
-	async pollV2(deviceToken, request) {
-		if (request.protocolVersion !== 2) {
+	/** Protocol-v3 poll: plural local state, one new delivery per poll. */
+	async pollV3(deviceToken, request) {
+		if (request.protocolVersion !== 3) {
 			if (isDeviceTokenShape(deviceToken)) {
 				const machineId = machineIdFromToken(deviceToken);
 				if ((await getMachine(machineId))?.tokenHash === sha256(deviceToken)) await updateMachine(machineId, { daemonProtocol: typeof request.protocolVersion === "number" && Number.isInteger(request.protocolVersion) ? request.protocolVersion : null });
@@ -5891,89 +5839,58 @@ var MachineGateway = class {
 				body: {
 					error: "daemon upgrade required; run `npm install -g @kky42/pievo@latest`, then `pievo daemon restart`",
 					code: "UPGRADE_REQUIRED",
-					requiredProtocol: 2
+					requiredProtocol: 3
 				}
 			};
 		}
-		const current = request.currentRun;
-		if (current && (typeof current.runId !== "string" || !["executing", "reporting"].includes(current.stage))) return {
+		const validCurrent = (value) => typeof value?.runId === "string" && ["executing", "reporting"].includes(value.stage);
+		if (!Array.isArray(request.currentRuns) || request.currentRuns.some((run) => !validCurrent(run))) return {
 			status: 400,
 			body: {
-				error: "invalid currentRun",
+				error: "invalid currentRuns",
 				code: "VALIDATION_ERROR"
 			}
 		};
+		const currentIds = [...new Set(request.currentRuns.map((run) => run.runId))];
 		const machineId = isDeviceTokenShape(deviceToken) ? machineIdFromToken(deviceToken) : "";
 		const priorMachine = machineId ? await getMachine(machineId) : void 0;
 		const reportedVersion = typeof request.info?.version === "string" ? clipText(request.info.version, 64) : priorMachine?.daemonVersion;
 		const needsUpdate = daemonNeedsUpdate(reportedVersion);
-		const base = await this.poll(deviceToken, request.info, current ? [current.runId] : void 0, request.watchDigest, !current && !needsUpdate);
+		const base = await this.pollCore(deviceToken, request.info, currentIds, request.watchDigest, !needsUpdate);
 		if (base.status !== 200) return base;
-		if ((await getMachine(machineId))?.daemonProtocol !== 2) await updateMachine(machineId, { daemonProtocol: 2 });
-		const running = await runningRunForMachine(machineId);
+		if ((await getMachine(machineId))?.daemonProtocol !== 3) await updateMachine(machineId, { daemonProtocol: 3 });
+		const running = await runningRunsForMachine(machineId);
+		const currentSet = new Set(currentIds);
 		const body = base.body;
-		const cancelRunId = current && running?.id === current.runId && running.cancelRequestedAt ? current.runId : void 0;
 		return {
 			status: 200,
 			body: {
-				delivery: current ? null : body.deliveries[0] ?? null,
+				delivery: body.delivery,
+				cancelRunIds: running.filter((run) => currentSet.has(run.id) && run.cancelRequestedAt).map((run) => run.id),
 				...needsUpdate ? { needsUpdate: {
 					current: reportedVersion ?? null,
 					required: MIN_DAEMON_VERSION,
 					command: daemonUpgradeCommand()
 				} } : {},
-				...cancelRunId ? { cancelRunId } : {},
-				...current && running && current.runId !== running.id ? { runConflict: {
-					daemonRunId: current.runId,
-					serverRunId: running.id
-				} } : {},
-				...!current && running && !body.deliveries.length ? { blockedRunId: running.id } : {},
 				watchDigest: body.watchDigest,
 				...body.watch ? { watch: body.watch } : {}
 			}
 		};
 	}
-	/** Protocol-v2 idle polls long-poll automatically; active/reporting polls never park. */
-	async pollV2Wait(deviceToken, request, waitMs = LONG_POLL_WAIT_MS) {
-		if (request.currentRun || request.protocolVersion !== 2) return this.pollV2(deviceToken, request);
+	/** Idle v3 polls long-poll; active/reporting polls return immediately. */
+	async pollV3Wait(deviceToken, request, waitMs = LONG_POLL_WAIT_MS) {
+		if (request.currentRuns?.length || request.protocolVersion !== 3) return this.pollV3(deviceToken, request);
 		const machineId = machineIdFromToken(deviceToken);
 		const waiter = this.armPollWaiter(machineId, Math.min(Math.max(waitMs, 0), LONG_POLL_WAIT_MS));
 		try {
-			const first = await this.pollV2(deviceToken, request);
+			const first = await this.pollV3(deviceToken, request);
 			if (first.status !== 200) return first;
-			const body = first.body;
-			if (body.delivery || body.blockedRunId) return first;
+			if (first.body.delivery) return first;
 			if (!await waiter.promise) {
 				await setMachineOnline(machineId, true);
 				return first;
 			}
-			return this.pollV2(deviceToken, request);
-		} finally {
-			waiter.cancel();
-		}
-	}
-	/**
-	* Legacy long-poll wrapper over `poll()`: when the daemon opted in (`wait:true`) and
-	* the immediate pass claimed nothing, park the request on the machine's waiter
-	* until the Dispatcher wakes it (a run went pending) or the bounded window
-	* elapses, then re-claim. Old daemons never send `wait` and keep the classic
-	* instant response. The waiter is armed BEFORE the first claim pass, so a run
-	* that goes pending while the pass is in flight can never slip past the park.
-	*/
-	async pollWait(deviceToken, info, activeRunIds, opts) {
-		if (!opts?.wait) return this.poll(deviceToken, info, activeRunIds, opts?.watchDigest);
-		const machineId = machineIdFromToken(deviceToken);
-		const waitMs = Math.min(Math.max(opts.waitMs ?? LONG_POLL_WAIT_MS, 0), LONG_POLL_WAIT_MS);
-		const waiter = this.armPollWaiter(machineId, waitMs);
-		try {
-			const first = await this.poll(deviceToken, info, activeRunIds, opts.watchDigest);
-			if (first.status !== 200) return first;
-			if (first.body.deliveries.length) return first;
-			if (!await waiter.promise) {
-				await setMachineOnline(machineId, true);
-				return first;
-			}
-			return await this.poll(deviceToken, void 0, void 0, opts.watchDigest);
+			return this.pollV3(deviceToken, request);
 		} finally {
 			waiter.cancel();
 		}
@@ -5997,7 +5914,11 @@ var MachineGateway = class {
 		};
 		const fresh = !!machine.lastSeen && Date.now() - Date.parse(machine.lastSeen) < 3e4;
 		const online = !!machine.online && fresh;
-		const running = await runningRunForMachine(machineId);
+		const currentRuns = (await runningRunsForMachine(machineId)).map((run) => ({
+			runId: run.id,
+			stage: "executing",
+			cancelPending: run.cancelRequestedAt != null
+		}));
 		return {
 			status: 200,
 			body: {
@@ -6005,14 +5926,7 @@ var MachineGateway = class {
 				name: machine.name || null,
 				lastSeen: machine.lastSeen ?? null,
 				daemonProtocol: machine.daemonProtocol ?? null,
-				...running ? {
-					...online ? { currentRun: {
-						runId: running.id,
-						stage: "executing",
-						cancelPending: running.cancelRequestedAt != null
-					} } : { blockedRunId: running.id },
-					...running.cancelRequestedAt ? { cancelPending: true } : {}
-				} : {}
+				currentRuns: online ? currentRuns : []
 			}
 		};
 	}
@@ -8630,7 +8544,7 @@ var CliGateway = class {
 	}
 	async requireStopProtocol(machineId, running) {
 		if (!running) return void 0;
-		if ((await getMachine(machineId))?.daemonProtocol === 2) return void 0;
+		if ((await getMachine(machineId))?.daemonProtocol === 3) return void 0;
 		return {
 			status: 426,
 			body: {
@@ -8645,8 +8559,7 @@ var CliGateway = class {
 			status: 404,
 			body: { error: "no such loop on this machine" }
 		};
-		const running = await runningRunForMachine(machineId);
-		const target = running?.loopId === loop.id ? running : void 0;
+		const target = await runningRunForLoop(loop.id);
 		const upgrade = await this.requireStopProtocol(machineId, target);
 		if (upgrade) return upgrade;
 		const result = await stopLoop(loop.id);
@@ -8700,8 +8613,7 @@ var CliGateway = class {
 				body: { text: forceDeleteWarning(reachability) }
 			};
 		}
-		const running = await runningRunForMachine(machineId);
-		const target = running?.loopId === loop.id ? running : void 0;
+		const target = await runningRunForLoop(loop.id);
 		const upgrade = await this.requireStopProtocol(machineId, target);
 		if (upgrade) return upgrade;
 		const result = await requestDeleteLoop(loop.id);

package/.output/server/_ssr/{boot-BigKgB8p.mjs → boot-Zz5AJgfy.mjs}

@@ -1,2 +1,2 @@
-import { U as getArtifactSync, Y as getGateway, q as getCliGateway } from "./boot-BZ-YyUiD.mjs";
+import { U as getArtifactSync, Y as getGateway, q as getCliGateway } from "./boot-DPoPmSLh.mjs";
 export { getArtifactSync, getCliGateway, getGateway };

package/.output/server/_ssr/{bun-sqlite-dialect-BW9W1_Ps-B67XLJZt.mjs → bun-sqlite-dialect-BW9W1_Ps-CqcLCApi.mjs}

@@ -1,6 +1,6 @@
-import { n as DefaultQueryCompiler, o as CompiledQuery, s as sql$1 } from "./auth-CbAfO4Ne.mjs";
+import { n as DefaultQueryCompiler, o as CompiledQuery, s as sql$1 } from "./auth-uQ19WsD1.mjs";
 import { n as DEFAULT_MIGRATION_TABLE, t as DEFAULT_MIGRATION_LOCK_TABLE } from "./kysely-migration-tables-JkVUjPF_-bPAX9LR_.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/bun-sqlite-dialect-BW9W1_Ps-B67XLJZt.js
+//#region node_modules/.nitro/vite/services/ssr/assets/bun-sqlite-dialect-BW9W1_Ps-CqcLCApi.js
 var BunSqliteAdapter = class {
 	get supportsCreateIfNotExists() {
 		return true;

package/.output/server/_ssr/{d1-sqlite-dialect-BLC8LXE6-nff_yHzH.mjs → d1-sqlite-dialect-BLC8LXE6-AuWb61y8.mjs}

@@ -1,6 +1,6 @@
-import { a as SqliteQueryCompiler, i as SqliteAdapter } from "./auth-CbAfO4Ne.mjs";
+import { a as SqliteQueryCompiler, i as SqliteAdapter } from "./auth-uQ19WsD1.mjs";
 import { n as DEFAULT_MIGRATION_TABLE, t as DEFAULT_MIGRATION_LOCK_TABLE } from "./kysely-migration-tables-JkVUjPF_-bPAX9LR_.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/d1-sqlite-dialect-BLC8LXE6-nff_yHzH.js
+//#region node_modules/.nitro/vite/services/ssr/assets/d1-sqlite-dialect-BLC8LXE6-AuWb61y8.js
 var D1SqliteAdapter = class extends SqliteAdapter {};
 var D1SqliteDriver = class {
 	#config;

package/.output/server/_ssr/db-BMANvbZu.mjs

@@ -0,0 +1,2 @@
+import { j as db } from "./boot-DPoPmSLh.mjs";
+export { db };

package/.output/server/_ssr/{dist-BGjVt6NE.mjs → dist-CtYTvPCD.mjs}

@@ -1,5 +1,5 @@
-import { _ as logger, o as createAdapterFactory } from "./factory-DNeo3vVt.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/dist-BGjVt6NE.js
+import { _ as logger, o as createAdapterFactory } from "./factory-BtqxMS8a.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/dist-CtYTvPCD.js
 /**
 * Case-insensitive in-memory comparison helpers.
 * Used when evaluating where clauses in the memory adapter.

package/.output/server/_ssr/{factory-DNeo3vVt.mjs → factory-BtqxMS8a.mjs}

@@ -1,5 +1,5 @@
-import { J as getEnvVar, a as BetterAuthError, z as env } from "./boot-BZ-YyUiD.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/factory-DNeo3vVt.js
+import { J as getEnvVar, a as BetterAuthError, z as env } from "./boot-DPoPmSLh.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/factory-BtqxMS8a.js
 var __defProp = Object.defineProperty;
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {

package/.output/server/_ssr/{invite._token-Bipap1cl.mjs → invite._token-DBttmaDb.mjs}

@@ -2,12 +2,12 @@ import { o as __toESM } from "../_runtime.mjs";
 import { g as require_jsx_runtime, h as require_react } from "../_libs/@base-ui/react+[...].mjs";
 import { l as btnPrimary } from "./ui-B6mE5-5v.mjs";
 import { d as useNavigate } from "../_libs/@tanstack/react-router+[...].mjs";
-import { i as PievoLogo, s as useSession } from "./LoopPlaybook-C86vJIjZ.mjs";
+import { i as PievoLogo, s as useSession } from "./LoopPlaybook-WFNer22Y.mjs";
 import { t as setActiveTeamCookie } from "./teamCookie-B7hLOIie.mjs";
 import { c as redeemTeamInvite } from "./teamFns-BBIbatdZ.mjs";
-import { t as Route } from "./invite._token-z3PzCMzb.mjs";
-import { t as SignIn } from "./SignIn-BQQiD3Ss.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/invite._token-Bipap1cl.js
+import { t as Route } from "./invite._token-DtAfQyfP.mjs";
+import { t as SignIn } from "./SignIn-2qr-vtR5.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/invite._token-DBttmaDb.js
 var import_react = /* @__PURE__ */ __toESM(require_react());
 var import_jsx_runtime = require_jsx_runtime();
 /**

package/.output/server/_ssr/{invite._token-z3PzCMzb.mjs → invite._token-DtAfQyfP.mjs}

@@ -1,9 +1,9 @@
 import { c as createFileRoute, s as lazyRouteComponent } from "../_libs/@tanstack/react-router+[...].mjs";
 import { c as getAuthState } from "./loopApi-7MTSs6hy.mjs";
-import { a as authClient } from "./LoopPlaybook-C86vJIjZ.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/invite._token-z3PzCMzb.js
+import { a as authClient } from "./LoopPlaybook-WFNer22Y.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/invite._token-DtAfQyfP.js
 var $$splitErrorComponentImporter = () => import("./invite._token-BlbVjz-o.mjs");
-var $$splitComponentImporter = () => import("./invite._token-Bipap1cl.mjs");
+var $$splitComponentImporter = () => import("./invite._token-DBttmaDb.mjs");
 /**
 * Invite-link redeem (`/invite/<token>`, design §4 option B). The recipient opens
 * the link the owner shared; if signed out (under the gate) they hit the normal

package/.output/server/_ssr/{kysely-adapter-C1ww7PKr.mjs → kysely-adapter-bSpTlW7Z.mjs}

@@ -1,2 +1,2 @@
-import { r as kyselyAdapter, t as createKyselyAdapter } from "./auth-CbAfO4Ne.mjs";
+import { r as kyselyAdapter, t as createKyselyAdapter } from "./auth-uQ19WsD1.mjs";
 export { createKyselyAdapter, kyselyAdapter };