neondeck 1.0.0-beta.4

package/dist/assets/app-BuuvLo98.js

@@ -0,0 +1,3620 @@
+import { $ as readLearningOperatorState, $i as lockWorktree, $r as installFlueExecutionContextTracker, $t as getGitHubPrFiles, A as readReport, Ai as subscribeChatSessionEvents, An as listTaskRecords, At as reviewKiloResult, Ba as asJsonValue, Bi as formatConfigServerSentEvent, Bt as readRepoFile, Ca as nonEmptyStringSchema, Ci as listChatSessionCommandEvents, Cn as resolvePrReference, Cr as applyDashboardPreset, D as fixPrReviewFeedback, Da as readProviderConfigSync, Di as switchChatSession, E as commentPrAutofixResult, Ea as providerRuntimeRegistrations, Ei as restoreChatSession, Er as triagePrEvent, Fa as ConfigValidationError, Fi as archiveMemory, Fr as localApiTokenQueryParam, Gi as readRepoHealthSnapshot, Gn as verifyPrWorktree, Gt as pushPrAutofix, Ha as invalidInputAction, Hi as subscribeConfigEvents, Hr as listRuntimeSkills, Ht as searchRepoFiles, I as recordConversationTurnAndMaybeQueueLearning, Ia as parseAppConfig, Ii as listMemories, Ir as readLocalApiToken, J as rejectSkillPatchCandidate, Jn as getGitHubPullRequest, Jt as deleteGitHubPrReviewDraft, K as applySkillPatchCandidate, Ka as __require, Ki as readRepoRegistrySnapshot, L as recordHandledPrFromWorkflowResult, La as parseDashboardConfig, Li as listMemoryEvents, Lt as patchRepoFiles, Ma as ensureRuntimeHomeSync, Mn as removeTask, Mr as bearerToken, Mt as recordDocsDriftFixTaskBoundary, Na as readRuntimeJson, Ni as decideMemoryCandidate, Nn as setTaskEnabled, Nr as localApiAuthHeader, Oa as loadNeondeckEnv, Oi as updateChatSessionCommandEvent, On as createAgentInstructionTask, Ot as listKiloResultStates, Pi as listMemoryCandidates, Pr as localApiTokenMatches, Pt as fixPrCiFailure, Qi as createWorktree, Qt as getGitHubPrFileDiff, Ra as runtimePaths, Ri as upsertMemory, Rt as readRepoCheckoutStatus, Sa as subscribeNotificationEvents, Si as linkChatSessionContext, Sn as setPrWatchPolling, Sr as updateExecutionPolicy, St as searchKiloSessions, T as approvePreparedDiffPushWithPolicy, Ta as isRegisteredProvider, Ti as renameChatSession, Tr as reloadConfig, Ua as okAction, Un as settleScheduledTaskWorkflowRun, Ur as loadRuntimeSkill, Ut as writeRepoFile, Va as failedAction, Vi as replayConfigEventsAfter, Vr as readRuntimeStatus, Vt as replaceRepoFile, Wa as __commonJSMin, Wn as preparePrWorktree, Wr as reloadRuntimeSkills, Wt as listRepoEditEvents, Xi as listWorktrees, Xn as listGitHubPrQueue, Xt as getGitHubPrBranchPermissions, Y as restoreSkillPatchCandidate, Yt as deleteGitHubPrReviewDraftComment, Zi as cleanupWorktrees, Zr as getMcpRegistry, Zt as getGitHubPrEventState, _a as addNotification, _i as readChatSessionMessages, _n as addRefWatch, _r as updateRepoAutopilotPolicy, _t as readKiloSession, aa as listPreparedDiffs, ai as removeMcpServer, an as postGitHubPrComment, ba as resolveNotification, bi as createChatSession, bn as listRefWatches, br as updateAgentModels, bt as readKiloSessionMessages, c as abandonPreparedDiffWithRevisionAbort, ca as readPreparedDiffChangedFiles, ci as listMcpApprovals, cn as postGitHubPrThreadReply, cr as runApprovedExecution, d as failAutopilotAdmission, da as requestPreparedDiffRevision, dn as refreshPrWatchEventState, dr as resolveExecutionApproval, dt as readKiloTaskDiff, ea as readWorktreeStatus, ei as completeMcpOAuthCallback, en as getGitHubPrRequestedChanges, et as readWorkflowObservability, f as recordAutopilotAdmissionRun, fa as runPreparedDiffVerification, fr as checkExecutionPolicy, ft as readKiloTaskEvents, ga as setWorkflowSummaryRunId, gi as readChatSession, gn as addPrWatch, h as settleAutopilotAdmissionTriage, ha as listWorkflowSummaries, hi as listChatSessions, hr as readExecutionPolicy, ht as startKiloTask, i as runAutopilotRecoveryAction, ii as addMcpServer, in as patchGitHubPrReviewDraftComment, it as listLearningReviews, j as readReportHtml, ja as ensureRuntimeHome, jn as readTaskRecord, jr as readHostMetrics, jt as verifyKiloResult, k as listReports, ki as formatChatSessionServerSentEvent, kn as createBriefingTask, kt as promoteKiloResult, l as runPreparedDiffRevision, la as readPreparedDiffFileDiff, li as listMcpAudit, ln as postGitHubPrThreadResolution, lr as listExecutionApprovals, lt as abortKiloTask, m as settleAutopilotAdmissionPrepare, ma as addWorkflowSummary, mi as refreshChatSessionSummary, mt as readKiloTaskStatus, na as syncWorktree, ni as readPublicMcpOAuthLogin, nn as getGitHubPrReviewThreads, nt as loadAutomationLearningMemoryContext, o as readAutopilotState, oa as openPreparedDiffWorktree, oi as setMcpServerEnabled, on as postGitHubPrReview, or as syncExeDevCheckout, p as recordAutopilotAdmissionTerminalFact, pa as readApprovalRecord, pi as referenceChatSession, pt as readKiloTaskSessions, q as listSkillPatchCandidates, qi as repoFullName, r as readAutopilotRecoveryOptions, ri as startMcpOAuthLogin, rn as listPrWatchEventWatermarks, rt as attachLearningReviewRunId, s as autopilotStateSchema, si as updateMcpServer, sn as postGitHubPrReviewDraftComment, ta as releaseWorktreeLock, ti as logoutMcpOAuthServer, tn as getGitHubPrReviewDraft, tt as recordFlueObservation, u as beginAutopilotAdmissionPrepare, ua as readPreparedDiffSummary, ui as resolveMcpApprovalWithPaths, un as putGitHubPrReviewDraft, ur as requestExecutionApproval, ut as listKiloTasks, va as listNotifications, vi as searchChatSessions, vr as readProviderConfig, vt as readKiloSessionChildren, wa as parseInput, wi as pinChatSession, wr as updateDashboardLayout, xa as formatNotificationServerSentEvent, xi as createChatSessionCommandEvent, xn as removePrWatch, xr as updateWorktreePolicy, xt as readUnavailableSessionAdapter, ya as markNotificationRead, yi as archiveChatSession, yn as listPrWatches, yr as updateProviderConfig, yt as readKiloSessionDiff, zi as readNeonSessionState, zt as readRepoDiff } from "./autopilot-CKgEx8yQ.js";
+import { a as runSchedulerTick, c as rollbackQuietly, f as supportedCommands, n as readSafetyPolicy, o as isSqliteBusy, s as readMetadataValue } from "./safety-CawD9GxD.js";
+import { a as review_conversation_for_learning_default, r as review_pr_batch_for_learning_default, s as curate_learning_store_default, t as scheduler_tick_default } from "./scheduler-tick-Cy26qBld.js";
+import { getRun, invoke, listRuns, observe, registerProvider } from "@flue/runtime";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import "node:path";
+import { fileURLToPath } from "node:url";
+import { DatabaseSync } from "node:sqlite";
+import * as v from "valibot";
+import { flue } from "@flue/runtime/routing";
+import { Hono } from "hono";
+//#region node_modules/@hono/node-server/dist/utils/stream.cjs
+var require_stream = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	var node_stream = __require("node:stream");
+	var node_process = __require("node:process");
+	var pr54206Applied = () => {
+		const [major, minor] = node_process.versions.node.split(".").map((component) => parseInt(component));
+		return major >= 23 || major === 22 && minor >= 7 || major === 20 && minor >= 18;
+	};
+	var useReadableToWeb = pr54206Applied();
+	var createStreamBody = (stream, useNativeReadableToWeb = useReadableToWeb) => {
+		if (useNativeReadableToWeb) return node_stream.Readable.toWeb(stream);
+		let controller;
+		let settled = false;
+		const cleanup = () => {
+			stream.off("data", onData);
+			stream.off("error", onError);
+			stream.off("end", onTerminate);
+			stream.off("close", onTerminate);
+		};
+		const settle = (callback) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			callback?.();
+		};
+		const onData = (chunk) => {
+			if (settled || !controller) return;
+			controller.enqueue(chunk);
+			if ((controller.desiredSize ?? 0) <= 0) stream.pause();
+		};
+		const onError = (error) => {
+			settle(() => {
+				controller?.error(error);
+			});
+		};
+		const onTerminate = () => {
+			settle(() => {
+				controller?.close();
+			});
+		};
+		return new ReadableStream({
+			start(streamController) {
+				controller = streamController;
+				stream.on("data", onData);
+				stream.on("error", onError);
+				stream.on("end", onTerminate);
+				stream.on("close", onTerminate);
+				stream.pause();
+			},
+			pull() {
+				if (!settled) stream.resume();
+			},
+			cancel() {
+				settle();
+				const ignoreError = () => {};
+				stream.on("error", ignoreError);
+				stream.once("close", () => stream.off("error", ignoreError));
+				stream.destroy();
+			}
+		});
+	};
+	exports.createStreamBody = createStreamBody;
+}));
+//#endregion
+//#region node_modules/hono/dist/cjs/utils/mime.js
+var require_mime = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __export = (target, all) => {
+		for (var name in all) __defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	};
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") {
+			for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: () => from[key],
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+	var mime_exports = {};
+	__export(mime_exports, {
+		getExtension: () => getExtension,
+		getMimeType: () => getMimeType,
+		mimes: () => baseMimes
+	});
+	module.exports = __toCommonJS(mime_exports);
+	var getMimeType = (filename, mimes = baseMimes) => {
+		const match = filename.match(/\.([a-zA-Z0-9]+?)$/);
+		if (!match) return;
+		return mimes[match[1].toLowerCase()];
+	};
+	var getExtension = (mimeType) => {
+		const baseType = mimeType.split(";", 1)[0].trim();
+		for (const ext in baseMimes) {
+			const stored = baseMimes[ext];
+			if (stored === mimeType || stored.split(";", 1)[0].trim() === baseType) return ext;
+		}
+	};
+	var baseMimes = {
+		aac: "audio/aac",
+		avi: "video/x-msvideo",
+		avif: "image/avif",
+		av1: "video/av1",
+		bin: "application/octet-stream",
+		bmp: "image/bmp",
+		css: "text/css; charset=utf-8",
+		csv: "text/csv; charset=utf-8",
+		eot: "application/vnd.ms-fontobject",
+		epub: "application/epub+zip",
+		gif: "image/gif",
+		gz: "application/gzip",
+		htm: "text/html; charset=utf-8",
+		html: "text/html; charset=utf-8",
+		ico: "image/x-icon",
+		ics: "text/calendar; charset=utf-8",
+		jpeg: "image/jpeg",
+		jpg: "image/jpeg",
+		js: "text/javascript; charset=utf-8",
+		json: "application/json",
+		jsonld: "application/ld+json",
+		map: "application/json",
+		mid: "audio/x-midi",
+		midi: "audio/x-midi",
+		mjs: "text/javascript; charset=utf-8",
+		mp3: "audio/mpeg",
+		mp4: "video/mp4",
+		mpeg: "video/mpeg",
+		oga: "audio/ogg",
+		ogv: "video/ogg",
+		ogx: "application/ogg",
+		opus: "audio/opus",
+		otf: "font/otf",
+		pdf: "application/pdf",
+		png: "image/png",
+		rtf: "application/rtf",
+		svg: "image/svg+xml; charset=utf-8",
+		tif: "image/tiff",
+		tiff: "image/tiff",
+		ts: "video/mp2t",
+		ttf: "font/ttf",
+		txt: "text/plain; charset=utf-8",
+		wasm: "application/wasm",
+		webm: "video/webm",
+		weba: "audio/webm",
+		webmanifest: "application/manifest+json",
+		webp: "image/webp",
+		woff: "font/woff",
+		woff2: "font/woff2",
+		xhtml: "application/xhtml+xml; charset=utf-8",
+		xml: "application/xml; charset=utf-8",
+		zip: "application/zip",
+		"3gp": "video/3gpp",
+		"3g2": "video/3gpp2",
+		gltf: "model/gltf+json",
+		glb: "model/gltf-binary"
+	};
+	0 && (module.exports = {
+		getExtension,
+		getMimeType,
+		mimes
+	});
+}));
+//#endregion
+//#region src/server/events/config-stream.ts
+var import_serve_static = (/* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	var require_utils_stream = require_stream();
+	var hono_utils_mime = require_mime();
+	var node_fs = __require("node:fs");
+	var node_path = __require("node:path");
+	var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
+	var ENCODINGS = {
+		br: ".br",
+		zstd: ".zst",
+		gzip: ".gz"
+	};
+	var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+	var getStats = (path) => {
+		let stats;
+		try {
+			stats = (0, node_fs.statSync)(path);
+		} catch {}
+		return stats;
+	};
+	var tryDecode = (str, decoder) => {
+		try {
+			return decoder(str);
+		} catch {
+			return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+				try {
+					return decoder(match);
+				} catch {
+					return match;
+				}
+			});
+		}
+	};
+	var tryDecodeURI = (str) => tryDecode(str, decodeURI);
+	var serveStatic = (options = { root: "" }) => {
+		const root = options.root || "";
+		const optionPath = options.path;
+		if (root !== "" && !(0, node_fs.existsSync)(root)) console.error(`serveStatic: root path '${root}' is not found, are you sure it's correct?`);
+		return async (c, next) => {
+			if (c.finalized) return next();
+			let filename;
+			if (optionPath) filename = optionPath;
+			else try {
+				filename = tryDecodeURI(c.req.path);
+				if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}|\\/.test(filename)) throw new Error();
+			} catch {
+				await options.onNotFound?.(c.req.path, c);
+				return next();
+			}
+			let path = (0, node_path.join)(root, !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename);
+			let stats = getStats(path);
+			if (stats && stats.isDirectory()) {
+				const indexFile = options.index ?? "index.html";
+				path = (0, node_path.join)(path, indexFile);
+				stats = getStats(path);
+			}
+			if (!stats) {
+				await options.onNotFound?.(path, c);
+				return next();
+			}
+			const mimeType = (0, hono_utils_mime.getMimeType)(path);
+			c.header("Content-Type", mimeType || "application/octet-stream");
+			if (options.precompressed && (!mimeType || mimeType === "application/octet-stream" || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+				const acceptEncodingSet = new Set(c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim()));
+				for (const encoding of ENCODINGS_ORDERED_KEYS) {
+					if (!acceptEncodingSet.has(encoding)) continue;
+					const precompressedStats = getStats(path + ENCODINGS[encoding]);
+					if (precompressedStats) {
+						c.header("Content-Encoding", encoding);
+						c.header("Vary", "Accept-Encoding", { append: true });
+						stats = precompressedStats;
+						path = path + ENCODINGS[encoding];
+						break;
+					}
+				}
+			}
+			let result;
+			const size = stats.size;
+			const range = c.req.header("range") || "";
+			c.header("Last-Modified", stats.mtime.toUTCString());
+			if (c.req.method == "HEAD" || c.req.method == "OPTIONS") {
+				c.header("Content-Length", size.toString());
+				c.status(200);
+				result = c.body(null);
+			} else if (!range) {
+				c.header("Content-Length", size.toString());
+				result = c.body(require_utils_stream.createStreamBody((0, node_fs.createReadStream)(path)), 200);
+			} else {
+				c.header("Accept-Ranges", "bytes");
+				const parts = range.replace(/bytes=/, "").split("-", 2);
+				const start = parseInt(parts[0], 10) || 0;
+				let end = parseInt(parts[1], 10) || size - 1;
+				if (size < end - start + 1) end = size - 1;
+				const chunksize = end - start + 1;
+				const stream = (0, node_fs.createReadStream)(path, {
+					start,
+					end
+				});
+				c.header("Content-Length", chunksize.toString());
+				c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
+				result = c.body(require_utils_stream.createStreamBody(stream), 206);
+			}
+			await options.onFound?.(path, c);
+			return result;
+		};
+	};
+	exports.serveStatic = serveStatic;
+})))();
+var configEventHeartbeatMs = 1e4;
+var configEventStreamMaxAgeMs = 2e4;
+function createConfigEventRoutes() {
+	const routes = new Hono();
+	routes.get("/config", (c) => {
+		const lastEventId = c.req.header("last-event-id");
+		const encoder = new TextEncoder();
+		let cleanup = () => {};
+		const stream = new ReadableStream({
+			start(controller) {
+				let active = true;
+				function send(value) {
+					if (!active) return;
+					controller.enqueue(encoder.encode(value));
+				}
+				send("retry: 3000\n: connected\n\n");
+				const unsubscribe = subscribeConfigEvents((event) => {
+					send(formatConfigServerSentEvent(event));
+				});
+				for (const event of replayConfigEventsAfter(lastEventId)) send(formatConfigServerSentEvent(event));
+				const heartbeat = setInterval(() => {
+					send(`: heartbeat ${Date.now()}\n\n`);
+				}, configEventHeartbeatMs);
+				const maxAge = setTimeout(() => {
+					send(": reconnecting\n\n");
+					cleanup();
+					controller.close();
+				}, configEventStreamMaxAgeMs);
+				cleanup = () => {
+					if (!active) return;
+					active = false;
+					clearInterval(heartbeat);
+					clearTimeout(maxAge);
+					unsubscribe();
+				};
+			},
+			cancel() {
+				cleanup();
+			}
+		});
+		return new Response(stream, { headers: {
+			"cache-control": "no-cache, no-transform",
+			connection: "keep-alive",
+			"content-type": "text/event-stream; charset=utf-8",
+			"x-accel-buffering": "no"
+		} });
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/events/notification-stream.ts
+function createNotificationEventRoutes() {
+	const routes = new Hono();
+	routes.get("/notifications", () => {
+		const encoder = new TextEncoder();
+		let cleanup = () => {};
+		const stream = new ReadableStream({
+			start(controller) {
+				function send(value) {
+					controller.enqueue(encoder.encode(value));
+				}
+				send(": connected\n\n");
+				const unsubscribe = subscribeNotificationEvents((event) => {
+					send(formatNotificationServerSentEvent(event));
+				});
+				const heartbeat = setInterval(() => {
+					send(`: heartbeat ${Date.now()}\n\n`);
+				}, 25e3);
+				cleanup = () => {
+					clearInterval(heartbeat);
+					unsubscribe();
+				};
+			},
+			cancel() {
+				cleanup();
+			}
+		});
+		return new Response(stream, { headers: {
+			"cache-control": "no-cache, no-transform",
+			connection: "keep-alive",
+			"content-type": "text/event-stream; charset=utf-8",
+			"x-accel-buffering": "no"
+		} });
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/events/session-stream.ts
+function createSessionEventRoutes() {
+	const routes = new Hono();
+	routes.get("/sessions", () => {
+		const encoder = new TextEncoder();
+		let cleanup = () => {};
+		const stream = new ReadableStream({
+			start(controller) {
+				function send(value) {
+					controller.enqueue(encoder.encode(value));
+				}
+				send(": connected\n\n");
+				const unsubscribe = subscribeChatSessionEvents((event) => {
+					send(formatChatSessionServerSentEvent(event));
+				});
+				const heartbeat = setInterval(() => {
+					send(`: heartbeat ${Date.now()}\n\n`);
+				}, 25e3);
+				cleanup = () => {
+					clearInterval(heartbeat);
+					unsubscribe();
+				};
+			},
+			cancel() {
+				cleanup();
+			}
+		});
+		return new Response(stream, { headers: {
+			"cache-control": "no-cache, no-transform",
+			connection: "keep-alive",
+			"content-type": "text/event-stream; charset=utf-8",
+			"x-accel-buffering": "no"
+		} });
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/learning-hooks.ts
+var observationHandlerUnsubscribers = /* @__PURE__ */ new Map();
+function installFlueObservationHandlers(paths, dependencies = {}) {
+	if (observationHandlerUnsubscribers.has(paths.home)) return;
+	const unsubscribe = (dependencies.observe ?? observe)((event, context) => {
+		const contextHome = flueContextRuntimeHome(context);
+		if (contextHome && contextHome !== paths.home) return;
+		if (event.type === "run_end") {
+			recordFlueObservation(event, paths).then(async () => {
+				const terminalFact = autopilotTerminalFact(event);
+				if (terminalFact) await recordAutopilotAdmissionTerminalFact({
+					runId: event.runId,
+					fact: terminalFact
+				}, paths);
+			}).then(() => Promise.all([
+				settleScheduledTaskWorkflowRun({
+					workflowRunId: event.runId,
+					failed: event.isError
+				}, paths),
+				settleAutopilotAdmissionTriage({
+					runId: event.runId,
+					failed: terminalActionFailed(event),
+					shouldPrepare: triageRequestsPrepare(event)
+				}, paths),
+				settleAutopilotAdmissionPrepare({
+					runId: event.runId,
+					failed: terminalActionFailed(event),
+					worktreeId: prepareWorktreeId(event)
+				}, paths)
+			])).then(() => startPrepareAfterTriage(event, paths)).catch((error) => {
+				console.error("[neondeck] failed to record or settle Flue observation", error);
+			});
+			attachCommandRunSummaryRunId(event, paths).catch((error) => {
+				console.error("[neondeck] failed to attach Flue run id", error);
+			});
+			const learningReviewId = learningReviewResultId(event);
+			if (learningReviewId) Promise.resolve().then(() => attachLearningReviewRunId({
+				reviewId: learningReviewId,
+				runId: event.runId
+			}, paths)).catch((error) => {
+				console.error("[neondeck] failed to attach learning review run id", error);
+			});
+			if (!learningReviewId && !event.isError && "result" in event) Promise.resolve().then(() => recordHandledPrFromWorkflowResult({
+				workflow: workflowLabel(event),
+				runId: event.runId,
+				result: event.result
+			}, paths, { async invokePrBatchReview(input) {
+				return invoke(review_pr_batch_for_learning_default, { input });
+			} })).catch((error) => {
+				console.error("[neondeck] failed to record handled PR learning event", error);
+			});
+			if (event.isError) addNotification({
+				level: "attention",
+				title: "Workflow failed",
+				message: `${workflowLabel(event)} failed.`,
+				source: "flue",
+				sourceId: event.runId,
+				data: {
+					runId: event.runId,
+					workflow: workflowLabel(event),
+					error: "See guarded Flue run inspection for error details."
+				}
+			}, paths).catch((error) => {
+				console.error("[neondeck] failed to record Flue failure", error);
+			});
+			return;
+		}
+		recordFlueObservation(event, paths).catch((error) => {
+			console.error("[neondeck] failed to record Flue observation", error);
+		});
+		if (event.type === "operation" && event.durationMs > 15e3 && event.isError) addNotification({
+			level: "attention",
+			title: "Slow Flue operation failed",
+			message: `${event.operationKind} failed after ${Math.round(event.durationMs / 1e3)}s.`,
+			source: "flue",
+			sourceId: event.operationId,
+			data: {
+				operationKind: event.operationKind,
+				durationMs: event.durationMs,
+				error: "See workflow observability for error details."
+			}
+		}, paths).catch((error) => {
+			console.error("[neondeck] failed to record Flue operation", error);
+		});
+	});
+	observationHandlerUnsubscribers.set(paths.home, unsubscribe);
+}
+function flueContextRuntimeHome(context) {
+	const value = context?.env?.NEONDECK_HOME;
+	return typeof value === "string" && value ? value : void 0;
+}
+async function startPrepareAfterTriage(event, paths) {
+	if (event.isError || !triageRequestsPrepare(event)) return;
+	const admission = await beginAutopilotAdmissionPrepare({ triageRunId: event.runId }, paths);
+	if (!admission) return;
+	try {
+		const { runId } = await invoke((await import("./prepare-pr-worktree-CLzccRYh.js")).default, { input: {
+			repoId: admission.repoId,
+			prNumber: admission.prNumber,
+			eventId: admission.eventFingerprint,
+			lock: false
+		} });
+		await recordAutopilotAdmissionRun({
+			id: admission.id,
+			runId
+		}, paths);
+	} catch (error) {
+		await failAutopilotAdmission({
+			id: admission.id,
+			error: error instanceof Error ? error.message : String(error)
+		}, paths);
+	}
+}
+function triageRequestsPrepare(event) {
+	if (workflowLabel(event) !== "triage-pr-event" || !("result" in event)) return false;
+	const result = event.result;
+	if (!result || typeof result !== "object") return false;
+	const data = result.data;
+	return Boolean(data && typeof data === "object" && data.shouldPrepareWorktree === true);
+}
+function prepareWorktreeId(event) {
+	if (!("result" in event) || !event.result || typeof event.result !== "object") return;
+	const data = event.result.data;
+	if (!data || typeof data !== "object") return void 0;
+	const worktree = data.worktree;
+	if (!worktree || typeof worktree !== "object") return void 0;
+	const id = worktree.id;
+	return typeof id === "string" ? id : void 0;
+}
+function autopilotTerminalFact(event) {
+	const workflow = workflowLabel(event);
+	const failed = terminalActionFailed(event);
+	if (workflow === "triage-pr-event") return {
+		workflow,
+		failed,
+		shouldPrepare: !failed && triageRequestsPrepare(event)
+	};
+	if (workflow === "prepare-pr-worktree") return {
+		workflow,
+		failed,
+		worktreeId: failed ? void 0 : prepareWorktreeId(event)
+	};
+}
+function terminalActionFailed(event) {
+	if (event.isError || !("result" in event)) return event.isError;
+	const result = event.result;
+	return Boolean(result && typeof result === "object" && result.ok === false);
+}
+function recordHandledPrApiResult(paths, workflow, result) {
+	Promise.resolve().then(() => recordHandledPrFromWorkflowResult({
+		workflow,
+		result
+	}, paths, { async invokePrBatchReview(input) {
+		return invoke(review_pr_batch_for_learning_default, { input });
+	} })).catch((error) => {
+		console.error("[neondeck] failed to record handled PR learning event", error);
+	});
+}
+function displayAssistantLearningMiddleware(paths) {
+	return async (c, next) => {
+		const method = c.req.method.toUpperCase();
+		const sessionId = displayAssistantSessionId(c.req.path);
+		await next();
+		if (!sessionId || method !== "POST" || c.res.status >= 400) return;
+		recordConversationTurnAndMaybeQueueLearning(sessionId, paths, {
+			async invokeConversationReview(input) {
+				return invoke(review_conversation_for_learning_default, { input });
+			},
+			async invokeCurationReview(input) {
+				return invoke(curate_learning_store_default, { input });
+			}
+		}).catch((error) => {
+			console.error("[neondeck] failed to queue learning review", error);
+		});
+	};
+}
+async function attachCommandRunSummaryRunId(event, paths) {
+	const link = commandRunSummaryLink(event);
+	if (!link) return;
+	await setWorkflowSummaryRunId(link.summaryId, link.runId, paths);
+}
+function commandRunSummaryLink(event) {
+	if (!("result" in event)) return void 0;
+	const result = event.result;
+	if (!result || typeof result !== "object") return void 0;
+	const summary = result.workflowSummary;
+	if (!summary || typeof summary !== "object") return void 0;
+	const id = summary.id;
+	if (typeof id !== "string") return void 0;
+	const runId = stringField(summary, "workflow") === "ci_fix_run" ? stringField(event, "runId") : objectStringField(result, "data", "runId") ?? stringField(summary, "runId") ?? stringField(event, "runId");
+	if (!runId) return void 0;
+	return {
+		summaryId: id,
+		runId
+	};
+}
+function learningReviewResultId(event) {
+	if (!("result" in event)) return void 0;
+	const result = event.result;
+	if (!result || typeof result !== "object") return void 0;
+	const action = result.action;
+	if (action !== "learning_review_conversation" && action !== "learning_curate" && action !== "learning_review_pr_batch") return;
+	const reviewId = result.reviewId;
+	return typeof reviewId === "string" ? reviewId : void 0;
+}
+function workflowLabel(event) {
+	if ("workflow" in event && typeof event.workflow === "string") return event.workflow;
+	return `Workflow run ${event.runId ?? "unknown"}`;
+}
+function objectStringField(value, objectKey, stringKey) {
+	if (!(objectKey in value)) return void 0;
+	const nested = value[objectKey];
+	if (!nested || typeof nested !== "object") return void 0;
+	return stringField(nested, stringKey);
+}
+function stringField(value, key) {
+	if (!(key in value)) return void 0;
+	const field = value[key];
+	return typeof field === "string" && field.trim() ? field : void 0;
+}
+function displayAssistantSessionId(path) {
+	if (!path.startsWith("/api/flue/agents/display-assistant/")) return void 0;
+	const remainder = path.slice(35);
+	if (!remainder || remainder.includes("/")) return void 0;
+	return decodeURIComponent(remainder);
+}
+//#endregion
+//#region src/server/middleware.ts
+var localHosts = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"localhost",
+	"[::1]",
+	"::1"
+]);
+var requireLocalApiAccess = async (c, next) => {
+	const host = hostName(c.req.header("host"));
+	if (host && localHosts.has(host)) {
+		if (!isSafeMethod(c.req.method) && !isAllowedBrowserOrigin(c.req.raw)) return c.json({ error: "Not found" }, 404);
+		await next();
+		return;
+	}
+	return c.json({ error: "Not found" }, 404);
+};
+function requireFlueRunInspectionToken(paths) {
+	return async (c, next) => {
+		const expected = await readLocalApiToken(paths);
+		if (!localApiTokenMatches(c.req.header("x-neondeck-api-token") ?? bearerToken(c.req.header("authorization")) ?? c.req.query("neondeckApiToken"), expected)) return c.json({ error: "Not found" }, 404);
+		await next();
+	};
+}
+function hostName(host) {
+	if (!host) return void 0;
+	const lower = host.toLowerCase();
+	if (lower.startsWith("[")) return lower.slice(0, lower.indexOf("]") + 1);
+	return lower.split(":")[0];
+}
+function isSafeMethod(method) {
+	return method === "GET" || method === "HEAD" || method === "OPTIONS";
+}
+function isAllowedBrowserOrigin(request) {
+	const fetchSite = request.headers.get("sec-fetch-site");
+	if (fetchSite && fetchSite !== "same-origin" && fetchSite !== "none") return false;
+	const origin = request.headers.get("origin");
+	if (origin) return isLocalUrl(origin);
+	const referer = request.headers.get("referer");
+	if (referer) return isLocalUrl(referer);
+	return true;
+}
+function isLocalUrl(value) {
+	try {
+		const url = new URL(value);
+		return localHosts.has(url.hostname.toLowerCase());
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/server/autopilot-push-dispatch.ts
+async function approvePreparedDiffPushWithDispatch(rawInput, paths = runtimePaths(), dependencies = {}) {
+	const approval = await approvePreparedDiffPushWithPolicy(rawInput, paths);
+	if (!approval.ok || !approval.preparedDiff) return approval;
+	return dispatchApprovedPreparedDiffPush(approval, paths, dependencies);
+}
+async function dispatchApprovedPreparedDiffPush(approval, paths, dependencies) {
+	const preparedDiff = approval.preparedDiff;
+	if (!preparedDiff) return approval;
+	const mode = await readPushOnApprovalMode(paths);
+	if (mode === "off") return withDispatchData(approval, {
+		mode,
+		status: "off",
+		message: "Push dispatch is disabled by autopilot.pushOnApproval=off."
+	}, "Recorded prepared diff push approval. Push dispatch is disabled by autopilot.pushOnApproval=off.");
+	const dispatch = mode === "verify-then-push" && preparedDiff.verificationStatus !== "passed" ? verifyThenPushDispatch(preparedDiff) : pushDispatch(preparedDiff);
+	const invokeWorkflow = dependencies.invokeWorkflow ?? invokeAutopilotWorkflow;
+	const approvalId = approval.approvals?.[0]?.id ?? null;
+	let receipt;
+	try {
+		receipt = await invokeWorkflowForRuntimeHome(paths, dispatch, invokeWorkflow);
+	} catch (error) {
+		const message = errorMessage$3(error);
+		await recordDispatchFailure(preparedDiff, mode, dispatch, approvalId, message, paths);
+		return {
+			...withDispatchData(approval, {
+				mode,
+				status: "dispatch-failed",
+				workflow: dispatch.workflow,
+				message
+			}, `Recorded prepared diff push approval, but workflow dispatch failed: ${message}`),
+			requires: ["workflowDispatch"],
+			errors: [message]
+		};
+	}
+	const workflowSummary = await addWorkflowSummary({
+		workflow: dispatch.workflow.replaceAll("-", "_"),
+		runId: receipt.runId,
+		status: "pending",
+		summary: {
+			event: "prepared_diff_push_approval_dispatch",
+			mode,
+			approvalId,
+			preparedDiffId: preparedDiff.id,
+			worktreeId: preparedDiff.worktreeId,
+			repoId: preparedDiff.repoId,
+			repoFullName: preparedDiff.repoFullName,
+			prNumber: preparedDiff.prNumber,
+			workflow: dispatch.workflow,
+			input: dispatch.input,
+			dispatchedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	}, paths).catch(async (error) => {
+		const message = errorMessage$3(error);
+		await recordDispatchSummaryFailure(preparedDiff, mode, dispatch, approvalId, receipt.runId, message, paths);
+		return null;
+	});
+	const summaryFailedMessage = workflowSummary ? void 0 : " Workflow summary recording failed; the workflow was still admitted.";
+	return {
+		...withDispatchData(approval, {
+			mode,
+			status: "dispatched",
+			workflow: dispatch.workflow,
+			runId: receipt.runId,
+			workflowSummaryId: workflowSummary?.id ?? null,
+			message: `${dispatch.message}${summaryFailedMessage ?? ""}`
+		}, `${dispatch.message}${summaryFailedMessage ?? ""}`),
+		...workflowSummary ? {} : {
+			requires: ["workflowSummary"],
+			errors: [summaryFailedMessage.trim()]
+		}
+	};
+}
+function pushDispatch(preparedDiff) {
+	return {
+		workflow: "push-pr-autofix",
+		input: {
+			preparedDiffId: preparedDiff.id,
+			lockOwner: "approval_push_pr_autofix"
+		},
+		message: `Approved prepared diff ${preparedDiff.id}; dispatched push-pr-autofix workflow.`
+	};
+}
+function verifyThenPushDispatch(preparedDiff) {
+	return {
+		workflow: "verify-then-push-pr-autofix",
+		input: {
+			preparedDiffId: preparedDiff.id,
+			worktreeId: preparedDiff.worktreeId
+		},
+		message: `Approved prepared diff ${preparedDiff.id}; dispatched verify-then-push-pr-autofix workflow.`
+	};
+}
+async function readPushOnApprovalMode(paths) {
+	const value = (await readRuntimeJson(paths.config, parseAppConfig)).autopilot?.pushOnApproval;
+	return value === "push" || value === "off" ? value : "verify-then-push";
+}
+async function invokeWorkflowForRuntimeHome(paths, dispatch, invokeWorkflow) {
+	process.env.NEONDECK_HOME = paths.home;
+	return invokeWorkflow(dispatch.workflow, dispatch.input);
+}
+async function invokeAutopilotWorkflow(workflow, input) {
+	if (workflow === "push-pr-autofix") return invokeWorkflow((await import("./push-pr-autofix-BFNSEASU.js")).default, { input });
+	return invokeWorkflow((await import("./verify-then-push-pr-autofix-CIl5ZwZm.js")).default, { input });
+}
+async function recordDispatchFailure(preparedDiff, mode, dispatch, approvalId, error, paths) {
+	await addWorkflowSummary({
+		workflow: dispatch.workflow.replaceAll("-", "_"),
+		status: "failed",
+		summary: {
+			event: "prepared_diff_push_approval_dispatch",
+			mode,
+			approvalId,
+			preparedDiffId: preparedDiff.id,
+			worktreeId: preparedDiff.worktreeId,
+			repoId: preparedDiff.repoId,
+			repoFullName: preparedDiff.repoFullName,
+			prNumber: preparedDiff.prNumber,
+			workflow: dispatch.workflow,
+			input: dispatch.input,
+			error,
+			dispatchedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	}, paths).catch(() => void 0);
+	await addNotification({
+		level: "attention",
+		title: "Push dispatch failed",
+		message: `Prepared diff ${preparedDiff.id} was approved, but workflow dispatch failed: ${error}`,
+		source: "autopilot",
+		sourceId: `prepared-diff:${preparedDiff.id}:push-dispatch-failed`,
+		data: {
+			approvalId,
+			preparedDiffId: preparedDiff.id,
+			worktreeId: preparedDiff.worktreeId,
+			workflow: dispatch.workflow,
+			error
+		}
+	}, paths).catch(() => void 0);
+}
+async function recordDispatchSummaryFailure(preparedDiff, mode, dispatch, approvalId, runId, error, paths) {
+	await addNotification({
+		level: "attention",
+		title: "Push dispatch audit failed",
+		message: `Prepared diff ${preparedDiff.id} dispatched ${dispatch.workflow} (${runId}), but workflow summary recording failed: ${error}`,
+		source: "autopilot",
+		sourceId: `prepared-diff:${preparedDiff.id}:push-dispatch-summary-failed:${runId}`,
+		data: {
+			mode,
+			approvalId,
+			preparedDiffId: preparedDiff.id,
+			worktreeId: preparedDiff.worktreeId,
+			workflow: dispatch.workflow,
+			runId,
+			error
+		}
+	}, paths).catch(() => void 0);
+}
+async function invokeWorkflow(workflow, request) {
+	return invoke(workflow, request);
+}
+function errorMessage$3(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function withDispatchData(approval, dispatch, message) {
+	const existing = approval.data && typeof approval.data === "object" && !Array.isArray(approval.data) ? approval.data : {};
+	return {
+		...approval,
+		message,
+		data: asJsonValue({
+			...existing,
+			pushApprovalDispatch: dispatch,
+			dispatchedPushRunId: typeof dispatch.runId === "string" ? dispatch.runId : null,
+			workflowSummaryId: typeof dispatch.workflowSummaryId === "string" ? dispatch.workflowSummaryId : null
+		})
+	};
+}
+//#endregion
+//#region src/server/http.ts
+async function safeJsonBody(c) {
+	return c.req.json().catch(() => ({}));
+}
+async function safeJsonObject(c) {
+	const body = await safeJsonBody(c);
+	return body && typeof body === "object" && !Array.isArray(body) ? body : {};
+}
+function boundedQueryLimit(value, fallback) {
+	if (!value) return fallback;
+	const limit = Number(value);
+	if (!Number.isInteger(limit) || limit < 1 || limit > 100) return void 0;
+	return limit;
+}
+function queryNumber(value) {
+	if (!value) return void 0;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function queryBoolean(value) {
+	if (!value) return void 0;
+	if (value === "1" || value === "true") return true;
+	if (value === "0" || value === "false") return false;
+}
+function kiloSessionQuery(c) {
+	return {
+		limit: queryNumber(c.req.query("limit")),
+		offset: queryNumber(c.req.query("offset")),
+		maxBytes: queryNumber(c.req.query("maxBytes")),
+		includeFullTranscript: queryBoolean(c.req.query("includeFullTranscript")),
+		includeToolOutput: queryBoolean(c.req.query("includeToolOutput")),
+		includeDiff: queryBoolean(c.req.query("includeDiff")),
+		requesterSurface: c.req.query("requesterSurface") ?? "dashboard",
+		readReason: c.req.query("readReason") ?? "dashboard-kilo-session-read"
+	};
+}
+function preparedDiffHttpStatus(result) {
+	if (result.ok) return 200;
+	if (result.error?.code === "PREPARED_DIFF_NOT_FOUND") return 404;
+	return 400;
+}
+//#endregion
+//#region src/server/routes/autopilot.ts
+function createAutopilotRoutes(paths) {
+	const routes = new Hono();
+	routes.post("/autopilot/triage-pr-event", async (c) => {
+		const result = await triagePrEvent(await safeJsonBody(c));
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/autopilot/prepare-pr-worktree", async (c) => {
+		const result = await preparePrWorktree(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/autopilot/fix-pr-ci-failure", async (c) => {
+		const result = await fixPrCiFailure(await safeJsonBody(c), paths);
+		recordHandledPrApiResult(paths, "api:fix_pr_ci_failure", result);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/autopilot/fix-pr-review-feedback", async (c) => {
+		const result = await fixPrReviewFeedback(await safeJsonBody(c), paths);
+		recordHandledPrApiResult(paths, "api:fix_pr_review_feedback", result);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/autopilot/comment-pr-autofix-result", async (c) => {
+		const result = await commentPrAutofixResult(await safeJsonBody(c), paths);
+		recordHandledPrApiResult(paths, "api:comment_pr_autofix_result", result);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/autopilot/approvals/:id/resolve", async (c) => {
+		const input = await safeJsonObject(c);
+		const decision = input.decision;
+		if (decision !== "approve" && decision !== "deny") return c.json({
+			ok: false,
+			action: "autopilot_approval_resolve",
+			changed: false,
+			message: "Decision must be approve or deny.",
+			errors: ["decision is required."]
+		}, 400);
+		const executionResult = await resolveExecutionApproval({
+			id: c.req.param("id"),
+			decision: decision === "approve" ? "allow-once" : "deny",
+			approverSurface: "dashboard"
+		}, paths);
+		if (executionResult.ok || !approvalNotFound(executionResult.message)) return c.json(executionResult, executionResult.ok ? 200 : 400);
+		const approval = readApprovalRecord(c.req.param("id"), paths);
+		if (!approval) return c.json({
+			ok: false,
+			action: "autopilot_approval_resolve",
+			changed: false,
+			message: `Autopilot approval "${c.req.param("id")}" was not found.`,
+			errors: ["approval not found."]
+		}, 404);
+		const result = decision === "approve" ? await approvePreparedDiffPushWithDispatch({
+			preparedDiffId: approval.preparedDiffId,
+			confirm: true,
+			reason: "Approved from dashboard Autopilot panel.",
+			approverSurface: "dashboard"
+		}, paths) : await resolvePreparedDiffRevisionFromRoute(approval.preparedDiffId, input, paths);
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.get("/prepared-diffs", async (c) => {
+		const result = await listPreparedDiffs({
+			status: c.req.query("status") || void 0,
+			includeTerminal: queryBoolean(c.req.query("includeTerminal")),
+			repoId: c.req.query("repoId") || void 0
+		}, paths);
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.get("/prepared-diffs/:id/summary", async (c) => {
+		const result = await readPreparedDiffSummary({ preparedDiffId: c.req.param("id") }, paths);
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.get("/prepared-diffs/:id/files", async (c) => {
+		const result = await readPreparedDiffChangedFiles({ preparedDiffId: c.req.param("id") }, paths);
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.get("/prepared-diffs/:id/files/diff", async (c) => {
+		const result = await readPreparedDiffFileDiff({
+			preparedDiffId: c.req.param("id"),
+			path: c.req.query("path"),
+			maxPatchBytes: queryNumber(c.req.query("maxPatchBytes"))
+		}, paths);
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.post("/prepared-diffs/:id/approve-push", async (c) => {
+		const result = await approvePreparedDiffPushWithDispatch({
+			...await safeJsonObject(c),
+			preparedDiffId: c.req.param("id")
+		}, paths);
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.post("/prepared-diffs/:id/request-revision", async (c) => {
+		const body = await safeJsonObject(c);
+		const requested = await requestPreparedDiffRevision({
+			...body,
+			preparedDiffId: c.req.param("id")
+		}, paths);
+		const result = requested.ok && (body.runRevisionNow === true || body.runNow === true) ? await runPreparedDiffRevision({
+			preparedDiffId: c.req.param("id"),
+			reason: typeof body.reason === "string" ? body.reason : void 0,
+			approverSurface: typeof body.approverSurface === "string" ? body.approverSurface : "dashboard"
+		}, paths) : requested;
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.post("/prepared-diffs/:id/run-revision", async (c) => {
+		const result = await runPreparedDiffRevision({
+			...await safeJsonObject(c),
+			preparedDiffId: c.req.param("id")
+		}, paths);
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.post("/prepared-diffs/:id/abandon", async (c) => {
+		const result = await abandonPreparedDiffWithRevisionAbort({
+			...await safeJsonObject(c),
+			preparedDiffId: c.req.param("id")
+		}, paths);
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.get("/prepared-diffs/:id/worktree-path", async (c) => {
+		const result = await openPreparedDiffWorktree({ preparedDiffId: c.req.param("id") }, paths);
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.post("/prepared-diffs/:id/verify", async (c) => {
+		const result = await runPreparedDiffVerification({
+			...await safeJsonObject(c),
+			preparedDiffId: c.req.param("id")
+		}, paths);
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.get("/prepared-diffs/:id/recovery", async (c) => {
+		const result = await readAutopilotRecoveryOptions({ preparedDiffId: c.req.param("id") }, paths);
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.post("/prepared-diffs/:id/recovery/run", async (c) => {
+		const result = await runAutopilotRecoveryAction({
+			...await safeJsonObject(c),
+			preparedDiffId: c.req.param("id")
+		}, paths, { allowRevisionDispatch: true });
+		recordHandledPrApiResult(paths, "api:autopilot_recovery", result);
+		return c.json(result, preparedDiffHttpStatus(result));
+	});
+	routes.post("/autopilot/verify-pr-worktree", async (c) => {
+		const result = await verifyPrWorktree(await safeJsonBody(c), paths);
+		recordHandledPrApiResult(paths, "api:verify_pr_worktree", result);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/autopilot/push-pr-autofix", async (c) => {
+		const result = await pushPrAutofix(await safeJsonBody(c), paths);
+		recordHandledPrApiResult(paths, "api:push_pr_autofix", result);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/prepared-diffs/:id/push", async (c) => {
+		const result = await pushPrAutofix({
+			...await safeJsonObject(c),
+			preparedDiffId: c.req.param("id")
+		}, paths);
+		recordHandledPrApiResult(paths, "api:push_pr_autofix", result);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	return routes;
+}
+function approvalNotFound(message) {
+	return Boolean(message?.includes("was not found"));
+}
+async function resolvePreparedDiffRevisionFromRoute(preparedDiffId, input, paths) {
+	const reason = typeof input.reason === "string" ? input.reason : void 0;
+	const runRevisionNow = input.runRevisionNow !== false;
+	if (runRevisionNow && !reason?.trim()) return {
+		ok: false,
+		action: "prepared_diff_request_revision",
+		changed: false,
+		message: "Running a prepared-diff revision requires a revision note.",
+		requires: ["reason"],
+		errors: ["reason is required."]
+	};
+	const requested = await requestPreparedDiffRevision({
+		preparedDiffId,
+		reason,
+		approverSurface: "dashboard"
+	}, paths);
+	if (!requested.ok || !runRevisionNow) return requested;
+	const run = await runPreparedDiffRevision({
+		preparedDiffId,
+		reason,
+		approverSurface: "dashboard"
+	}, paths);
+	return {
+		...run,
+		data: {
+			request: requested,
+			run
+		}
+	};
+}
+//#endregion
+//#region src/server/routes/commands.ts
+function createCommandRoutes() {
+	const routes = new Hono();
+	routes.get("/", (c) => {
+		return c.json({ items: supportedCommands() });
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/config.ts
+function createConfigRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/providers", async (c) => {
+		return c.json(await readProviderConfig(paths));
+	});
+	routes.post("/config/reload", async (c) => {
+		return c.json(await reloadConfig(paths));
+	});
+	routes.post("/models", async (c) => {
+		return c.json(await updateAgentModels(await c.req.json(), paths));
+	});
+	routes.post("/providers/kilocode", async (c) => {
+		const input = await c.req.json();
+		return c.json(await updateProviderConfig({
+			...input,
+			provider: "kilocode"
+		}, paths));
+	});
+	routes.post("/providers/:provider", async (c) => {
+		const input = await safeJsonObject(c);
+		const provider = c.req.param("provider");
+		if (!isRegisteredProvider(provider)) return c.json({
+			ok: false,
+			changed: false,
+			action: "config_update_provider",
+			message: `Unsupported provider "${provider}".`
+		}, 400);
+		return c.json(await updateProviderConfig({
+			...input,
+			provider
+		}, paths));
+	});
+	routes.post("/worktrees/policy", async (c) => {
+		const result = await updateWorktreePolicy(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/repos/:repoId/autopilot-policy", async (c) => {
+		const result = await updateRepoAutopilotPolicy({
+			...await safeJsonObject(c),
+			repoId: c.req.param("repoId")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/dashboard/config", async (c) => {
+		try {
+			return c.json(await readRuntimeJson(paths.dashboard, parseDashboardConfig));
+		} catch (error) {
+			if (error instanceof ConfigValidationError) return c.json({
+				error: "Invalid dashboard config",
+				message: error.message,
+				path: error.path
+			}, 500);
+			throw error;
+		}
+	});
+	routes.post("/dashboard/config", async (c) => {
+		const result = await updateDashboardLayout(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/dashboard/preset", async (c) => {
+		const result = await applyDashboardPreset(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/execution.ts
+function createExecutionRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/policy", async (c) => {
+		return c.json(await readExecutionPolicy(paths));
+	});
+	routes.post("/policy", async (c) => {
+		const input = await safeJsonBody(c);
+		return c.json(await updateExecutionPolicy(input, paths));
+	});
+	routes.post("/check", async (c) => {
+		const input = await safeJsonBody(c);
+		return c.json(await checkExecutionPolicy(input, paths));
+	});
+	routes.get("/approvals", async (c) => {
+		const includeResolved = c.req.query("includeResolved") === "1";
+		return c.json(await listExecutionApprovals(paths, { includeResolved }));
+	});
+	routes.post("/approvals", async (c) => {
+		const result = await requestExecutionApproval(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/approvals/:id/resolve", async (c) => {
+		const result = await resolveExecutionApproval({
+			...await c.req.json().catch(() => ({})),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/run", async (c) => {
+		const result = await runApprovedExecution(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/exedev/sync-checkout", async (c) => {
+		const result = await syncExeDevCheckout(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/github.ts
+function createGitHubRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/prs", async (c) => {
+		const result = await listGitHubPrQueue(paths);
+		const queue = result.ok && result.data && typeof result.data === "object" ? result.data.queue : void 0;
+		if (queue && typeof queue === "object") return c.json(queue);
+		return c.json({
+			error: result.message,
+			items: [],
+			issues: (result.errors ?? [result.message]).map((message) => ({
+				type: "search-error",
+				message
+			}))
+		}, result.requires?.includes("GITHUB_TOKEN") ? 503 : 502);
+	});
+	routes.get("/prs/:owner/:repo/:number", async (c) => {
+		const target = prTargetFromParams(c.req.param("owner"), c.req.param("repo"), c.req.param("number"));
+		if (!target.ok) return c.json(target.result, 400);
+		const result = await getGitHubPullRequest({
+			repo: target.input.repo,
+			number: target.input.prNumber
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/prs/:owner/:repo/:number/files/diff", async (c) => {
+		const owner = c.req.param("owner");
+		const repo = c.req.param("repo");
+		const number = Number(c.req.param("number"));
+		if (!Number.isInteger(number) || number <= 0) return c.json({
+			ok: false,
+			action: "github_pr_file_diff_get",
+			changed: false,
+			message: "Invalid PR number.",
+			requires: ["prNumber"]
+		}, 400);
+		const result = await getGitHubPrFileDiff({
+			repo: `${owner}/${repo}`,
+			prNumber: number,
+			path: c.req.query("path") ?? "",
+			headSha: c.req.query("head")?.trim() || void 0,
+			baseSha: c.req.query("base")?.trim() || void 0,
+			baseRef: c.req.query("baseRef")?.trim() || void 0,
+			source: sourceQuery(c.req.query("source")),
+			maxPatchBytes: queryNumber(c.req.query("maxPatchBytes"))
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/prs/:owner/:repo/:number/files", async (c) => {
+		const owner = c.req.param("owner");
+		const repo = c.req.param("repo");
+		const number = Number(c.req.param("number"));
+		if (!Number.isInteger(number) || number <= 0) return c.json({
+			ok: false,
+			action: "github_pr_files_get",
+			changed: false,
+			message: "Invalid PR number.",
+			requires: ["prNumber"]
+		}, 400);
+		const result = await getGitHubPrFiles({
+			repo: `${owner}/${repo}`,
+			prNumber: number,
+			headSha: c.req.query("head")?.trim() || void 0,
+			baseSha: c.req.query("base")?.trim() || void 0,
+			baseRef: c.req.query("baseRef")?.trim() || void 0,
+			patches: patchesQuery(c.req.query("patches")),
+			source: sourceQuery(c.req.query("source"))
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/prs/:owner/:repo/:number/review-draft", async (c) => {
+		const target = prTargetFromParams(c.req.param("owner"), c.req.param("repo"), c.req.param("number"));
+		if (!target.ok) return c.json(target.result, 400);
+		const result = await getGitHubPrReviewDraft(target.input, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.put("/prs/:owner/:repo/:number/review-draft", async (c) => {
+		const target = prTargetFromParams(c.req.param("owner"), c.req.param("repo"), c.req.param("number"));
+		if (!target.ok) return c.json(target.result, 400);
+		const result = await putGitHubPrReviewDraft(target.input, await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/prs/:owner/:repo/:number/review-draft/comments", async (c) => {
+		const target = prTargetFromParams(c.req.param("owner"), c.req.param("repo"), c.req.param("number"));
+		if (!target.ok) return c.json(target.result, 400);
+		const result = await postGitHubPrReviewDraftComment(target.input, await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.patch("/prs/:owner/:repo/:number/review-draft/comments/:id", async (c) => {
+		const target = prTargetFromParams(c.req.param("owner"), c.req.param("repo"), c.req.param("number"));
+		if (!target.ok) return c.json(target.result, 400);
+		const result = await patchGitHubPrReviewDraftComment(target.input, c.req.param("id"), await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.delete("/prs/:owner/:repo/:number/review-draft/comments/:id", async (c) => {
+		const target = prTargetFromParams(c.req.param("owner"), c.req.param("repo"), c.req.param("number"));
+		if (!target.ok) return c.json(target.result, 400);
+		const result = await deleteGitHubPrReviewDraftComment(target.input, c.req.param("id"), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.delete("/prs/:owner/:repo/:number/review-draft", async (c) => {
+		const target = prTargetFromParams(c.req.param("owner"), c.req.param("repo"), c.req.param("number"));
+		if (!target.ok) return c.json(target.result, 400);
+		const result = await deleteGitHubPrReviewDraft(target.input, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/prs/:owner/:repo/:number/reviews", async (c) => {
+		const target = prTargetFromParams(c.req.param("owner"), c.req.param("repo"), c.req.param("number"));
+		if (!target.ok) return c.json(target.result, 400);
+		const result = await postGitHubPrReview(target.input, await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/prs/:owner/:repo/:number/review-threads/:threadId/reply", async (c) => {
+		const target = prTargetFromParams(c.req.param("owner"), c.req.param("repo"), c.req.param("number"));
+		if (!target.ok) return c.json(target.result, 400);
+		const result = await postGitHubPrThreadReply(target.input, c.req.param("threadId"), await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/prs/:owner/:repo/:number/review-threads/:threadId/resolve", async (c) => {
+		const target = prTargetFromParams(c.req.param("owner"), c.req.param("repo"), c.req.param("number"));
+		if (!target.ok) return c.json(target.result, 400);
+		const result = await postGitHubPrThreadResolution(target.input, c.req.param("threadId"), true, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/prs/:owner/:repo/:number/review-threads/:threadId/unresolve", async (c) => {
+		const target = prTargetFromParams(c.req.param("owner"), c.req.param("repo"), c.req.param("number"));
+		if (!target.ok) return c.json(target.result, 400);
+		const result = await postGitHubPrThreadResolution(target.input, c.req.param("threadId"), false, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/prs/event-state", async (c) => {
+		const result = await getGitHubPrEventState(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/prs/review-threads", async (c) => {
+		const result = await getGitHubPrReviewThreads(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/prs/requested-changes", async (c) => {
+		const result = await getGitHubPrRequestedChanges(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/prs/branch-permissions", async (c) => {
+		const result = await getGitHubPrBranchPermissions(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/prs/comment", async (c) => {
+		const result = await postGitHubPrComment(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	return routes;
+}
+function prTargetFromParams(owner, repo, numberText) {
+	const number = Number(numberText);
+	if (!Number.isInteger(number) || number <= 0) return {
+		ok: false,
+		result: {
+			ok: false,
+			action: "github_pr_review_target",
+			changed: false,
+			message: "Invalid PR number.",
+			requires: ["prNumber"]
+		}
+	};
+	return {
+		ok: true,
+		input: {
+			repo: `${owner}/${repo}`,
+			prNumber: number
+		}
+	};
+}
+function patchesQuery(value) {
+	return value === "none" || value === "all" ? value : void 0;
+}
+function sourceQuery(value) {
+	return value === "local" || value === "github" || value === "auto" ? value : void 0;
+}
+//#endregion
+//#region src/modules/handoff/schemas.ts
+var handoffSourceSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(120));
+var handoffNoteLevelSchema = v.optional(v.picklist([
+	"info",
+	"ready",
+	"attention",
+	"urgent"
+]), "info");
+var handoffNoteInputSchema = v.strictObject({
+	text: v.pipe(v.string(), v.minLength(1), v.maxLength(4096)),
+	source: v.optional(handoffSourceSchema),
+	repo: v.optional(v.pipe(v.string(), v.minLength(1))),
+	pr: v.optional(v.pipe(v.string(), v.minLength(1))),
+	level: handoffNoteLevelSchema
+});
+var handoffRegisterPrInputSchema = v.strictObject({
+	ref: v.pipe(v.string(), v.minLength(1)),
+	source: v.optional(handoffSourceSchema),
+	watch: v.optional(v.boolean()),
+	review: v.optional(v.boolean()),
+	note: v.optional(v.pipe(v.string(), v.minLength(1), v.maxLength(4096)))
+});
+var handoffWatchPrInputSchema = v.strictObject({
+	ref: v.pipe(v.string(), v.minLength(1)),
+	source: v.optional(handoffSourceSchema),
+	desiredTerminalState: v.optional(v.picklist(["checks", "merged"])),
+	intervalSeconds: v.optional(v.pipe(v.number(), v.integer(), v.minValue(60)))
+});
+v.looseObject({
+	ok: v.boolean(),
+	action: v.string(),
+	changed: v.boolean(),
+	message: v.string(),
+	id: v.optional(v.string()),
+	deckUrl: v.optional(v.string())
+});
+//#endregion
+//#region src/modules/handoff/service.ts
+var deckUrl = "/";
+async function registerHandoffWatchPr(rawInput, paths = runtimePaths(), dependencies = {}) {
+	await ensureRuntimeHome(paths);
+	const parsed = parseHandoffInput(handoffWatchPrInputSchema, rawInput, "handoff_pr_watch");
+	if (!parsed.ok) return parsed.result;
+	const source = normalizeHandoffSource(parsed.input.source);
+	const prLink = await resolveRegisteredPrLink(parsed.input.ref, paths);
+	if (!prLink.ok) return prLink.result;
+	const desiredTerminalState = parsed.input.desiredTerminalState ?? "checks";
+	const watchResult = await (dependencies.addPrWatch ?? addPrWatch)({
+		ref: prLink.link.ref.id,
+		desiredTerminalState,
+		...parsed.input.intervalSeconds !== void 0 ? { intervalSeconds: parsed.input.intervalSeconds } : {},
+		createdBy: source
+	}, paths);
+	if (!watchResult.ok) return failResult("handoff_pr_watch", watchResult.message, {
+		errors: watchResult.errors,
+		requires: watchResult.requires
+	});
+	const watchId = watchIdFromValue(watchResult.watch);
+	const audit = await addHandoffAudit({
+		event: "watch-pr",
+		source,
+		ref: prLink.link.ref.id,
+		desiredTerminalState,
+		intervalSeconds: parsed.input.intervalSeconds ?? null,
+		watchId: watchId ?? null
+	}, paths);
+	return okResult("handoff_pr_watch", watchResult.changed, watchResult.changed ? `Watching ${prLink.link.ref.id} from ${displaySource(source)}.` : `Watch for ${prLink.link.ref.id} was already current.`, {
+		id: watchId,
+		watch: watchResult.watch,
+		audit
+	});
+}
+async function createHandoffNote(rawInput, paths = runtimePaths(), dependencies = {}) {
+	await ensureRuntimeHome(paths);
+	const parsed = parseHandoffInput(handoffNoteInputSchema, rawInput, "handoff_note_create");
+	if (!parsed.ok) return parsed.result;
+	const source = normalizeHandoffSource(parsed.input.source);
+	const prLink = parsed.input.pr ? await resolveRegisteredPrLink(parsed.input.pr, paths) : null;
+	if (prLink && !prLink.ok) return prLink.result;
+	const repoResult = parsed.input.repo ? await resolveRegisteredRepo(parsed.input.repo, paths) : null;
+	if (repoResult && !repoResult.ok) return repoResult.result;
+	const repo = prLink?.link.repo ?? repoResult?.repo ?? null;
+	if (prLink?.link.repo && repoResult?.repo) {
+		if (repoFullName(prLink.link.repo).toLowerCase() !== repoFullName(repoResult.repo).toLowerCase()) return failResult("handoff_note_create", `Note repo "${repoFullName(repoResult.repo)}" does not match PR repo "${repoFullName(prLink.link.repo)}".`, { requires: ["repo"] });
+	}
+	const level = parsed.input.level === "urgent" ? "attention" : parsed.input.level;
+	const sourceId = noteSourceId({
+		source,
+		text: parsed.input.text,
+		repoFullName: repo ? repoFullName(repo) : null,
+		prId: prLink?.link.ref.id ?? null
+	});
+	const notification = await (dependencies.createNotification ?? addNotification)({
+		level,
+		title: `Note from ${displaySource(source)}`,
+		message: parsed.input.text,
+		source,
+		sourceId,
+		data: {
+			kind: "external-note",
+			source,
+			repoId: repo?.id ?? null,
+			repoFullName: repo ? repoFullName(repo) : null,
+			prNumber: prLink?.link.ref.prNumber ?? null,
+			prRef: prLink?.link.ref.id ?? null
+		}
+	}, paths);
+	const audit = await addHandoffAudit({
+		event: "note",
+		source,
+		notificationId: notification.id,
+		repoId: repo?.id ?? null,
+		repoFullName: repo ? repoFullName(repo) : null,
+		prRef: prLink?.link.ref.id ?? null,
+		level
+	}, paths);
+	return okResult("handoff_note_create", true, "Created handoff note.", {
+		id: notification.id,
+		notification,
+		audit
+	});
+}
+async function registerHandoffPr(rawInput, paths = runtimePaths(), dependencies = {}) {
+	await ensureRuntimeHome(paths);
+	const parsed = parseHandoffInput(handoffRegisterPrInputSchema, rawInput, "handoff_pr_register");
+	if (!parsed.ok) return parsed.result;
+	const input = parsed.input;
+	const source = normalizeHandoffSource(input.source);
+	if (input.review === true) {
+		if (!await externalReviewQueueAllowed(paths)) return failResult("handoff_pr_register", "External PR review queueing is disabled by handoff.allowExternalReviewQueue.", { requires: ["handoff.allowExternalReviewQueue"] });
+	}
+	const prLink = await resolveRegisteredPrLink(input.ref, paths);
+	if (!prLink.ok) return prLink.result;
+	const ref = prLink.link.ref.id;
+	const watchEnabled = input.watch ?? true;
+	let watch;
+	let watchChanged = false;
+	let watchId;
+	if (watchEnabled) {
+		const watchResult = await (dependencies.addPrWatch ?? addPrWatch)({
+			ref,
+			desiredTerminalState: "checks",
+			createdBy: source
+		}, paths);
+		if (!watchResult.ok) return failResult("handoff_pr_register", watchResult.message, {
+			errors: watchResult.errors,
+			requires: watchResult.requires
+		});
+		watch = watchResult.watch;
+		watchChanged = watchResult.changed;
+		watchId = watchIdFromValue(watch);
+	}
+	let notification;
+	if (input.note) {
+		const noteResult = await createHandoffNote({
+			text: input.note,
+			source,
+			pr: ref,
+			level: "ready"
+		}, paths, dependencies);
+		if (!noteResult.ok) return noteResult;
+		notification = noteResult.notification;
+	}
+	let review;
+	if (input.review === true) {
+		const invokeReview = dependencies.invokeReviewPrWorkflow ?? invokeReviewPrWorkflow;
+		try {
+			const { runId } = await invokeReview({ ref });
+			review = asJsonValue({
+				workflow: "review-pr-for-human",
+				runId,
+				ref,
+				queued: true
+			});
+		} catch (error) {
+			const message = errorMessage$2(error);
+			const audit = await addHandoffAudit({
+				event: "register-pr",
+				source,
+				ref,
+				watch: watchEnabled,
+				watchId: watchId ?? null,
+				note: Boolean(input.note),
+				notificationId: notificationIdFromValue(notification),
+				review: true,
+				error: message
+			}, paths, { status: "failed" });
+			return failResult("handoff_pr_register", `Review workflow dispatch failed for ${ref}.`, {
+				changed: watchChanged || Boolean(notification),
+				id: watchId ?? notificationIdFromValue(notification),
+				watch,
+				notification,
+				audit,
+				errors: [message],
+				requires: ["workflowDispatch"]
+			});
+		}
+	}
+	const reviewRunId = reviewRunIdFromValue(review);
+	const audit = await addHandoffAudit({
+		event: "register-pr",
+		source,
+		ref,
+		watch: watchEnabled,
+		watchId: watchId ?? null,
+		note: Boolean(input.note),
+		notificationId: notificationIdFromValue(notification),
+		review: input.review === true,
+		reviewRunId
+	}, paths, reviewRunId ? { runId: reviewRunId } : {});
+	const changed = watchChanged || Boolean(notification) || Boolean(review);
+	return okResult("handoff_pr_register", changed, changed ? `Registered ${ref} from ${displaySource(source)}.` : `Registration for ${ref} was already current.`, {
+		id: watchId ?? notificationIdFromValue(notification),
+		watch,
+		notification,
+		review,
+		audit
+	});
+}
+function normalizeHandoffSource(value, fallback = "external:cli") {
+	const raw = (value?.trim() || fallback).replace(/\s+/g, "-");
+	return (/^(?:external|ci):/i.test(raw) ? raw : `external:${raw}`).slice(0, 120);
+}
+function parseHandoffInput(schema, input, action) {
+	return parseInput(schema, input, (message) => failResult(action, "Invalid handoff input.", { errors: [message] }));
+}
+async function resolveRegisteredPrLink(ref, paths) {
+	const registry = await readRepoRegistrySnapshot(paths);
+	const resolved = resolvePrReference(ref, registry);
+	if (!resolved.ok) return {
+		ok: false,
+		result: failResult("handoff_pr_reference", resolved.result.message, {
+			errors: resolved.result.errors,
+			requires: resolved.result.requires
+		})
+	};
+	const repo = registry.repos.find((item) => repoFullName(item).toLowerCase() === resolved.reference.repoFullName.toLowerCase() || item.id === resolved.reference.repoId);
+	if (!repo) return {
+		ok: false,
+		result: failResult("handoff_pr_reference", `Repository "${resolved.reference.repoFullName}" is not configured.`, { requires: ["repo"] })
+	};
+	return {
+		ok: true,
+		link: {
+			repo,
+			ref: resolved.reference
+		}
+	};
+}
+async function resolveRegisteredRepo(ref, paths) {
+	const matches = (await readRepoRegistrySnapshot(paths)).repos.filter((repo) => repo.id === ref || repo.github.name === ref || repoFullName(repo).toLowerCase() === ref.toLowerCase());
+	if (matches.length === 1) return {
+		ok: true,
+		repo: matches[0]
+	};
+	if (matches.length > 1) return {
+		ok: false,
+		result: failResult("handoff_repo_reference", `Repository "${ref}" is ambiguous.`, { requires: ["repo"] })
+	};
+	return {
+		ok: false,
+		result: failResult("handoff_repo_reference", `Repository "${ref}" is not configured.`, { requires: ["repo"] })
+	};
+}
+async function externalReviewQueueAllowed(paths) {
+	return (await readRuntimeJson(paths.config, parseAppConfig)).handoff?.allowExternalReviewQueue ?? true;
+}
+async function invokeReviewPrWorkflow(input) {
+	const { invoke } = await import("@flue/runtime");
+	return invoke((await import("./review-pr-for-human-B2j8wz2L.js")).default, { input });
+}
+async function addHandoffAudit(summary, paths, options = {}) {
+	return addWorkflowSummary({
+		workflow: "agent_handoff",
+		status: options.status ?? "completed",
+		...options.runId ? { runId: options.runId } : {},
+		summary
+	}, paths);
+}
+function okResult(action, changed, message, data = {}) {
+	return {
+		ok: true,
+		action,
+		changed,
+		message,
+		...data.id ? { id: data.id } : {},
+		deckUrl,
+		...data.watch ? { watch: asJsonValue(data.watch) } : {},
+		...data.notification ? { notification: asJsonValue(data.notification) } : {},
+		...data.release ? { release: asJsonValue(data.release) } : {},
+		...data.review ? { review: asJsonValue(data.review) } : {},
+		...data.audit ? { audit: asJsonValue(data.audit) } : {}
+	};
+}
+function failResult(action, message, data = {}) {
+	return {
+		ok: false,
+		action,
+		changed: data.changed ?? false,
+		message,
+		...data.id ? { id: data.id } : {},
+		deckUrl,
+		...data.watch ? { watch: asJsonValue(data.watch) } : {},
+		...data.notification ? { notification: asJsonValue(data.notification) } : {},
+		...data.release ? { release: asJsonValue(data.release) } : {},
+		...data.review ? { review: asJsonValue(data.review) } : {},
+		...data.audit ? { audit: asJsonValue(data.audit) } : {},
+		...data.errors ? { errors: data.errors } : {},
+		...data.requires ? { requires: data.requires } : {}
+	};
+}
+function displaySource(source) {
+	return source.replace(/^(?:external|ci):/, "");
+}
+function errorMessage$2(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+function noteSourceId(input) {
+	return createHash("sha256").update([
+		input.source,
+		input.text,
+		input.repoFullName ?? "",
+		input.prId ?? ""
+	].join("\0")).digest("hex").slice(0, 32);
+}
+function watchIdFromValue(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const id = value.id;
+	return typeof id === "string" ? id : void 0;
+}
+function notificationIdFromValue(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const id = value.id;
+	return typeof id === "string" ? id : void 0;
+}
+function reviewRunIdFromValue(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const runId = value.runId;
+	return typeof runId === "string" ? runId : void 0;
+}
+//#endregion
+//#region src/server/routes/handoff.ts
+function createHandoffRoutes(paths) {
+	const routes = new Hono();
+	routes.post("/handoff/watch-pr", async (c) => {
+		const input = await handoffBody(c);
+		if (!input.ok) return c.json(input.result, 400);
+		const body = input.body;
+		const result = await registerHandoffWatchPr({
+			ref: body.ref,
+			source: body.source,
+			desiredTerminalState: body.desiredTerminalState,
+			intervalSeconds: body.intervalSeconds
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/handoff/note", async (c) => {
+		const input = await handoffBody(c);
+		if (!input.ok) return c.json(input.result, 400);
+		const result = await createHandoffNote(input.body, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/handoff/register-pr", async (c) => {
+		const input = await handoffBody(c);
+		if (!input.ok) return c.json(input.result, 400);
+		const result = await registerHandoffPr(input.body, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	return routes;
+}
+async function handoffBody(c) {
+	const body = await safeJsonObject(c);
+	if (typeof body.source !== "string" || !body.source.trim()) return {
+		ok: false,
+		result: {
+			ok: false,
+			action: "handoff_request",
+			changed: false,
+			message: "Handoff API requests require a source field.",
+			deckUrl: "/",
+			requires: ["source"]
+		}
+	};
+	return {
+		ok: true,
+		body
+	};
+}
+//#endregion
+//#region src/server/routes/kilo.ts
+function createKiloRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/tasks", async (c) => {
+		return c.json(await listKiloTasks({
+			status: c.req.query("status"),
+			repoId: c.req.query("repoId"),
+			limit: queryNumber(c.req.query("limit")),
+			includeDiff: queryBoolean(c.req.query("includeDiff"))
+		}, paths));
+	});
+	routes.get("/results", async (c) => {
+		const result = await listKiloResultStates({
+			taskId: c.req.query("taskId") || void 0,
+			limit: queryNumber(c.req.query("limit"))
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/tasks", async (c) => {
+		const result = await startKiloTask(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/tasks/:id", async (c) => {
+		const result = await readKiloTaskStatus({ taskId: c.req.param("id") }, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.get("/tasks/:id/events", async (c) => {
+		const result = await readKiloTaskEvents({
+			taskId: c.req.param("id"),
+			limit: queryNumber(c.req.query("limit"))
+		}, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.post("/tasks/:id/abort", async (c) => {
+		const result = await abortKiloTask({ taskId: c.req.param("id") }, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/tasks/:id/sessions", async (c) => {
+		const result = await readKiloTaskSessions({ taskId: c.req.param("id") }, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.get("/tasks/:id/diff", async (c) => {
+		const result = await readKiloTaskDiff({ taskId: c.req.param("id") }, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.get("/tasks/:id/result", async (c) => {
+		const result = await listKiloResultStates({ taskId: c.req.param("id") }, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.post("/tasks/:id/review", async (c) => {
+		const result = await reviewKiloResult({ taskId: c.req.param("id") }, paths);
+		recordHandledPrApiResult(paths, "api:kilo_result_review", result);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/tasks/:id/verify", async (c) => {
+		const result = await verifyKiloResult({
+			...await safeJsonObject(c),
+			taskId: c.req.param("id")
+		}, paths);
+		recordHandledPrApiResult(paths, "api:kilo_result_verify", result);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/tasks/:id/promote", async (c) => {
+		const result = await promoteKiloResult({ taskId: c.req.param("id") }, paths);
+		recordHandledPrApiResult(paths, "api:kilo_result_promote", result);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/sessions/search", async (c) => {
+		const result = await searchKiloSessions(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/sessions/:id", async (c) => {
+		const result = await readKiloSession({
+			sessionId: c.req.param("id"),
+			...kiloSessionQuery(c)
+		}, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.get("/sessions/:id/messages", async (c) => {
+		const result = await readKiloSessionMessages({
+			sessionId: c.req.param("id"),
+			...kiloSessionQuery(c)
+		}, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.get("/sessions/:id/children", async (c) => {
+		const result = await readKiloSessionChildren({
+			sessionId: c.req.param("id"),
+			...kiloSessionQuery(c)
+		}, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.get("/sessions/:id/todos", async (c) => {
+		const result = await readUnavailableSessionAdapter({
+			sessionId: c.req.param("id"),
+			...kiloSessionQuery(c)
+		}, "todos", paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.get("/sessions/:id/diff", async (c) => {
+		const result = await readKiloSessionDiff({
+			sessionId: c.req.param("id"),
+			...kiloSessionQuery(c)
+		}, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/learning.ts
+function createLearningRoutes(paths) {
+	const routes = new Hono();
+	routes.post("/curate", async (c) => {
+		const parsed = v.safeParse(v.object({
+			mode: v.optional(v.picklist([
+				"off",
+				"review",
+				"auto"
+			])),
+			reason: v.optional(v.string())
+		}), await safeJsonBody(c));
+		if (!parsed.success) return c.json({
+			ok: false,
+			action: "learning_curate",
+			changed: false,
+			message: v.summarize(parsed.issues)
+		}, 400);
+		const receipt = await invoke(curate_learning_store_default, { input: {
+			...parsed.output,
+			trigger: "manual"
+		} });
+		return c.json({
+			ok: true,
+			action: "learning_curate",
+			changed: true,
+			runId: receipt.runId,
+			message: "Queued memory curation learning workflow."
+		});
+	});
+	routes.get("/state", async (c) => {
+		const input = {
+			limit: boundedQueryLimit(c.req.query("limit"), 25),
+			reviewKind: learningReviewKind(c.req.query("reviewKind")),
+			reviewStatus: learningReviewStatus(c.req.query("reviewStatus")),
+			candidateStatus: learningCandidateStatus(c.req.query("candidateStatus")),
+			candidateTarget: learningCandidateTarget(c.req.query("candidateTarget")),
+			memoryId: c.req.query("memoryId") || void 0
+		};
+		if (c.req.query("limit") && input.limit === void 0) return c.json({
+			ok: false,
+			action: "learning_operator_state",
+			changed: false,
+			message: `Invalid learning state limit "${c.req.query("limit")}".`
+		}, 400);
+		if (c.req.query("reviewKind") && !input.reviewKind) return c.json({
+			ok: false,
+			action: "learning_operator_state",
+			changed: false,
+			message: `Invalid review kind "${c.req.query("reviewKind")}".`
+		}, 400);
+		if (c.req.query("reviewStatus") && !input.reviewStatus) return c.json({
+			ok: false,
+			action: "learning_operator_state",
+			changed: false,
+			message: `Invalid review status "${c.req.query("reviewStatus")}".`
+		}, 400);
+		if (c.req.query("candidateStatus") && !input.candidateStatus) return c.json({
+			ok: false,
+			action: "learning_operator_state",
+			changed: false,
+			message: `Invalid candidate status "${c.req.query("candidateStatus")}".`
+		}, 400);
+		if (c.req.query("candidateTarget") && !input.candidateTarget) return c.json({
+			ok: false,
+			action: "learning_operator_state",
+			changed: false,
+			message: `Invalid candidate target "${c.req.query("candidateTarget")}".`
+		}, 400);
+		const result = await readLearningOperatorState(input, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/reviews", (c) => {
+		const kind = learningReviewKind(c.req.query("kind"));
+		const status = learningReviewStatus(c.req.query("status"));
+		const limit = boundedQueryLimit(c.req.query("limit"), 50);
+		if (c.req.query("kind") && !kind) return c.json({
+			ok: false,
+			action: "learning_review_list",
+			changed: false,
+			message: `Invalid learning review kind "${c.req.query("kind")}".`
+		}, 400);
+		if (c.req.query("status") && !status) return c.json({
+			ok: false,
+			action: "learning_review_list",
+			changed: false,
+			message: `Invalid learning review status "${c.req.query("status")}".`
+		}, 400);
+		if (c.req.query("limit") && limit === void 0) return c.json({
+			ok: false,
+			action: "learning_review_list",
+			changed: false,
+			message: `Invalid review limit "${c.req.query("limit")}".`
+		}, 400);
+		return c.json(listLearningReviews({
+			kind,
+			status,
+			limit
+		}, paths));
+	});
+	routes.post("/reviews/conversation", async (c) => {
+		const parsed = v.safeParse(v.object({
+			sessionId: v.optional(v.pipe(v.string(), v.minLength(1))),
+			reason: v.optional(v.string())
+		}), await safeJsonBody(c));
+		if (!parsed.success) return c.json({
+			ok: false,
+			action: "learning_review_conversation",
+			changed: false,
+			message: v.summarize(parsed.issues)
+		}, 400);
+		if (parsed.output.sessionId) {
+			const session = await readChatSession({
+				id: parsed.output.sessionId,
+				reason: "manual-conversation-learning-review",
+				surface: "learning"
+			}, paths);
+			if (!session.ok) return c.json(session, 400);
+		}
+		const receipt = await invoke(review_conversation_for_learning_default, { input: {
+			...parsed.output,
+			trigger: "manual"
+		} });
+		return c.json({
+			ok: true,
+			action: "learning_review_conversation",
+			changed: true,
+			runId: receipt.runId,
+			message: "Queued conversation learning review workflow."
+		});
+	});
+	routes.post("/reviews/prs", async (c) => {
+		const parsed = v.safeParse(v.object({
+			repoId: v.optional(v.pipe(v.string(), v.minLength(1))),
+			reason: v.optional(v.string()),
+			limit: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1)))
+		}), await safeJsonBody(c));
+		if (!parsed.success) return c.json({
+			ok: false,
+			action: "learning_review_pr_batch",
+			changed: false,
+			message: v.summarize(parsed.issues)
+		}, 400);
+		const receipt = await invoke(review_pr_batch_for_learning_default, { input: {
+			...parsed.output,
+			trigger: "manual"
+		} });
+		return c.json({
+			ok: true,
+			action: "learning_review_pr_batch",
+			changed: true,
+			runId: receipt.runId,
+			message: "Queued PR/autopilot learning retrospective workflow."
+		});
+	});
+	routes.get("/candidates", async (c) => {
+		const status = learningCandidateStatus(c.req.query("status"));
+		if (c.req.query("status") && !status) return c.json({
+			ok: false,
+			action: "memory_candidate_list",
+			changed: false,
+			message: `Invalid candidate status "${c.req.query("status")}".`
+		}, 400);
+		const limit = Number(c.req.query("limit") ?? "100");
+		if (c.req.query("limit") && !boundedQueryLimit(c.req.query("limit"), 100)) return c.json({
+			ok: false,
+			action: "learning_candidate_list",
+			changed: false,
+			message: `Invalid candidate limit "${c.req.query("limit")}".`
+		}, 400);
+		const boundedLimit = Number.isFinite(limit) ? limit : void 0;
+		const [memoryCandidates, skillCandidates] = await Promise.all([listMemoryCandidates({
+			status,
+			limit: boundedLimit
+		}, paths), listSkillPatchCandidates({
+			status,
+			limit: boundedLimit
+		}, paths)]);
+		return c.json({
+			ok: memoryCandidates.ok && skillCandidates.ok,
+			action: "learning_candidate_list",
+			changed: false,
+			candidates: [...memoryCandidates.candidates ?? [], ...skillCandidates.candidates ?? []],
+			memoryCandidates: memoryCandidates.candidates ?? [],
+			skillCandidates: skillCandidates.candidates ?? [],
+			fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	});
+	routes.post("/candidates/:id/approve", async (c) => {
+		const body = await safeJsonBody(c);
+		const result = await decideMemoryCandidate({
+			...body,
+			id: c.req.param("id"),
+			decision: "apply"
+		}, paths);
+		if (result.ok) return c.json(result);
+		if (!memoryCandidateWasNotFound(result)) return c.json(result, 400);
+		const skillResult = await applySkillPatchCandidate({
+			...body,
+			id: c.req.param("id")
+		}, paths);
+		return c.json(skillResult, skillResult.ok ? 200 : 400);
+	});
+	routes.post("/candidates/:id/reject", async (c) => {
+		const body = await safeJsonBody(c);
+		const result = await decideMemoryCandidate({
+			...body,
+			id: c.req.param("id"),
+			decision: "reject"
+		}, paths);
+		if (result.ok) return c.json(result);
+		if (!memoryCandidateWasNotFound(result)) return c.json(result, 400);
+		const skillResult = await rejectSkillPatchCandidate({
+			...body,
+			id: c.req.param("id")
+		}, paths);
+		return c.json(skillResult, skillResult.ok ? 200 : 400);
+	});
+	return routes;
+}
+function learningCandidateStatus(value) {
+	if (value === "proposed" || value === "applied" || value === "rejected" || value === "archived") return value;
+}
+function learningCandidateTarget(value) {
+	if (value === "memory" || value === "skill") return value;
+}
+function learningReviewKind(value) {
+	if (value === "conversation" || value === "curation" || value === "pr-batch") return value;
+}
+function learningReviewStatus(value) {
+	if (value === "running" || value === "completed" || value === "failed") return value;
+}
+function memoryCandidateWasNotFound(result) {
+	if (!result || typeof result !== "object") return false;
+	const record = result;
+	return record.message === "Memory candidate was not found." && Array.isArray(record.requires) && record.requires.includes("id");
+}
+//#endregion
+//#region src/server/routes/memory.ts
+function createMemoryRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/memories", async (c) => {
+		const rawScope = c.req.query("scope");
+		const scope = memoryScope(rawScope);
+		const key = c.req.query("key");
+		const rawStatus = c.req.query("status");
+		const status = memoryStatus(rawStatus);
+		if (rawScope && !scope) return c.json({
+			ok: false,
+			action: "memory_list",
+			changed: false,
+			message: `Invalid memory scope "${rawScope}".`
+		}, 400);
+		if (rawStatus && !status) return c.json({
+			ok: false,
+			action: "memory_list",
+			changed: false,
+			message: `Invalid memory status "${rawStatus}".`
+		}, 400);
+		return c.json(await listMemories({
+			scope,
+			key: key || void 0,
+			status,
+			includeArchived: c.req.query("includeArchived") === "true",
+			repoId: c.req.query("repoId") || void 0
+		}, paths));
+	});
+	routes.post("/memories", async (c) => {
+		return c.json(await upsertMemory(await c.req.json(), paths));
+	});
+	routes.post("/memories/:id/archive", async (c) => {
+		const result = await archiveMemory({
+			...await safeJsonBody(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/memory-events", async (c) => {
+		const limit = Number(c.req.query("limit") ?? "100");
+		return c.json(await listMemoryEvents({
+			memoryId: c.req.query("memoryId") || void 0,
+			limit: Number.isFinite(limit) ? limit : void 0
+		}, paths));
+	});
+	return routes;
+}
+function memoryScope(value) {
+	if (value === "user" || value === "local" || value === "project") return value;
+}
+function memoryStatus(value) {
+	if (value === "active" || value === "archived") return value;
+}
+//#endregion
+//#region src/server/routes/metrics.ts
+function createMetricsRoutes() {
+	const routes = new Hono();
+	routes.get("/host", async (c) => {
+		return c.json(await readHostMetrics());
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/mcp.ts
+function createMcpRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/servers", async (c) => {
+		return c.json({
+			ok: true,
+			action: "mcp_servers_list",
+			changed: false,
+			message: "Read MCP server statuses.",
+			servers: await getMcpRegistry(paths).status()
+		});
+	});
+	routes.post("/servers", async (c) => {
+		const result = await addMcpServer(await safeJsonBody(c), paths);
+		if (result.ok) {
+			const id = readIdFromResultData(result.data);
+			await getMcpRegistry(paths).refresh(id);
+		}
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.patch("/servers/:id", async (c) => {
+		const id = c.req.param("id");
+		const result = await updateMcpServer({
+			...await safeJsonObject(c),
+			id
+		}, paths);
+		if (result.ok) await getMcpRegistry(paths).refresh(id);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.delete("/servers/:id", async (c) => {
+		const body = await safeJsonObject(c);
+		const id = c.req.param("id");
+		const result = await removeMcpServer({
+			...body,
+			id,
+			confirm: body.confirm === true || c.req.query("confirm") === "true"
+		}, paths);
+		if (result.ok) await getMcpRegistry(paths).refresh(id);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/servers/:id/enable", async (c) => {
+		const id = c.req.param("id");
+		const result = await setMcpServerEnabled({ id }, true, paths);
+		if (result.ok) await getMcpRegistry(paths).refresh(id);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/servers/:id/disable", async (c) => {
+		const id = c.req.param("id");
+		const result = await setMcpServerEnabled({ id }, false, paths);
+		if (result.ok) await getMcpRegistry(paths).refresh(id);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/servers/:id/tools", async (c) => {
+		return c.json({
+			ok: true,
+			action: "mcp_tools_list",
+			changed: false,
+			message: "Read cached MCP tools.",
+			tools: await getMcpRegistry(paths).listTools(c.req.param("id"))
+		});
+	});
+	routes.post("/servers/:id/refresh", async (c) => {
+		const id = c.req.param("id");
+		if (!await getMcpRegistry(paths).refresh(id)) return c.json({
+			ok: false,
+			action: "mcp_server_refresh",
+			changed: false,
+			message: `MCP server "${id}" was not found.`,
+			requires: ["id"]
+		}, 404);
+		return c.json({
+			ok: true,
+			action: "mcp_server_refresh",
+			changed: false,
+			message: `Refreshed MCP server "${id}".`
+		});
+	});
+	routes.post("/servers/:id/login", async (c) => {
+		const body = await safeJsonObject(c);
+		const redirectUrl = typeof body.redirectUrl === "string" ? body.redirectUrl : `${requestOrigin(c)}/api/mcp/oauth/callback`;
+		const result = await startMcpOAuthLogin({
+			id: c.req.param("id"),
+			redirectUrl
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/logins/:id", async (c) => {
+		const login = await readPublicMcpOAuthLogin(c.req.param("id"), paths);
+		if (!login) return c.json({
+			ok: false,
+			action: "mcp_login_read",
+			changed: false,
+			message: "MCP OAuth login was not found."
+		}, 404);
+		return c.json({
+			ok: true,
+			action: "mcp_login_read",
+			changed: false,
+			message: `Read MCP OAuth login "${login.id}".`,
+			login
+		});
+	});
+	routes.get("/oauth/callback", async (c) => {
+		const result = await completeMcpOAuthCallback({
+			state: c.req.query("state"),
+			code: c.req.query("code"),
+			error: c.req.query("error")
+		}, paths);
+		const login = "login" in result && isRecord(result.login) ? result.login : null;
+		const serverId = login && typeof login.serverId === "string" ? login.serverId : void 0;
+		if (result.ok && serverId) await getMcpRegistry(paths).refresh(serverId);
+		return c.html(oauthCallbackHtml(result.ok, result.message), result.ok ? 200 : 400);
+	});
+	routes.post("/servers/:id/logout", async (c) => {
+		const body = await safeJsonObject(c);
+		const id = c.req.param("id");
+		const result = await logoutMcpOAuthServer({
+			id,
+			confirm: body.confirm === true
+		}, paths);
+		if (result.ok) await getMcpRegistry(paths).refresh(id);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/approvals", async (c) => {
+		return c.json({
+			ok: true,
+			action: "mcp_approvals_list",
+			changed: false,
+			message: "Read MCP approvals.",
+			approvals: await listMcpApprovals(paths, { includeResolved: c.req.query("includeResolved") === "1" })
+		});
+	});
+	routes.post("/approvals/:id/resolve", async (c) => {
+		const result = await resolveMcpApprovalWithPaths({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/audit", async (c) => {
+		return c.json({
+			ok: true,
+			action: "mcp_audit_list",
+			changed: false,
+			message: "Read MCP audit rows.",
+			audit: await listMcpAudit(paths, {
+				serverId: c.req.query("serverId") || void 0,
+				limit: queryNumber(c.req.query("limit"))
+			})
+		});
+	});
+	return routes;
+}
+function requestOrigin(c) {
+	return new URL(c.req.url).origin;
+}
+function readIdFromResultData(data) {
+	if (!isRecord(data)) return void 0;
+	const id = data.id ?? data.serverId;
+	if (typeof id === "string") return id;
+	const server = data.server;
+	return isRecord(server) && typeof server.id === "string" ? server.id : void 0;
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function oauthCallbackHtml(ok, message) {
+	const title = ok ? "MCP login complete" : "MCP login failed";
+	return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(title)}</title>
+    <style>
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: grid;
+        place-items: center;
+        background: #0a0b10;
+        color: #d7f7ff;
+        font: 14px/1.5 system-ui, sans-serif;
+      }
+      main {
+        max-width: 36rem;
+        border: 1px solid #ffffff1f;
+        padding: 24px;
+      }
+      h1 {
+        margin: 0 0 8px;
+        color: ${ok ? "#69e6ff" : "#ff4fb8"};
+        font: 600 16px/1.2 ui-monospace, SFMono-Regular, Menlo, monospace;
+      }
+      p {
+        margin: 0;
+        color: #d7f7ffb3;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>${escapeHtml(title)}</h1>
+      <p>${escapeHtml(message)}</p>
+    </main>
+  </body>
+</html>`;
+}
+function escapeHtml(value) {
+	return value.replace(/[&<>"']/g, (char) => {
+		switch (char) {
+			case "&": return "&amp;";
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			case "\"": return "&quot;";
+			default: return "&#39;";
+		}
+	});
+}
+//#endregion
+//#region src/server/routes/notifications.ts
+function createNotificationRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/", async (c) => {
+		const includeResolved = c.req.query("includeResolved") === "1";
+		return c.json({
+			items: await listNotifications(paths, { includeResolved }),
+			policy: notificationPolicy(),
+			fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	});
+	routes.post("/:id/read", async (c) => {
+		await markNotificationRead(c.req.param("id"), paths);
+		return c.json({ ok: true });
+	});
+	routes.post("/:id/resolve", async (c) => {
+		await resolveNotification(c.req.param("id"), paths);
+		return c.json({ ok: true });
+	});
+	return routes;
+}
+function notificationPolicy() {
+	return {
+		info: "Passive updates such as queued scheduled work.",
+		ready: "Completed work or green checks that can be glanced at and cleared.",
+		attention: "Actionable failures, missing configuration, blocked watches, or failed Flue work.",
+		urgent: "Release or production-facing failures that should interrupt passive viewing.",
+		reconcile: "Unresolved notifications with the same source and source id are updated in place and counted.",
+		autopilot: "Autopilot notifications use deterministic source ids by prepared diff/workflow and state: review-fix, ci-fix, verify, push-blocked, pushed, comment-result, and failed-workflow. Repeated retries reconcile in place; state changes create separate actionable records with recovery metadata.",
+		kilo: "Kilo notifications reconcile by delegated task and state: started, progress, waiting-approval, completed, failed, timed-out, needs-review, verified, promote-blocked, and promoted. Progress updates replace one task progress row; result workflow states create separate actionable records linked to the task."
+	};
+}
+//#endregion
+//#region src/server/routes/repo-edit.ts
+function createRepoEditRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/repo-edits", async (c) => {
+		return c.json(await listRepoEditEvents(paths));
+	});
+	routes.get("/repos/:repoId/status", async (c) => {
+		const result = await readRepoCheckoutStatus({ repoId: c.req.param("repoId") }, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/repos/:repoId/files/read", async (c) => {
+		const result = await readRepoFile({
+			...await safeJsonObject(c),
+			repoId: c.req.param("repoId")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/repos/:repoId/files/search", async (c) => {
+		const result = await searchRepoFiles({
+			...await safeJsonObject(c),
+			repoId: c.req.param("repoId")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/repos/:repoId/files/write/preview", async (c) => {
+		const result = await writeRepoFile({
+			...await safeJsonObject(c),
+			repoId: c.req.param("repoId"),
+			dryRun: true
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/repos/:repoId/files/write", async (c) => {
+		const result = await writeRepoFile({
+			...await safeJsonObject(c),
+			repoId: c.req.param("repoId")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/repos/:repoId/files/replace/preview", async (c) => {
+		const result = await replaceRepoFile({
+			...await safeJsonObject(c),
+			repoId: c.req.param("repoId"),
+			dryRun: true
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/repos/:repoId/files/replace", async (c) => {
+		const result = await replaceRepoFile({
+			...await safeJsonObject(c),
+			repoId: c.req.param("repoId")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/repos/:repoId/files/patch/preview", async (c) => {
+		const result = await patchRepoFiles({
+			...await safeJsonObject(c),
+			repoId: c.req.param("repoId"),
+			dryRun: true
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/repos/:repoId/files/patch", async (c) => {
+		const result = await patchRepoFiles({
+			...await safeJsonObject(c),
+			repoId: c.req.param("repoId")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/repos/:repoId/diff", async (c) => {
+		const result = await readRepoDiff({
+			...await safeJsonObject(c),
+			repoId: c.req.param("repoId")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	return routes;
+}
+//#endregion
+//#region src/modules/docs-drift/service.ts
+var neonDocsFixSkillPath = fileURLToPath(new URL("../../skills/neon-docs-fix/SKILL.md", import.meta.url));
+var docsDriftStageFixInputSchema = v.object({ reportId: nonEmptyStringSchema });
+async function stageDocsDriftFix(rawInput, paths = runtimePaths(), dependencies = {}) {
+	const parsed = parseInput(docsDriftStageFixInputSchema, rawInput, (message) => invalidInputAction("docs_drift_stage_fix", message));
+	if (!parsed.ok) return parsed.result;
+	const report = await (dependencies.readReport ?? readReport)(parsed.input.reportId, paths);
+	if (!report) return failedAction("docs_drift_stage_fix", "Docs drift report not found.", { requires: ["reportId"] });
+	if (report.kind !== "docs-drift") return failedAction("docs_drift_stage_fix", "Only docs-drift reports can stage docs fixes.", { requires: ["docsDriftReport"] });
+	const summary = docsDriftSummary(report);
+	if (!summary || summary.hits.length === 0) return failedAction("docs_drift_stage_fix", "Docs drift report has no fixable drift hits.", { requires: ["driftHits"] });
+	const repo = (await readRepoRegistrySnapshot(paths)).repos.find((candidate) => candidate.id === summary.repo);
+	if (!repo) return failedAction("docs_drift_stage_fix", `Repository "${summary.repo}" is not configured.`, { requires: ["repo"] });
+	const created = await (dependencies.createWorktree ?? createWorktree)({
+		repoId: repo.id,
+		baseRef: docsFixHeadSha(summary),
+		headSha: docsFixHeadSha(summary),
+		createdBy: "neondeck"
+	}, paths);
+	if (!created.ok || !("worktree" in created)) {
+		const result = objectConfig(created);
+		return failedAction("docs_drift_stage_fix", created.message, {
+			errors: stringArrayConfig(result.errors),
+			requires: stringArrayConfig(result.requires)
+		});
+	}
+	const taskId = `docs-drift-${randomUUID()}`;
+	try {
+		await recordDocsDriftFixTaskBoundary({
+			taskId,
+			reportId: report.id,
+			repoId: repo.id,
+			repoFullName: summary.repoFullName,
+			worktreeId: created.worktree.id,
+			allowedDocsPaths: docsFixAllowedDocsPaths(summary)
+		}, paths);
+	} catch (error) {
+		return failedAction("docs_drift_stage_fix", `Could not record docs drift fix boundary: ${errorMessage$1(error)}.`, {
+			requires: ["docsDriftBoundary"],
+			errors: [errorMessage$1(error)]
+		});
+	}
+	const learningMemoryContext = await loadAutomationLearningMemoryContext(paths, {
+		repoId: repo.id,
+		includeGlobal: true
+	});
+	const kilo = await (dependencies.startKiloTask ?? startKiloTask)({
+		taskId,
+		worktreeId: created.worktree.id,
+		title: `Docs drift fix: ${summary.repoFullName}`,
+		prompt: await docsFixPrompt(summary, report, paths, learningMemoryContext),
+		mode: "draft-fix",
+		allowAuto: true,
+		confirmAuto: true,
+		explicitUserRequest: true
+	}, paths);
+	if (!kilo.ok) {
+		const result = objectConfig(kilo);
+		return failedAction("docs_drift_stage_fix", kilo.message, {
+			errors: stringArrayConfig(result.errors),
+			requires: stringArrayConfig(result.requires)
+		});
+	}
+	const startedTaskId = "task" in kilo ? kilo.task.id : taskId;
+	await addWorkflowSummary({
+		workflow: "docs_drift_stage_fix",
+		status: "started",
+		summary: {
+			outcome: "kilo-started",
+			reportId: report.id,
+			repoId: repo.id,
+			repoFullName: summary.repoFullName,
+			kiloTaskId: startedTaskId,
+			worktreeId: created.worktree.id,
+			memoryIds: learningMemoryContext.memoryIds
+		}
+	}, paths);
+	return okAction("docs_drift_stage_fix", true, `Started docs drift fix task for ${summary.repoFullName}.`, { data: asJsonValue({
+		report: reportLink(report),
+		worktree: {
+			id: created.worktree.id,
+			path: created.worktree.localPath,
+			headSha: created.worktree.headSha,
+			targetSha: docsFixHeadSha(summary)
+		},
+		kiloTask: { id: startedTaskId }
+	}) });
+}
+function docsDriftSummary(report) {
+	const summary = objectConfig(report.summary);
+	const repo = stringConfig(summary.repo);
+	const repoFullName = stringConfig(summary.repoFullName);
+	const scannedCommit = stringConfig(summary.scannedCommit);
+	if (!repo || !repoFullName || !scannedCommit) return null;
+	const hits = Array.isArray(summary.hits) ? summary.hits.flatMap((hit) => {
+		const record = objectConfig(hit);
+		const docPath = stringConfig(record.docPath);
+		const changedPath = stringConfig(record.changedPath);
+		const status = stringConfig(record.status);
+		const excerpt = stringConfig(record.excerpt);
+		const line = typeof record.line === "number" && Number.isInteger(record.line) ? record.line : null;
+		if (!docPath || !changedPath || !status || !excerpt || line === null) return [];
+		return [{
+			docPath,
+			changedPath,
+			previousPath: stringConfig(record.previousPath),
+			status,
+			line,
+			excerpt
+		}];
+	}) : [];
+	return {
+		repo,
+		repoFullName,
+		base: stringConfig(summary.base),
+		scannedCommit,
+		attemptedCommit: stringConfig(summary.attemptedCommit),
+		truncated: Boolean(summary.truncated),
+		hits
+	};
+}
+async function docsFixPrompt(summary, report, paths, learningMemoryContext) {
+	const skill = await runtimeSkillContent("neon-docs-fix", neonDocsFixSkillPath, paths);
+	const docPaths = docsFixAllowedDocsPaths(summary);
+	return [
+		skill.trim() ? `Runtime skill neon-docs-fix:\n${skill.trim()}` : "Runtime skill neon-docs-fix was unavailable; follow the task bounds below.",
+		"",
+		`Task: update stale documentation references for ${summary.repoFullName}.`,
+		`Report: /reports/${report.id}`,
+		`Scanned commit: ${summary.scannedCommit}`,
+		summary.attemptedCommit ? `Attempted commit: ${summary.attemptedCommit}` : null,
+		summary.truncated ? "The drift scan was truncated. Fix only the listed, evidence-backed hits." : null,
+		"",
+		"Bounds:",
+		"- Edit only documentation files listed under allowedDocsPaths.",
+		"- Do not change source code, tests, generated files, package metadata, lockfiles, or runtime config.",
+		"- Keep documentation edits minimal and fact-backed by the drift hits.",
+		"- Commit local changes in this managed worktree when you make a fix.",
+		"- Never push, open a pull request, post comments, submit reviews, or mutate external systems.",
+		"",
+		learningMemoryContext.text,
+		"",
+		"Drift facts:",
+		JSON.stringify({
+			report: reportLink(report),
+			repo: summary.repo,
+			repoFullName: summary.repoFullName,
+			base: summary.base,
+			scannedCommit: summary.scannedCommit,
+			attemptedCommit: summary.attemptedCommit,
+			targetCommit: docsFixHeadSha(summary),
+			allowedDocsPaths: docPaths,
+			hits: summary.hits.slice(0, 100)
+		}, null, 2)
+	].filter((line) => line !== null).join("\n");
+}
+async function runtimeSkillContent(id, fallbackPath, paths) {
+	const loaded = await loadRuntimeSkill({ id }, paths);
+	if (loaded.ok) return loaded.skill.content;
+	return readFile(fallbackPath, "utf8").catch(() => "");
+}
+function docsFixAllowedDocsPaths(summary) {
+	return [...new Set(summary.hits.map((hit) => hit.docPath))].sort();
+}
+function docsFixHeadSha(summary) {
+	return summary.attemptedCommit ?? summary.scannedCommit;
+}
+function reportLink(report) {
+	return {
+		id: report.id,
+		title: report.title,
+		url: `/reports/${report.id}`
+	};
+}
+function stringConfig(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function stringArrayConfig(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function objectConfig(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function errorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/server/routes/reports.ts
+function createReportApiRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/reports", async (c) => {
+		const kind = c.req.query("kind")?.trim() || void 0;
+		const limitText = c.req.query("limit");
+		const limit = limitText ? Number(limitText) : void 0;
+		if (limitText && (limit === void 0 || !Number.isFinite(limit) || limit <= 0)) return c.json({
+			ok: false,
+			action: "reports_list",
+			message: "Report limit must be a positive number.",
+			items: []
+		}, 400);
+		try {
+			return c.json({
+				ok: true,
+				action: "reports_list",
+				items: await listReports(paths, {
+					kind,
+					limit
+				}),
+				fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				action: "reports_list",
+				message: error instanceof Error ? error.message : String(error),
+				items: []
+			}, 400);
+		}
+	});
+	routes.get("/reports/:id", async (c) => {
+		const id = c.req.param("id")?.trim();
+		if (!id) return c.json({
+			ok: false,
+			action: "reports_read",
+			message: "Report id is required.",
+			item: null
+		}, 400);
+		try {
+			const item = await readReport(id, paths);
+			if (!item) return c.json({
+				ok: false,
+				action: "reports_read",
+				message: "Report not found.",
+				item: null
+			}, 404);
+			return c.json({
+				ok: true,
+				action: "reports_read",
+				item,
+				fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				action: "reports_read",
+				message: error instanceof Error ? error.message : String(error),
+				item: null
+			}, 400);
+		}
+	});
+	routes.post("/reports/:id/stage-docs-fix", async (c) => {
+		const result = await stageDocsDriftFix({
+			...await safeJsonObject(c),
+			reportId: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	return routes;
+}
+function createReportFileRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/:id", async (c) => {
+		const id = c.req.param("id")?.trim();
+		if (!id) return c.text("Not found", 404);
+		try {
+			const result = await readReportHtml(id, paths);
+			if (!result) return c.text("Not found", 404);
+			return c.html(result.html, 200, {
+				"content-security-policy": "default-src 'none'; style-src 'unsafe-inline';",
+				"x-content-type-options": "nosniff"
+			});
+		} catch {
+			return c.text("Not found", 404);
+		}
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/repos.ts
+function createReposRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/", async (c) => {
+		try {
+			return c.json(await readRepoRegistrySnapshot(paths));
+		} catch (error) {
+			if (error instanceof ConfigValidationError) return c.json({
+				error: "Invalid repo registry",
+				message: error.message,
+				path: error.path
+			}, 500);
+			throw error;
+		}
+	});
+	routes.get("/health", async (c) => {
+		try {
+			return c.json(await readRepoHealthSnapshot(paths));
+		} catch (error) {
+			if (error instanceof ConfigValidationError) return c.json({
+				error: "Invalid repo registry",
+				message: error.message,
+				path: error.path
+			}, 500);
+			throw error;
+		}
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/scheduled-tasks.ts
+function createScheduledTaskRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/scheduled-tasks", async (c) => c.json(await listTaskRecords(paths)));
+	routes.post("/scheduled-tasks/briefings", async (c) => {
+		const result = await createBriefingTask(await safeJsonObject(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/scheduled-tasks/instructions", async (c) => {
+		const result = await createAgentInstructionTask(await safeJsonObject(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/scheduled-tasks/:id", async (c) => {
+		const result = await readTaskRecord(c.req.param("id"), paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.post("/scheduled-tasks/:id/pause", async (c) => {
+		const result = await setTaskEnabled(c.req.param("id"), false, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.post("/scheduled-tasks/:id/resume", async (c) => {
+		const result = await setTaskEnabled(c.req.param("id"), true, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.delete("/scheduled-tasks/:id", async (c) => {
+		if (c.req.query("confirm") !== "true") return c.json({
+			ok: false,
+			action: "scheduled_task_delete",
+			changed: false,
+			message: "Deleting a scheduled task requires confirm=true.",
+			requires: ["confirm"]
+		}, 400);
+		const result = await removeTask(c.req.param("id"), paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/runtime.ts
+function createRuntimeRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/health", (c) => c.json({
+		ok: true,
+		service: "neondeck",
+		home: paths.home,
+		uptimeSeconds: Math.round(process.uptime())
+	}));
+	routes.get("/runtime/status", async (c) => {
+		return c.json(await readRuntimeStatus(paths));
+	});
+	routes.get("/local-api/session", async (c) => {
+		return c.json({
+			ok: true,
+			action: "local_api_session_read",
+			token: await readLocalApiToken(paths),
+			header: localApiAuthHeader,
+			queryParam: localApiTokenQueryParam
+		});
+	});
+	routes.get("/autopilot/state", async (c) => {
+		return c.json(v.parse(autopilotStateSchema, await readAutopilotState(paths)));
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/safety.ts
+function createSafetyRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/policy", (c) => {
+		return c.json(readSafetyPolicy(paths));
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/scheduler-workflow.ts
+var schedulerWorkflowName = "scheduler-tick";
+var schedulerWorkflowAdmissionLeaseKey = "scheduler.tick.workflow.admission.lease";
+var defaultWorkflowWaitTimeoutMs = 300 * 1e3;
+var defaultWorkflowAdmissionLeaseTtlMs = 36e4;
+var defaultWorkflowPollMs = 250;
+var schedulerTickInFlight = /* @__PURE__ */ new Map();
+async function runObservedSchedulerTick(paths, dependencies = {}) {
+	const key = paths.home;
+	const inFlight = schedulerTickInFlight.get(key);
+	if (inFlight) return inFlight;
+	const next = runObservedSchedulerTickOnce(paths, dependencies).finally(() => {
+		schedulerTickInFlight.delete(key);
+	});
+	schedulerTickInFlight.set(key, next);
+	return next;
+}
+async function runObservedSchedulerTickOnce(paths, dependencies) {
+	await ensureRuntimeHome(paths);
+	const now = currentDate(dependencies);
+	let activeRun;
+	try {
+		activeRun = await activeSchedulerTickRun(paths, dependencies, now);
+	} catch (error) {
+		return runDirectSchedulerTickFallback(paths, error, "inspection");
+	}
+	if (activeRun) return resultFromObservedRun(paths, activeRun.runId, dependencies);
+	const admission = acquireSchedulerWorkflowAdmissionLease(paths, now, schedulerWorkflowAdmissionLeaseTtlMs(dependencies));
+	if (!admission.acquired) {
+		if (admission.lease?.runId) return resultFromObservedRun(paths, admission.lease.runId, dependencies);
+		return {
+			ok: true,
+			action: "scheduler_tick",
+			changed: false,
+			outcome: "silent",
+			message: "Scheduler tick skipped because another process is admitting the observed scheduler workflow.",
+			extra: { admissionLease: admission.lease ? "active" : "busy" }
+		};
+	}
+	try {
+		let receipt;
+		try {
+			receipt = await invokeSchedulerTickWorkflow(paths, dependencies);
+		} catch (error) {
+			return runDirectSchedulerTickFallback(paths, error, "admission");
+		}
+		recordSchedulerWorkflowAdmissionRunId(paths, admission.lease.owner, receipt.runId, currentDate(dependencies), schedulerWorkflowAdmissionLeaseTtlMs(dependencies));
+		return resultFromObservedRun(paths, receipt.runId, dependencies);
+	} finally {
+		await releaseSchedulerWorkflowAdmissionLease(paths, admission.lease.owner);
+	}
+}
+async function resultFromObservedRun(paths, runId, dependencies) {
+	try {
+		return resultFromTerminalRun(runId, await waitForRun(runId, dependencies));
+	} catch (error) {
+		return runDirectSchedulerTickFallback(paths, error, "inspection");
+	}
+}
+async function runDirectSchedulerTickFallback(paths, error, phase) {
+	const message = errorMessage(error);
+	const fallback = await runSchedulerTick(paths);
+	await addNotification({
+		level: "attention",
+		title: "Scheduler workflow observation failed",
+		message: `Scheduler tick workflow ${phase} failed; ran the direct scheduler tick instead. ${message}`,
+		source: "scheduler",
+		sourceId: "scheduler-tick:workflow-observation-fallback",
+		data: {
+			phase,
+			error: message,
+			fallbackOutcome: fallback.outcome ?? null
+		}
+	}, paths);
+	return {
+		...fallback,
+		changed: true,
+		message: `Scheduler tick workflow ${phase} failed; ran direct scheduler tick instead. ${fallback.message}`,
+		extra: {
+			...objectField(fallback.extra),
+			workflowObservationFallback: true,
+			workflowObservationPhase: phase,
+			...phase === "admission" ? {
+				workflowAdmissionFailed: true,
+				workflowAdmissionError: message
+			} : {
+				workflowInspectionFailed: true,
+				workflowInspectionError: message
+			}
+		}
+	};
+}
+function resultFromTerminalRun(runId, run) {
+	if (!run || run.status === "active") return {
+		ok: false,
+		action: "scheduler_tick",
+		changed: false,
+		outcome: "failed",
+		message: `Scheduler tick workflow ${runId} did not complete within ${defaultWorkflowWaitTimeoutMs}ms.`,
+		errors: ["scheduler-tick workflow timed out"],
+		extra: {
+			runId,
+			activeWorkflow: true
+		},
+		runId
+	};
+	if (run.status === "errored") return {
+		ok: false,
+		action: "scheduler_tick",
+		changed: false,
+		outcome: "failed",
+		message: `Scheduler tick workflow ${runId} failed: ${errorMessage(run.error)}.`,
+		errors: [errorMessage(run.error)],
+		extra: { runId },
+		runId
+	};
+	return {
+		...schedulerResultFromRun(run.result),
+		runId
+	};
+}
+function startSchedulerObservedLoop(paths, intervalMs = 6e4, runTick = runObservedSchedulerTick) {
+	let tickInFlight = false;
+	const timer = setInterval(() => {
+		if (tickInFlight) return;
+		tickInFlight = true;
+		runTick(paths).catch((error) => {
+			console.error("[neondeck] scheduler observed tick failed", error);
+		}).finally(() => {
+			tickInFlight = false;
+		});
+	}, intervalMs);
+	timer.unref?.();
+	return timer;
+}
+async function invokeSchedulerTickWorkflow(paths, dependencies) {
+	if (dependencies.invokeWorkflow) return dependencies.invokeWorkflow(paths);
+	return invoke(scheduler_tick_default, { input: { runtimeHome: paths.home } });
+}
+async function activeSchedulerTickRun(paths, dependencies, now) {
+	const active = await (dependencies.listRuns ?? listRuns)({
+		workflowName: schedulerWorkflowName,
+		status: "active",
+		limit: 50
+	});
+	for (const pointer of active.runs) {
+		const run = await (dependencies.getRun ?? getRun)(pointer.runId);
+		if (!run || run.status !== "active") continue;
+		if (runRuntimeHome(run) !== paths.home) continue;
+		if (isStaleActiveRun(run, now, activeRunTtlMs(dependencies))) continue;
+		return run;
+	}
+	return null;
+}
+async function waitForRun(runId, dependencies) {
+	const deadline = Date.now() + (dependencies.waitTimeoutMs ?? defaultWorkflowWaitTimeoutMs);
+	let run = null;
+	while (Date.now() < deadline) {
+		run = await (dependencies.getRun ?? getRun)(runId);
+		if (run && run.status !== "active") return run;
+		await (dependencies.sleep ?? sleep)(dependencies.pollMs ?? defaultWorkflowPollMs);
+	}
+	return run;
+}
+function schedulerResultFromRun(result) {
+	const record = objectField(result);
+	if (typeof record.ok === "boolean" && typeof record.message === "string") return record;
+	return {
+		ok: false,
+		action: "scheduler_tick",
+		changed: false,
+		outcome: "failed",
+		message: "Scheduler tick workflow returned an invalid result.",
+		errors: ["invalid scheduler-tick workflow result"]
+	};
+}
+function objectField(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function runRuntimeHome(run) {
+	const input = objectField(run.input);
+	return typeof input.runtimeHome === "string" && input.runtimeHome ? input.runtimeHome : null;
+}
+function acquireSchedulerWorkflowAdmissionLease(paths, now, ttlMs) {
+	const database = new DatabaseSync(paths.neondeckDatabase);
+	try {
+		database.exec("BEGIN IMMEDIATE;");
+		const existingLease = parseSchedulerWorkflowAdmissionLease(readMetadataValue(database.prepare("SELECT value FROM app_metadata WHERE key = ?;").get(schedulerWorkflowAdmissionLeaseKey)));
+		if (existingLease && existingLease.runtimeHome === paths.home && Date.parse(existingLease.expiresAt) > now.getTime()) {
+			database.exec("COMMIT;");
+			return {
+				acquired: false,
+				lease: existingLease
+			};
+		}
+		const acquiredAt = now.toISOString();
+		const lease = {
+			owner: `pid-${process.pid}-${randomUUID()}`,
+			runtimeHome: paths.home,
+			acquiredAt,
+			expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+			runId: null
+		};
+		database.prepare(`
+        INSERT INTO app_metadata (key, value, updated_at)
+        VALUES (?, ?, ?)
+        ON CONFLICT(key) DO UPDATE SET
+          value = excluded.value,
+          updated_at = excluded.updated_at;
+      `).run(schedulerWorkflowAdmissionLeaseKey, JSON.stringify(lease), acquiredAt);
+		database.exec("COMMIT;");
+		return {
+			acquired: true,
+			lease
+		};
+	} catch (error) {
+		rollbackQuietly(database);
+		if (isSqliteBusy(error)) return {
+			acquired: false,
+			lease: null
+		};
+		throw error;
+	} finally {
+		database.close();
+	}
+}
+function recordSchedulerWorkflowAdmissionRunId(paths, owner, runId, now, ttlMs) {
+	const database = new DatabaseSync(paths.neondeckDatabase);
+	try {
+		database.exec("BEGIN IMMEDIATE;");
+		const existingLease = parseSchedulerWorkflowAdmissionLease(readMetadataValue(database.prepare("SELECT value FROM app_metadata WHERE key = ?;").get(schedulerWorkflowAdmissionLeaseKey)));
+		if (existingLease?.owner !== owner) {
+			database.exec("COMMIT;");
+			return false;
+		}
+		const updatedLease = {
+			...existingLease,
+			runId,
+			expiresAt: new Date(now.getTime() + ttlMs).toISOString()
+		};
+		database.prepare(`
+        UPDATE app_metadata
+        SET value = ?, updated_at = ?
+        WHERE key = ?;
+      `).run(JSON.stringify(updatedLease), now.toISOString(), schedulerWorkflowAdmissionLeaseKey);
+		database.exec("COMMIT;");
+		return true;
+	} catch (error) {
+		rollbackQuietly(database);
+		if (isSqliteBusy(error)) return false;
+		throw error;
+	} finally {
+		database.close();
+	}
+}
+async function releaseSchedulerWorkflowAdmissionLease(paths, owner) {
+	const maxAttempts = 5;
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+		if (releaseSchedulerWorkflowAdmissionLeaseOnce(paths, owner)) return;
+		if (attempt < maxAttempts) await sleep(25 * attempt);
+	}
+	console.warn("[neondeck] scheduler workflow admission lease release was blocked by SQLite; lease will expire automatically.");
+	try {
+		await addNotification({
+			level: "attention",
+			title: "Scheduler workflow lease release blocked",
+			message: "Scheduler workflow admission lease release was blocked by SQLite; future observed ticks may wait for the lease TTL before retrying.",
+			source: "scheduler",
+			sourceId: "scheduler-tick:workflow-admission-lease-release",
+			data: { owner }
+		}, paths);
+	} catch (error) {
+		console.warn("[neondeck] failed to persist scheduler workflow lease release warning", error);
+	}
+}
+function releaseSchedulerWorkflowAdmissionLeaseOnce(paths, owner) {
+	const database = new DatabaseSync(paths.neondeckDatabase);
+	try {
+		database.exec("BEGIN IMMEDIATE;");
+		if (parseSchedulerWorkflowAdmissionLease(readMetadataValue(database.prepare("SELECT value FROM app_metadata WHERE key = ?;").get(schedulerWorkflowAdmissionLeaseKey)))?.owner === owner) database.prepare("DELETE FROM app_metadata WHERE key = ?;").run(schedulerWorkflowAdmissionLeaseKey);
+		database.exec("COMMIT;");
+		return true;
+	} catch (error) {
+		rollbackQuietly(database);
+		if (isSqliteBusy(error)) return false;
+		throw error;
+	} finally {
+		database.close();
+	}
+}
+function parseSchedulerWorkflowAdmissionLease(value) {
+	if (!value) return;
+	try {
+		const parsed = objectField(JSON.parse(value));
+		if (typeof parsed.owner === "string" && typeof parsed.runtimeHome === "string" && typeof parsed.acquiredAt === "string" && typeof parsed.expiresAt === "string") return {
+			owner: parsed.owner,
+			runtimeHome: parsed.runtimeHome,
+			acquiredAt: parsed.acquiredAt,
+			expiresAt: parsed.expiresAt,
+			runId: typeof parsed.runId === "string" ? parsed.runId : null
+		};
+	} catch {
+		return;
+	}
+}
+function isStaleActiveRun(run, now, ttlMs) {
+	const startedAt = Date.parse(run.startedAt);
+	return Number.isFinite(startedAt) && startedAt + ttlMs <= now.getTime();
+}
+function schedulerWorkflowAdmissionLeaseTtlMs(dependencies) {
+	return dependencies.admissionLeaseTtlMs ?? defaultWorkflowAdmissionLeaseTtlMs;
+}
+function activeRunTtlMs(dependencies) {
+	return dependencies.activeRunTtlMs ?? defaultWorkflowWaitTimeoutMs;
+}
+function currentDate(dependencies) {
+	return dependencies.now?.() ?? /* @__PURE__ */ new Date();
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function sleep(milliseconds) {
+	return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+//#endregion
+//#region src/server/routes/scheduler.ts
+function createSchedulerRoutes(paths) {
+	const routes = new Hono();
+	routes.post("/scheduler/tick", async (c) => {
+		return c.json(await runObservedSchedulerTick(paths));
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/sessions.ts
+function createSessionRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/session", async (c) => {
+		return c.json(await readNeonSessionState(paths, c.req.query("surface")));
+	});
+	routes.get("/sessions", async (c) => {
+		return c.json(await listChatSessions({
+			includeArchived: c.req.query("includeArchived") === "1",
+			kind: sessionKind(c.req.query("kind")),
+			surface: c.req.query("surface") || void 0
+		}, paths));
+	});
+	routes.post("/sessions/search", async (c) => {
+		const result = await searchChatSessions(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/sessions", async (c) => {
+		const result = await createChatSession(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/sessions/:id", async (c) => {
+		const result = await readChatSession({
+			id: c.req.param("id"),
+			surface: c.req.query("surface") || void 0,
+			reason: c.req.query("reason") || void 0
+		}, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.get("/sessions/:id/messages", async (c) => {
+		const rawLimit = Number(c.req.query("limit"));
+		const result = await readChatSessionMessages({
+			id: c.req.param("id"),
+			cursor: c.req.query("cursor") || void 0,
+			limit: Number.isFinite(rawLimit) ? rawLimit : void 0,
+			surface: c.req.query("surface") || void 0,
+			reason: c.req.query("reason") || void 0,
+			explicitUserRequest: c.req.query("explicitUserRequest") === "1"
+		}, paths);
+		return c.json(result, result.ok ? 200 : "requires" in result ? 400 : 404);
+	});
+	routes.get("/sessions/:id/command-events", async (c) => {
+		const rawLimit = Number(c.req.query("limit"));
+		const result = await listChatSessionCommandEvents({
+			sessionId: c.req.param("id"),
+			limit: Number.isFinite(rawLimit) ? rawLimit : void 0
+		}, paths);
+		return c.json(result, result.ok ? 200 : 404);
+	});
+	routes.post("/sessions/:id/command-events", async (c) => {
+		const result = await createChatSessionCommandEvent({
+			...await safeJsonObject(c),
+			sessionId: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/sessions/:id/command-events/:eventId", async (c) => {
+		const result = await updateChatSessionCommandEvent({
+			...await safeJsonObject(c),
+			sessionId: c.req.param("id"),
+			eventId: c.req.param("eventId")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/sessions/:id/summary/refresh", async (c) => {
+		const result = await refreshChatSessionSummary({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/sessions/:id/reference", async (c) => {
+		const result = await referenceChatSession({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/sessions/:id/switch", async (c) => {
+		const result = await switchChatSession({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/sessions/:id/rename", async (c) => {
+		const result = await renameChatSession({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/sessions/:id/pin", async (c) => {
+		const result = await pinChatSession({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/sessions/:id/archive", async (c) => {
+		const result = await archiveChatSession({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/sessions/:id/restore", async (c) => {
+		const result = await restoreChatSession({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/sessions/:id/link-context", async (c) => {
+		const result = await linkChatSessionContext({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	return routes;
+}
+function sessionKind(value) {
+	if (value === "main" || value === "scratch" || value === "general" || value === "repo" || value === "watch" || value === "task" || value === "briefing") return value;
+}
+//#endregion
+//#region src/server/routes/skills.ts
+function createSkillRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/patches", async (c) => {
+		const status = learningCandidateStatus(c.req.query("status"));
+		if (c.req.query("status") && !status) return c.json({
+			ok: false,
+			action: "skill_patch_list",
+			changed: false,
+			message: `Invalid candidate status "${c.req.query("status")}".`
+		}, 400);
+		if (c.req.query("limit") && !boundedQueryLimit(c.req.query("limit"), 100)) return c.json({
+			ok: false,
+			action: "skill_patch_list",
+			changed: false,
+			message: `Invalid patch limit "${c.req.query("limit")}".`
+		}, 400);
+		return c.json(await listSkillPatchCandidates({
+			status,
+			skillId: c.req.query("skillId") || void 0,
+			limit: boundedQueryLimit(c.req.query("limit"), 100)
+		}, paths));
+	});
+	routes.post("/patches/:id/apply", async (c) => {
+		const result = await applySkillPatchCandidate({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/patches/:id/reject", async (c) => {
+		const result = await rejectSkillPatchCandidate({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/patches/:id/restore", async (c) => {
+		const result = await restoreSkillPatchCandidate({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/", async (c) => {
+		return c.json(await listRuntimeSkills(paths));
+	});
+	routes.get("/:id", async (c) => {
+		const result = await loadRuntimeSkill({ id: c.req.param("id") }, paths);
+		if (!result.ok) return c.json(result, 404);
+		return c.json(result);
+	});
+	routes.post("/reload", async (c) => {
+		return c.json(await reloadRuntimeSkills(paths));
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/watches.ts
+function createWatchRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/watches", async (c) => {
+		return c.json(await listPrWatches(paths));
+	});
+	routes.post("/watches", async (c) => {
+		const result = await addPrWatch(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/watches/events/watermarks", async (c) => {
+		return c.json(await listPrWatchEventWatermarks({ watchId: c.req.query("watchId") || void 0 }, paths));
+	});
+	routes.get("/watches/:id/events/watermarks", async (c) => {
+		return c.json(await listPrWatchEventWatermarks({ watchId: c.req.param("id") }, paths));
+	});
+	routes.post("/watches/:id/events/refresh", async (c) => {
+		const result = await refreshPrWatchEventState({
+			...await safeJsonObject(c),
+			watchId: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/watches/ref", async (c) => {
+		return c.json(await listRefWatches(paths));
+	});
+	routes.post("/watches/ref", async (c) => {
+		const result = await addRefWatch(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/watches/:id/polling", async (c) => {
+		const result = await setPrWatchPolling({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/watches/:id", async (c) => {
+		const result = await removePrWatch({
+			...await safeJsonObject(c),
+			id: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/workflows.ts
+function createWorkflowRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/summaries", async (c) => {
+		return c.json({
+			items: await listWorkflowSummaries(paths),
+			fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	});
+	routes.get("/observability", async (c) => {
+		return c.json(await readWorkflowObservability(paths));
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/routes/worktrees.ts
+function createWorktreeRoutes(paths) {
+	const routes = new Hono();
+	routes.get("/worktrees", async (c) => {
+		return c.json(await listWorktrees(paths));
+	});
+	routes.post("/worktrees", async (c) => {
+		const result = await createWorktree(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.get("/worktrees/:id/status", async (c) => {
+		const result = await readWorktreeStatus({ worktreeId: c.req.param("id") }, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/worktrees/:id/sync", async (c) => {
+		const result = await syncWorktree({
+			...await safeJsonObject(c),
+			worktreeId: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/worktrees/:id/lock", async (c) => {
+		const result = await lockWorktree({
+			...await safeJsonObject(c),
+			worktreeId: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/worktree-locks/:id/release", async (c) => {
+		const result = await releaseWorktreeLock({
+			...await safeJsonObject(c),
+			lockId: c.req.param("id")
+		}, paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	routes.post("/worktrees/cleanup", async (c) => {
+		const result = await cleanupWorktrees(await safeJsonBody(c), paths);
+		return c.json(result, result.ok ? 200 : 400);
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/create-app.ts
+async function createApp(options = {}) {
+	const paths = options.paths ?? runtimePaths();
+	process.env.NEONDECK_HOME = paths.home;
+	ensureRuntimeHomeSync(paths);
+	loadNeondeckEnv(paths);
+	const providerConfig = readProviderConfigSync(paths);
+	for (const provider of providerRuntimeRegistrations(process.env, providerConfig)) registerProvider(provider.id, provider.registration);
+	const app = new Hono();
+	const staticRoot = options.staticRoot ?? resolveStaticRoot();
+	await ensureRuntimeHome(paths);
+	installFlueExecutionContextTracker();
+	installFlueObservationHandlers(paths);
+	if (options.scheduler !== false && process.env.NEONDECK_DISABLE_SCHEDULER !== "1") startSchedulerObservedLoop(paths);
+	await getMcpRegistry(paths).start();
+	app.use("/api/*", requireLocalApiAccess);
+	app.use("/reports/*", requireLocalApiAccess);
+	app.route("/api", createRuntimeRoutes(paths));
+	app.route("/api/events", createConfigEventRoutes());
+	app.route("/api/events", createNotificationEventRoutes());
+	app.route("/api/events", createSessionEventRoutes());
+	app.route("/api/safety", createSafetyRoutes(paths));
+	app.route("/api/execution", createExecutionRoutes(paths));
+	app.route("/api", createSessionRoutes(paths));
+	app.route("/api", createConfigRoutes(paths));
+	app.route("/api/metrics", createMetricsRoutes());
+	app.route("/api/mcp", createMcpRoutes(paths));
+	app.route("/api/repos", createReposRoutes(paths));
+	app.route("/api", createRepoEditRoutes(paths));
+	app.route("/api", createWorktreeRoutes(paths));
+	app.route("/api/kilo", createKiloRoutes(paths));
+	app.route("/api", createAutopilotRoutes(paths));
+	app.route("/api", createHandoffRoutes(paths));
+	app.route("/api", createWatchRoutes(paths));
+	app.route("/api", createSchedulerRoutes(paths));
+	app.route("/api", createScheduledTaskRoutes(paths));
+	app.route("/api/notifications", createNotificationRoutes(paths));
+	app.route("/api", createMemoryRoutes(paths));
+	app.route("/api/learning", createLearningRoutes(paths));
+	app.route("/api/skills", createSkillRoutes(paths));
+	app.route("/api/commands", createCommandRoutes());
+	app.route("/api", createReportApiRoutes(paths));
+	app.route("/api/workflows", createWorkflowRoutes(paths));
+	app.route("/api/github", createGitHubRoutes(paths));
+	app.use("/api/flue/agents/display-assistant/*", displayAssistantLearningMiddleware(paths));
+	const requireRunInspection = requireFlueRunInspectionToken(paths);
+	app.use("/api/flue/runs", requireRunInspection);
+	app.use("/api/flue/runs/*", requireRunInspection);
+	app.route("/api/flue", flue());
+	app.route("/reports", createReportFileRoutes(paths));
+	app.use("/assets/*", (0, import_serve_static.serveStatic)({ root: staticRoot }));
+	app.get("/manifest.webmanifest", (0, import_serve_static.serveStatic)({
+		root: staticRoot,
+		path: "manifest.webmanifest"
+	}));
+	app.use("/icons/*", (0, import_serve_static.serveStatic)({ root: staticRoot }));
+	app.get("/favicon.svg", (0, import_serve_static.serveStatic)({
+		root: staticRoot,
+		path: "favicon.svg"
+	}));
+	app.get("*", (0, import_serve_static.serveStatic)({
+		root: staticRoot,
+		path: "index.html"
+	}));
+	return app;
+}
+function resolveStaticRoot(env = process.env) {
+	const candidates = [
+		env.NEONDECK_STATIC_ROOT,
+		fileURLToPath(new URL("../../web/dist", import.meta.url)),
+		fileURLToPath(new URL("../web/dist", import.meta.url)),
+		"./web/dist"
+	].filter((value) => Boolean(value));
+	return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+//#endregion
+//#region src/server/app.ts
+var app_default = await createApp();
+//#endregion
+export { app_default as default };
+
+//# sourceMappingURL=app-BuuvLo98.js.map