neondeck 1.0.0-beta.10

package/dist/assets/briefings-DuApznpN.js

@@ -0,0 +1,1596 @@
+import { Bn as listScheduledTasks, Ci as readChatSession, Di as createChatSession, Ea as listNotifications, Fi as updateChatSessionCommandEvent, Hn as readScheduledTask, Ja as runtimePaths, Kn as nextOccurrence, Li as publishSessionEvent, O as createCiFailureDossierReport, Ta as addNotification, Va as ensureRuntimeHome, Xa as asJsonValue, Ya as openDb, ea as readRepoRegistrySnapshot, gi as fetchGitHubLogin, ia as listWorktrees, o as readAutopilotState, oi as fetchPullRequestQueue, pa as listPreparedDiffs, qn as validateAutomationTrigger, yn as listPrWatchRecords } from "./autopilot-B8lfWyA1.js";
+import { l as startPrReview } from "./pr-reviews-BtJ5cm5P.js";
+import { defineAction, dispatch } from "@flue/runtime";
+import { randomUUID } from "node:crypto";
+import * as v from "valibot";
+//#region src/modules/briefings/schemas.ts
+var defaultBriefingProfileId = "morning";
+var defaultBriefingInstructions = "Summarize what needs my attention today. Prioritize review requests, failing checks, blocked automation, and time-sensitive follow-up. Keep the briefing concise and distinguish observed facts from inference.";
+var defaultBriefingSchedule = "0 8 * * 1-5";
+var nonEmptyStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));
+var timezoneSchema = v.pipe(nonEmptyStringSchema, v.check((value) => {
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone: value });
+		return true;
+	} catch {
+		return false;
+	}
+}, "Timezone must be a valid IANA timezone."));
+var briefingProfileUpdateSchema = v.object({
+	id: v.optional(v.pipe(nonEmptyStringSchema, v.maxLength(64))),
+	name: v.optional(v.pipe(nonEmptyStringSchema, v.maxLength(96))),
+	enabled: v.optional(v.boolean()),
+	instructions: v.optional(v.pipe(nonEmptyStringSchema, v.maxLength(8e3))),
+	schedule: v.optional(v.pipe(nonEmptyStringSchema, v.maxLength(160))),
+	timezone: v.optional(timezoneSchema)
+});
+var briefingRunNowSchema = v.object({
+	profileId: v.optional(v.pipe(nonEmptyStringSchema, v.maxLength(64))),
+	sessionId: v.optional(nonEmptyStringSchema),
+	commandEventId: v.optional(nonEmptyStringSchema),
+	trigger: v.optional(v.picklist(["manual", "dashboard"]))
+});
+var briefingWorkflowInputSchema = v.object({
+	profileId: v.optional(v.pipe(nonEmptyStringSchema, v.maxLength(64))),
+	taskId: v.optional(nonEmptyStringSchema),
+	sessionId: v.optional(nonEmptyStringSchema),
+	commandEventId: v.optional(nonEmptyStringSchema),
+	trigger: v.optional(v.picklist([
+		"manual",
+		"scheduled",
+		"dashboard"
+	]))
+});
+var briefingSnapshotSchema = v.object({
+	version: v.literal(1),
+	collectedAt: nonEmptyStringSchema,
+	byteSize: v.pipe(v.number(), v.integer(), v.minValue(0)),
+	truncated: v.boolean(),
+	sources: v.record(v.string(), v.object({
+		status: v.picklist([
+			"ok",
+			"partial",
+			"unavailable"
+		]),
+		fetchedAt: nonEmptyStringSchema,
+		truncated: v.boolean(),
+		error: v.optional(v.string()),
+		data: v.nullable(v.unknown())
+	}))
+});
+//#endregion
+//#region src/modules/commands/summaries.ts
+function compactCommandSummary(result) {
+	if (result.command === "review-queue" && result.data && typeof result.data === "object") {
+		const data = result.data;
+		return {
+			ok: result.ok,
+			command: result.command,
+			input: result.input,
+			status: result.status,
+			message: result.message,
+			fetchedAt: data.fetchedAt,
+			login: data.login,
+			repos: data.repos,
+			count: data.count,
+			truncated: data.truncated,
+			issues: data.issues,
+			triage: data.triage,
+			topActions: data.topActions
+		};
+	}
+	return result;
+}
+function completedCommand(command, input, message, data) {
+	return {
+		ok: true,
+		command,
+		input,
+		status: "completed",
+		message,
+		data: asJsonValue(data)
+	};
+}
+function runningCommand(command, input, message, data) {
+	return {
+		ok: true,
+		command,
+		input,
+		status: "running",
+		message,
+		data: asJsonValue(data)
+	};
+}
+function needsConfigCommand(command, input, message, details) {
+	return {
+		ok: false,
+		command,
+		input,
+		status: "needs-config",
+		message,
+		...details.errors ? { errors: details.errors } : {},
+		...details.requires ? { requires: details.requires } : {}
+	};
+}
+function failedCommand(command, input, message, details = {}) {
+	return {
+		ok: false,
+		command,
+		input,
+		status: "failed",
+		message,
+		...details.errors ? { errors: details.errors } : {},
+		...details.requires ? { requires: details.requires } : {},
+		...details.data ? { data: asJsonValue(details.data) } : {}
+	};
+}
+//#endregion
+//#region src/modules/commands/utils.ts
+var allThinkingLevels = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+function supportedReasoningLevelsForModel(model) {
+	const specifier = parseModelSpecifier(model);
+	if (!specifier) return ["off"];
+	if (specifier.provider === "openai") return isOpenAiReasoningModel(specifier.model) ? allThinkingLevels : ["off"];
+	if (specifier.provider === "anthropic") return isAnthropicReasoningModel(specifier.model) ? allThinkingLevels : ["off"];
+	if (specifier.provider === "kilocode") return isKilocodeReasoningModel(specifier.model) ? allThinkingLevels : ["off"];
+	return ["off"];
+}
+function parseModelSpecifier(model) {
+	const slash = model.indexOf("/");
+	if (slash <= 0 || slash === model.length - 1) return null;
+	return {
+		provider: model.slice(0, slash),
+		model: model.slice(slash + 1)
+	};
+}
+function isOpenAiReasoningModel(model) {
+	return /^(gpt-5|o[1-9])(?:[.-]|$)/i.test(model);
+}
+function isAnthropicReasoningModel(model) {
+	return /^claude-(?:.*-4|3-7)(?:[.-]|$)/i.test(model);
+}
+function isKilocodeReasoningModel(model) {
+	const nested = parseModelSpecifier(model);
+	if (nested?.provider === "openai") return isOpenAiReasoningModel(nested.model);
+	if (nested?.provider === "anthropic") return isAnthropicReasoningModel(nested.model);
+	return /^kilo-auto(?:\/|$)/i.test(model) || isOpenAiReasoningModel(model) || isAnthropicReasoningModel(model) || /(?:^|\/)(deepseek-r1|qwen.*thinking|.*reasoning.*)(?:[/:.-]|$)/i.test(model);
+}
+function formatList(values) {
+	if (values.length === 0) return "no";
+	if (values.length === 1) return values[0] ?? "";
+	return `${values.slice(0, -1).join(", ")} or ${values.at(-1)}`;
+}
+function isMemoryScope(value) {
+	return value === "user" || value === "local" || value === "project";
+}
+function isActiveMemoryScope(value) {
+	return value === "user" || value === "local" || value === "project";
+}
+function parseMemoryValue(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return raw;
+	}
+}
+function readStringArrayProperty(value, key) {
+	if (!value || typeof value !== "object" || !(key in value)) return void 0;
+	const property = value[key];
+	if (!Array.isArray(property)) return void 0;
+	return property.filter((item) => typeof item === "string");
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/modules/commands/handlers/queue.ts
+async function reviewQueueCommand(command, paths, dependencies) {
+	const queue = await readReviewQueue(paths, dependencies);
+	if (!queue.ok) return needsConfigCommand(command.name, command.raw, queue.message, {
+		requires: queue.requires,
+		errors: queue.errors
+	});
+	const watches = await listPrWatchRecords(paths);
+	const triage = triageReviewQueue(queue.queue, watches);
+	return completedCommand(command.name, command.raw, reviewQueueMessage(triage), {
+		fetchedAt: queue.queue.fetchedAt,
+		login: queue.queue.login,
+		repos: queue.queue.repos,
+		count: queue.queue.items.length,
+		truncated: queue.queue.truncated,
+		issues: queue.queue.issues,
+		items: queue.queue.items,
+		triage,
+		topActions: triage.topActions
+	});
+}
+async function reviewPrCommand(command, paths, dependencies) {
+	const ref = command.args.join(" ").trim();
+	if (!ref) return failedCommand(command.name, command.raw, "/review-pr requires a PR reference.", { requires: ["ref"] });
+	const { review, reviewId, runId } = await (dependencies.startPrReview ?? startPrReview)({
+		ref,
+		origin: "chat"
+	}, paths, dependencies.invokeReviewPrWorkflow ? { invokeWorkflow: (input) => dependencies.invokeReviewPrWorkflow({
+		ref: input.ref,
+		reviewId: input.reviewId,
+		attemptId: input.attemptId
+	}) } : void 0);
+	return runningCommand(command.name, command.raw, `Reviewing ${review.repoFullName}#${review.prNumber}.`, {
+		workflow: "review-pr-for-human",
+		reviewId,
+		runId,
+		ref: review.ref,
+		queued: true,
+		reviewUrl: review.reviewUrl,
+		trustBoundary: review.trustBoundary,
+		assistantBrief: "Track the durable review record. It will transition to ready with report links and local draft counts; the human reviewer owns edits and submission."
+	});
+}
+async function fixCiCommand(command, paths, dependencies) {
+	const explicitRef = command.args.join(" ").trim();
+	if (explicitRef) {
+		const parsed = parsePullRequestRef(explicitRef);
+		if (!parsed) return failedCommand(command.name, command.raw, "Expected a PR reference like repo#123, owner/repo#123, or a GitHub pull request URL.", { requires: ["pr"] });
+		return queueFixCiWorkflow(command, `${parsed.repo}#${parsed.number}`, dependencies);
+	}
+	const queue = await readReviewQueue(paths, dependencies);
+	if (!queue.ok) return needsConfigCommand(command.name, command.raw, queue.message, {
+		requires: queue.requires,
+		errors: queue.errors
+	});
+	const selected = selectPullRequest(queue.queue, command.args, { prefer: isCiFixCandidate });
+	if (!selected.ok) return failedCommand(command.name, command.raw, selected.message, {
+		requires: selected.requires,
+		data: { available: summarizePullRequests(queue.queue.items).slice(0, 10) }
+	});
+	if (!isCiFixCandidate(selected.item)) return failedCommand(command.name, command.raw, `${selected.item.repo}#${selected.item.number} does not have failing or unknown CI checks.`, {
+		requires: ["failingChecks"],
+		data: { pr: summarizePullRequests([selected.item])[0] }
+	});
+	return queueFixCiWorkflow(command, `${selected.item.repo}#${selected.item.number}`, dependencies);
+}
+async function queueFixCiWorkflow(command, ref, dependencies) {
+	const { runId } = await (dependencies.invokeFixCiWorkflow ?? invokeFixCiWorkflow)({ ref });
+	return completedCommand(command.name, command.raw, `Queued CI fix workflow ${runId} for ${ref}.`, {
+		workflow: "fix-pr-ci",
+		runId,
+		ref,
+		queued: true,
+		reportUrlHint: "/reports",
+		trustBoundary: "The workflow can create local reports, a managed local worktree, a Kilo task, and a prepared diff only; it does not push, comment, or submit a GitHub review.",
+		assistantBrief: "Track the returned workflow run id. The dossier report is local; any code changes must pass through the prepared-diff review loop."
+	});
+}
+async function invokeFixCiWorkflow(input) {
+	const { invoke } = await import("@flue/runtime");
+	return invoke((await import("./fix-pr-ci-P3dLxmbx.js")).default, { input });
+}
+async function explainCiCommand(command, paths, dependencies) {
+	const options = parseExplainCiArgs(command.args);
+	const queue = await readReviewQueue(paths, dependencies);
+	if (!queue.ok) return needsConfigCommand(command.name, command.raw, queue.message, {
+		requires: queue.requires,
+		errors: queue.errors
+	});
+	const selected = selectPullRequest(queue.queue, options.args, { prefer: (item) => item.checks?.status === "failure" || item.checkError !== void 0 || item.checks?.status === "pending" });
+	if (!selected.ok) return failedCommand(command.name, command.raw, selected.message, {
+		requires: selected.requires,
+		data: { available: summarizePullRequests(queue.queue.items).slice(0, 10) }
+	});
+	const pr = selected.item;
+	const explanation = ciExplanation(pr);
+	if (options.report) {
+		const report = await (dependencies.createCiFailureDossierReport ?? createCiFailureDossierReport)({
+			ref: `${pr.repo}#${pr.number}`,
+			reportOnly: true
+		}, paths);
+		if (!report.ok) {
+			const requires = "requires" in report ? report.requires : void 0;
+			const errors = "errors" in report ? report.errors : void 0;
+			return requires?.includes("GITHUB_TOKEN") ? needsConfigCommand(command.name, command.raw, report.message, {
+				requires,
+				errors
+			}) : failedCommand(command.name, command.raw, report.message, {
+				requires,
+				errors
+			});
+		}
+		if (!("report" in report)) return failedCommand(command.name, command.raw, "CI dossier report writer did not return a report record.", { requires: ["report"] });
+		return completedCommand(command.name, command.raw, `${explanation.message} Created CI dossier report ${report.report.id}.`, {
+			pr: summarizePullRequests([pr])[0],
+			checks: pr.checks,
+			checkError: pr.checkError,
+			explanation,
+			report: {
+				id: report.report.id,
+				kind: report.report.kind,
+				title: report.report.title,
+				url: `/reports/${report.report.id}`
+			},
+			assistantBrief: "Use the deterministic CI dossier report and queue facts first. Separate observed facts from likely next debugging steps."
+		});
+	}
+	return completedCommand(command.name, command.raw, explanation.message, {
+		pr: summarizePullRequests([pr])[0],
+		checks: pr.checks,
+		checkError: pr.checkError,
+		explanation,
+		assistantBrief: "Use these deterministic CI/check facts first. Separate observed facts from likely next debugging steps."
+	});
+}
+function parseExplainCiArgs(args) {
+	return {
+		report: args.includes("--report"),
+		args: args.filter((arg) => arg !== "--report")
+	};
+}
+async function summarizePrCommand(command, paths, dependencies) {
+	const queue = await readReviewQueue(paths, dependencies);
+	if (!queue.ok) return needsConfigCommand(command.name, command.raw, queue.message, {
+		requires: queue.requires,
+		errors: queue.errors
+	});
+	const selected = selectPullRequest(queue.queue, command.args);
+	if (!selected.ok) return failedCommand(command.name, command.raw, selected.message, {
+		requires: selected.requires,
+		data: { available: summarizePullRequests(queue.queue.items).slice(0, 10) }
+	});
+	const pr = selected.item;
+	const summary = {
+		headline: `${pr.repo}#${pr.number}: ${pr.title}`,
+		state: pr.state,
+		author: pr.author,
+		relations: pr.relations,
+		labels: pr.labels,
+		comments: pr.comments,
+		ageDays: pr.ageDays,
+		stale: pr.stale,
+		baseRef: pr.baseRef,
+		headSha: pr.headSha,
+		checks: pr.checks?.status ?? "unknown",
+		url: pr.url
+	};
+	return completedCommand(command.name, command.raw, `Summarized ${pr.repo}#${pr.number}.`, {
+		pr: summarizePullRequests([pr])[0],
+		summary,
+		assistantBrief: "Summarize the PR from these deterministic facts. Do not invent diff contents that were not fetched."
+	});
+}
+function triageReviewQueue(queue, watches) {
+	const authored = queue.items.filter((item) => item.relations.includes("authored"));
+	const assigned = queue.items.filter((item) => item.relations.includes("assigned"));
+	const requestedReviews = queue.items.filter((item) => item.relations.includes("review-requested"));
+	const failedChecks = queue.items.filter((item) => item.checks?.status === "failure");
+	const checkErrors = queue.items.filter((item) => item.checkError);
+	const stalePrs = queue.items.filter((item) => item.stale);
+	const activeWatches = watches.filter((watch) => [
+		"watching",
+		"merged",
+		"attention-needed"
+	].includes(watch.status));
+	const watchedPrs = queue.items.filter((item) => activeWatches.some((watch) => watch.repoFullName === item.repo && watch.prNumber === item.number));
+	return {
+		summary: {
+			authored: authored.length,
+			assigned: assigned.length,
+			requestedReviews: requestedReviews.length,
+			failedChecks: failedChecks.length,
+			checkErrors: checkErrors.length,
+			stale: stalePrs.length,
+			activeWatches: activeWatches.length,
+			watchedPrs: watchedPrs.length,
+			truncated: queue.truncated,
+			issues: queue.issues.length
+		},
+		authored: summarizePullRequests(authored),
+		assigned: summarizePullRequests(assigned),
+		requestedReviews: summarizePullRequests(requestedReviews),
+		failedChecks: summarizePullRequests(failedChecks),
+		checkErrors: summarizePullRequests(checkErrors),
+		stalePrs: summarizePullRequests(stalePrs),
+		issues: summarizeQueueIssues(queue.issues),
+		activeWatches: activeWatches.map((watch) => ({
+			id: watch.id,
+			repo: watch.repoFullName,
+			number: watch.prNumber,
+			status: watch.status,
+			desiredTerminalState: watch.desiredTerminalState,
+			url: watch.url,
+			updatedAt: watch.updatedAt
+		})),
+		topActions: rankReviewQueueActions(queue.items, activeWatches, failedChecks, checkErrors, requestedReviews, assigned, stalePrs, authored).slice(0, 3)
+	};
+}
+function summarizePullRequests(items) {
+	return items.map((item) => ({
+		repo: item.repo,
+		number: item.number,
+		title: item.title,
+		url: item.url,
+		author: item.author,
+		relations: item.relations,
+		checks: item.checks?.status ?? "unknown",
+		checkError: item.checkError,
+		stale: item.stale,
+		ageDays: item.ageDays,
+		updatedAt: item.updatedAt
+	}));
+}
+function summarizeQueueIssues(issues) {
+	return issues.map((issue) => ({
+		type: issue.type,
+		message: issue.message,
+		query: issue.query,
+		repo: issue.repo,
+		number: issue.number
+	}));
+}
+function rankReviewQueueActions(items, watches, failedChecks, checkErrors, requestedReviews, assigned, stalePrs, authored) {
+	const actions = [];
+	for (const item of failedChecks) actions.push(prAction(item, "Fix failing checks", "urgent"));
+	for (const item of checkErrors) actions.push(prAction(item, "Investigate unknown CI status", "urgent"));
+	for (const watch of watches.filter((item) => item.status === "attention-needed")) actions.push({
+		title: `Resolve watch ${watch.id}`,
+		reason: `Watch is ${watch.status}.`,
+		priority: "urgent",
+		url: watch.url,
+		repo: watch.repoFullName,
+		number: watch.prNumber
+	});
+	for (const item of requestedReviews) actions.push(prAction(item, "Review requested PR", "high"));
+	for (const item of assigned) actions.push(prAction(item, "Move assigned PR forward", "high"));
+	for (const item of stalePrs) actions.push(prAction(item, "Refresh stale PR", "medium"));
+	for (const item of authored) actions.push(prAction(item, "Advance authored PR", "medium"));
+	for (const item of items) actions.push(prAction(item, "Inspect open PR", "low"));
+	return dedupeActions(actions);
+}
+function prAction(item, reason, priority) {
+	return {
+		title: `${reason}: ${item.repo}#${item.number}`,
+		reason: item.checks?.status === "failure" ? `${item.checks.failed} checks failed.` : item.checkError ? `GitHub enrichment failed: ${item.checkError}` : reason,
+		priority,
+		url: item.url,
+		repo: item.repo,
+		number: item.number
+	};
+}
+function dedupeActions(actions) {
+	const seen = /* @__PURE__ */ new Set();
+	return actions.filter((action) => {
+		const key = action.repo && action.number ? `${action.repo}#${action.number}` : `${action.title}:${action.reason}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function isCiFixCandidate(item) {
+	return item.checks?.status === "failure" || item.checkError !== void 0;
+}
+function reviewQueueMessage(triage) {
+	const { summary } = triage;
+	const partial = summary.truncated || summary.issues > 0;
+	return `Triaged ${summary.authored + summary.assigned + summary.requestedReviews} user-related PR signal${summary.authored + summary.assigned + summary.requestedReviews === 1 ? "" : "s"}: ${summary.requestedReviews} review request${summary.requestedReviews === 1 ? "" : "s"}, ${summary.failedChecks} failing check set${summary.failedChecks === 1 ? "" : "s"}, ${summary.checkErrors} unknown check state${summary.checkErrors === 1 ? "" : "s"}, ${summary.stale} stale PR${summary.stale === 1 ? "" : "s"}.${partial ? " Results are partial; inspect queue issues." : ""}`;
+}
+function selectPullRequest(queue, args, options = {}) {
+	const ref = args.join(" ").trim();
+	if (ref) {
+		const parsed = parsePullRequestRef(ref);
+		if (!parsed) return {
+			ok: false,
+			message: "Expected a PR reference like repo#123, owner/repo#123, or a GitHub pull request URL.",
+			requires: ["pr"]
+		};
+		const match = queue.items.find((item) => item.number === parsed.number && (item.repo.toLowerCase() === parsed.repo.toLowerCase() || item.repo.split("/").at(1)?.toLowerCase() === parsed.repo.toLowerCase()));
+		if (!match) return {
+			ok: false,
+			message: `PR ${parsed.repo}#${parsed.number} was not found in the current review queue.`,
+			requires: ["queuedPr"]
+		};
+		return {
+			ok: true,
+			item: match
+		};
+	}
+	const item = (options.prefer ? queue.items.find(options.prefer) : void 0) ?? queue.items[0];
+	if (!item) return {
+		ok: false,
+		message: "No pull requests are available in the current review queue.",
+		requires: ["pr"]
+	};
+	return {
+		ok: true,
+		item
+	};
+}
+function parsePullRequestRef(ref) {
+	const url = ref.match(/github\.com\/([^/\s]+)\/([^/\s]+)\/pull\/(\d+)/i);
+	if (url) return {
+		repo: `${url[1]}/${url[2].replace(/\.git$/, "")}`,
+		number: Number(url[3])
+	};
+	const hash = ref.match(/^([A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)?)#(\d+)$/);
+	if (!hash) return void 0;
+	return {
+		repo: hash[1],
+		number: Number(hash[2])
+	};
+}
+function ciExplanation(pr) {
+	if (pr.checkError) return {
+		status: "unknown",
+		message: `GitHub check status for ${pr.repo}#${pr.number} could not be enriched.`,
+		facts: [`Enrichment error: ${pr.checkError}`],
+		nextActions: ["Open the PR checks page in GitHub.", "Retry after confirming the token can read checks."]
+	};
+	if (!pr.checks) return {
+		status: "unknown",
+		message: `${pr.repo}#${pr.number} has no check summary in the queue.`,
+		facts: ["No check runs or commit statuses were available."],
+		nextActions: ["Confirm the PR head SHA and configured repository access."]
+	};
+	const facts = [
+		`${pr.checks.total} total check signal${pr.checks.total === 1 ? "" : "s"}.`,
+		`${pr.checks.failed} failed, ${pr.checks.pending} pending, ${pr.checks.successful} successful.`,
+		`${pr.checks.statusContexts ?? 0} legacy status context${pr.checks.statusContexts === 1 ? "" : "s"}.`
+	];
+	const nextActions = pr.checks.status === "failure" ? [
+		"Open the failing GitHub checks and inspect the first failed job log.",
+		"Run the matching local validation command if the repo exposes one.",
+		"After fixing, rerun failed checks or push an update."
+	] : pr.checks.status === "pending" ? ["Wait for pending checks or inspect queued jobs for capacity issues."] : pr.checks.status === "success" ? ["No CI action is needed unless review feedback remains."] : ["Confirm whether this repo is expected to publish checks."];
+	return {
+		status: pr.checks.status,
+		message: `${pr.repo}#${pr.number} CI is ${pr.checks.status}.`,
+		facts,
+		nextActions
+	};
+}
+async function readReviewQueue(paths, dependencies) {
+	const token = process.env.GITHUB_TOKEN;
+	if (!token) return {
+		ok: false,
+		message: "GITHUB_TOKEN is not configured.",
+		requires: ["GITHUB_TOKEN"]
+	};
+	try {
+		const registry = await readRepoRegistrySnapshot(paths);
+		const fetchLogin = dependencies.fetchGitHubLogin ?? fetchGitHubLogin;
+		return {
+			ok: true,
+			queue: await (dependencies.fetchPullRequestQueue ?? fetchPullRequestQueue)({
+				token,
+				login: process.env.GITHUB_LOGIN ?? await fetchLogin(token),
+				repos: registry.repos
+			})
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: "Could not fetch GitHub review queue.",
+			errors: [errorMessage(error)]
+		};
+	}
+}
+//#endregion
+//#region src/modules/hygiene/service.ts
+async function readHygieneSummary(paths) {
+	const [worktrees, preparedDiffs, watches] = await Promise.all([
+		listWorktrees(paths),
+		listPreparedDiffs({}, paths),
+		listPrWatchRecords(paths)
+	]);
+	const unusedApprovals = countUnusedExecutionApprovals(paths);
+	return {
+		worktreeCleanupCandidates: worktrees.worktrees.filter((worktree) => [
+			"cleanup-pending",
+			"failed",
+			"needs-sync"
+		].includes(worktree.lifecycleStatus)).length,
+		stalledPreparedDiffs: (preparedDiffs.preparedDiffs ?? []).filter((diff) => [
+			"prepared",
+			"revision-requested",
+			"push-approved"
+		].includes(diff.status)).length,
+		closedOrMergedWatches: watches.filter((watch) => ["closed", "merged"].includes(watch.status)).length,
+		unusedExecutionApprovals: unusedApprovals
+	};
+}
+function countUnusedExecutionApprovals(paths) {
+	const database = openDb(paths.neondeckDatabase, { readOnly: true });
+	try {
+		const row = database.prepare(`
+        SELECT COUNT(*) AS count
+        FROM execution_approvals
+        WHERE status = 'approved'
+          AND used_at IS NULL;
+      `).get();
+		return typeof row?.count === "number" ? row.count : 0;
+	} finally {
+		database.close();
+	}
+}
+//#endregion
+//#region src/modules/briefings/snapshot.ts
+var collectionLimit = 40;
+var snapshotByteLimit = 96e3;
+async function collectBriefingSnapshot(paths, dependencies = {}) {
+	const collectedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const [repos, reviewQueue, watches, tasks, notifications, hygiene, autopilot] = await Promise.all([
+		capture("repos", async () => {
+			return boundedList((await (dependencies.readRepos ?? readRepoRegistrySnapshot)(paths)).repos.map((repo) => ({
+				id: repo.id,
+				fullName: `${repo.github.owner}/${repo.github.name}`,
+				localPath: repo.path
+			})));
+		}),
+		capture("reviewQueue", async () => {
+			const result = await readReviewQueue(paths, dependencies);
+			if (!result.ok) return {
+				data: {
+					available: false,
+					message: result.message,
+					requires: result.requires ?? [],
+					errors: result.errors ?? []
+				},
+				partial: true
+			};
+			const items = result.queue.items.map((item) => ({
+				repo: item.repo,
+				number: item.number,
+				title: item.title,
+				url: item.url,
+				author: item.author,
+				checks: item.checks,
+				updatedAt: item.updatedAt
+			}));
+			return {
+				...boundedList(items),
+				data: {
+					...boundedList(items).data,
+					issues: result.queue.issues.slice(0, 12),
+					fetchedAt: result.queue.fetchedAt
+				},
+				partial: result.queue.truncated || result.queue.issues.length > 0
+			};
+		}),
+		capture("watches", async () => {
+			return boundedList((await (dependencies.readWatches ?? listPrWatchRecords)(paths)).map((watch) => ({
+				id: watch.id,
+				repoId: watch.repoId,
+				prNumber: watch.prNumber,
+				title: watch.title,
+				status: watch.status,
+				url: watch.url,
+				lastCheckedAt: watch.lastCheckedAt
+			})));
+		}),
+		capture("scheduledTasks", async () => {
+			return boundedList((await (dependencies.readTasks ?? listScheduledTasks)(paths)).map((task) => ({
+				id: task.id,
+				kind: task.spec.kind,
+				enabled: task.enabled,
+				nextRunAt: task.nextRunAt,
+				lastRunAt: task.lastRunAt
+			})));
+		}),
+		capture("notifications", async () => {
+			return boundedList((await (dependencies.readNotifications ?? listNotifications)(paths)).filter((notification) => !notification.readAt).map((notification) => ({
+				id: notification.id,
+				level: notification.level,
+				title: notification.title,
+				message: notification.message,
+				source: notification.source,
+				createdAt: notification.createdAt
+			})));
+		}),
+		capture("hygiene", async () => ({ data: await (dependencies.readHygiene ?? readHygieneSummary)(paths) })),
+		capture("autopilot", async () => {
+			const state = await (dependencies.readAutopilot ?? readAutopilotState)(paths);
+			return {
+				data: {
+					summary: state.summary,
+					queue: state.queue.slice(0, collectionLimit),
+					preparedDiffs: state.preparedDiffs.slice(0, collectionLimit),
+					pendingApprovals: state.pendingApprovals.slice(0, collectionLimit),
+					runningChecks: state.runningChecks.slice(0, collectionLimit)
+				},
+				truncated: state.queue.length > collectionLimit || state.preparedDiffs.length > collectionLimit || state.pendingApprovals.length > collectionLimit || state.runningChecks.length > collectionLimit
+			};
+		})
+	]);
+	const sources = {
+		repos,
+		reviewQueue,
+		watches,
+		scheduledTasks: tasks,
+		notifications,
+		hygiene,
+		autopilot
+	};
+	const sizedInitial = withByteSize({
+		version: 1,
+		collectedAt,
+		byteSize: 0,
+		truncated: Object.values(sources).some((source) => source.truncated),
+		sources
+	});
+	if (sizedInitial.byteSize <= snapshotByteLimit) return sizedInitial;
+	const compactSources = Object.fromEntries(Object.entries(sources).map(([name, source]) => [name, {
+		...source,
+		status: source.status === "unavailable" ? "unavailable" : "partial",
+		truncated: true,
+		...source.error ? { error: truncateText(source.error, 1e3) } : {},
+		data: asJsonValue(compactData(source.data))
+	}]));
+	const compact = {
+		version: 1,
+		collectedAt,
+		byteSize: 0,
+		truncated: true,
+		sources: compactSources
+	};
+	const sizedCompact = withByteSize(compact);
+	if (sizedCompact.byteSize <= snapshotByteLimit) return sizedCompact;
+	return withByteSize({
+		...compact,
+		sources: Object.fromEntries(Object.entries(compactSources).map(([name, source]) => [name, {
+			...source,
+			data: null,
+			error: source.error ? truncateText(source.error, 300) : void 0
+		}]))
+	});
+}
+async function capture(_name, read) {
+	const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+	try {
+		const result = await read();
+		return {
+			status: result.partial || result.truncated ? "partial" : "ok",
+			fetchedAt,
+			truncated: Boolean(result.truncated),
+			data: asJsonValue(result.data)
+		};
+	} catch (error) {
+		return {
+			status: "unavailable",
+			fetchedAt,
+			truncated: false,
+			error: truncateText(error instanceof Error ? error.message : String(error), 1e3),
+			data: null
+		};
+	}
+}
+function withByteSize(snapshot) {
+	let candidate = snapshot;
+	for (let attempt = 0; attempt < 3; attempt += 1) {
+		const byteSize = Buffer.byteLength(JSON.stringify(candidate), "utf8");
+		if (byteSize === candidate.byteSize) return candidate;
+		candidate = {
+			...candidate,
+			byteSize
+		};
+	}
+	return candidate;
+}
+function truncateText(value, limit) {
+	return value.length > limit ? `${value.slice(0, limit - 3)}...` : value;
+}
+function boundedList(items) {
+	return {
+		data: {
+			total: items.length,
+			items: items.slice(0, collectionLimit)
+		},
+		truncated: items.length > collectionLimit
+	};
+}
+function compactData(data, depth = 0) {
+	if (typeof data === "string") return data.length > 300 ? `${data.slice(0, 297)}...` : data;
+	if (data === null || typeof data === "number" || typeof data === "boolean" || data === void 0) return data ?? null;
+	if (depth >= 3) return Array.isArray(data) ? {
+		total: data.length,
+		truncated: true
+	} : { truncated: true };
+	if (Array.isArray(data)) return data.slice(0, 3).map((value) => compactData(value, depth + 1));
+	if (typeof data !== "object") return String(data);
+	return Object.fromEntries(Object.entries(data).slice(0, 3).map(([key, value]) => [key, compactData(value, depth + 1)]));
+}
+//#endregion
+//#region src/modules/briefings/store.ts
+var nullableString = v.nullable(v.string());
+var persistedProfileSchema = v.object({
+	id: v.string(),
+	name: v.string(),
+	enabled: v.number(),
+	instructions: v.string(),
+	instructions_version: v.number(),
+	schedule: v.string(),
+	timezone: v.string(),
+	session_id: nullableString,
+	created_at: v.string(),
+	updated_at: v.string()
+});
+var persistedRunSchema = v.object({
+	id: v.string(),
+	profile_id: nullableString,
+	trigger: v.picklist([
+		"manual",
+		"scheduled",
+		"dashboard"
+	]),
+	snapshot_json: v.string(),
+	instructions: v.string(),
+	instructions_version: v.number(),
+	session_id: v.string(),
+	command_event_id: nullableString,
+	dispatch_id: nullableString,
+	workflow_run_id: nullableString,
+	status: v.picklist([
+		"queued",
+		"ready",
+		"failed"
+	]),
+	error: nullableString,
+	queued_at: v.string(),
+	completed_at: nullableString,
+	created_at: v.string(),
+	updated_at: v.string()
+});
+var persistedRunMetadataSchema = v.omit(persistedRunSchema, ["snapshot_json", "instructions"]);
+var persistedBriefingTaskSchema = v.object({
+	kind: v.string(),
+	trigger_json: v.string(),
+	next_run_at: nullableString,
+	claim_id: nullableString,
+	claim_expires_at: nullableString,
+	last_run_at: nullableString,
+	created_at: v.string()
+});
+async function readBriefingProfile(id = defaultBriefingProfileId, paths = runtimePaths()) {
+	await ensureRuntimeHome(paths);
+	const database = openDb(paths.neondeckDatabase);
+	try {
+		const row = database.prepare("SELECT * FROM briefing_profiles WHERE id = ?;").get(id);
+		if (row) return readProfileRow(row, false);
+	} finally {
+		database.close();
+	}
+	const compatibleTask = await readScheduledTask(`briefing:${id}`, paths);
+	const timezone = compatibleTask?.trigger.kind === "cron" ? compatibleTask.trigger.timezone : Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC";
+	if (!compatibleTask) return (await writeBriefingProfileAndTask({
+		id,
+		name: id === "morning" ? "Morning Briefing" : id,
+		enabled: true,
+		instructions: defaultBriefingInstructions,
+		instructionsVersion: 1,
+		schedule: defaultBriefingSchedule,
+		timezone,
+		sessionId: null
+	}, paths)).profile;
+	const cron = compatibleTask?.trigger.kind === "cron" ? compatibleTask.trigger : void 0;
+	return {
+		id,
+		name: id === "morning" ? "Morning Briefing" : id,
+		enabled: compatibleTask.enabled,
+		instructions: defaultBriefingInstructions,
+		instructionsVersion: 1,
+		schedule: cron?.expression ?? "0 8 * * 1-5",
+		timezone,
+		sessionId: null,
+		compatibility: true,
+		createdAt: null,
+		updatedAt: compatibleTask?.updatedAt ?? null
+	};
+}
+async function writeBriefingProfileAndTask(profile, paths = runtimePaths()) {
+	await ensureRuntimeHome(paths);
+	const triggerResult = validateAutomationTrigger({
+		kind: "cron",
+		expression: profile.schedule,
+		timezone: profile.timezone
+	});
+	if (!triggerResult.ok) throw new Error(triggerResult.message);
+	const trigger = triggerResult.trigger;
+	const taskId = `briefing:${profile.id}`;
+	const spec = {
+		kind: "run-briefing",
+		briefingId: profile.id
+	};
+	const database = openDb(paths.neondeckDatabase);
+	const now = /* @__PURE__ */ new Date();
+	const nowIso = now.toISOString();
+	try {
+		database.exec("BEGIN IMMEDIATE;");
+		const beforeProfile = database.prepare("SELECT * FROM briefing_profiles WHERE id = ?;").get(profile.id);
+		const beforeTaskRow = database.prepare("SELECT * FROM scheduled_tasks WHERE id = ?;").get(taskId);
+		const beforeTask = beforeTaskRow ? parsePersisted(persistedBriefingTaskSchema, beforeTaskRow, "briefing scheduled task") : void 0;
+		if (beforeTask && beforeTask.kind !== "run-briefing") throw new Error(`Scheduled task "${taskId}" cannot be replaced with a briefing task.`);
+		const triggerJson = JSON.stringify(asJsonValue(trigger));
+		const nextRunAt = beforeTask && beforeTask.trigger_json === triggerJson ? beforeTask.next_run_at : nextOccurrence(trigger, now);
+		database.prepare(`INSERT INTO scheduled_tasks (
+          id, kind, trigger_json, payload_json, enabled, next_run_at,
+          claim_id, claim_expires_at, last_run_at, created_at, updated_at
+        ) VALUES (?, 'run-briefing', ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          kind = excluded.kind,
+          trigger_json = excluded.trigger_json,
+          payload_json = excluded.payload_json,
+          enabled = excluded.enabled,
+          next_run_at = excluded.next_run_at,
+          updated_at = excluded.updated_at;`).run(taskId, triggerJson, JSON.stringify(asJsonValue(spec)), profile.enabled ? 1 : 0, nextRunAt, beforeTask?.claim_id ?? null, beforeTask?.claim_expires_at ?? null, beforeTask?.last_run_at ?? null, beforeTask?.created_at ?? nowIso, nowIso);
+		database.prepare(`INSERT INTO briefing_profiles (
+          id, name, enabled, instructions, instructions_version, schedule,
+          timezone, session_id, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          name = excluded.name,
+          enabled = excluded.enabled,
+          instructions = excluded.instructions,
+          instructions_version = excluded.instructions_version,
+          schedule = excluded.schedule,
+          timezone = excluded.timezone,
+          session_id = excluded.session_id,
+          updated_at = excluded.updated_at;`).run(profile.id, profile.name, profile.enabled ? 1 : 0, profile.instructions, profile.instructionsVersion, profile.schedule, profile.timezone, profile.sessionId, nowIso, nowIso);
+		const afterProfile = database.prepare("SELECT * FROM briefing_profiles WHERE id = ?;").get(profile.id);
+		database.prepare(`INSERT INTO config_history (
+          action, file, target, before_json, after_json, changed_at
+        ) VALUES ('briefing_profile_update', 'briefing_profiles', ?, ?, ?, ?);`).run(profile.id, beforeProfile ? JSON.stringify(readProfileRow(beforeProfile, false)) : null, JSON.stringify(readProfileRow(afterProfile, false)), nowIso);
+		database.exec("COMMIT;");
+		return {
+			profile: readProfileRow(afterProfile, false),
+			task: {
+				id: taskId,
+				spec,
+				trigger,
+				enabled: profile.enabled,
+				nextRunAt,
+				claimId: beforeTask?.claim_id ?? null,
+				claimExpiresAt: beforeTask?.claim_expires_at ?? null,
+				lastRunAt: beforeTask?.last_run_at ?? null,
+				createdAt: beforeTask?.created_at ?? nowIso,
+				updatedAt: nowIso
+			}
+		};
+	} catch (error) {
+		database.exec("ROLLBACK;");
+		throw error;
+	} finally {
+		database.close();
+	}
+}
+async function setBriefingProfileSession(id, sessionId, paths = runtimePaths()) {
+	await ensureRuntimeHome(paths);
+	const database = openDb(paths.neondeckDatabase);
+	try {
+		database.prepare("UPDATE briefing_profiles SET session_id = ?, updated_at = ? WHERE id = ?;").run(sessionId, (/* @__PURE__ */ new Date()).toISOString(), id);
+	} finally {
+		database.close();
+	}
+}
+async function createBriefingRun(input, paths = runtimePaths()) {
+	await ensureRuntimeHome(paths);
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const id = `briefing:${now.replace(/\D/g, "").slice(0, 14)}:${randomUUID().slice(0, 8)}`;
+	const database = openDb(paths.neondeckDatabase);
+	try {
+		database.prepare(`INSERT INTO briefing_runs (
+          id, profile_id, trigger, snapshot_json, instructions,
+          instructions_version, session_id, command_event_id, dispatch_id,
+          workflow_run_id, status, error, queued_at, completed_at, created_at,
+          updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, 'queued', NULL, ?, NULL, ?, ?);`).run(id, input.profileId, input.trigger, JSON.stringify(input.snapshot), input.instructions, input.instructionsVersion, input.sessionId, input.commandEventId ?? null, now, now, now);
+		return readBriefingRun(id, paths);
+	} finally {
+		database.close();
+	}
+}
+async function attachBriefingDispatch(id, dispatchId, paths = runtimePaths()) {
+	const database = openDb(paths.neondeckDatabase);
+	try {
+		database.prepare("UPDATE briefing_runs SET dispatch_id = ?, updated_at = ? WHERE id = ?;").run(dispatchId, (/* @__PURE__ */ new Date()).toISOString(), id);
+	} finally {
+		database.close();
+	}
+}
+async function attachBriefingWorkflowRun(id, workflowRunId, paths = runtimePaths()) {
+	const database = openDb(paths.neondeckDatabase);
+	try {
+		database.prepare("UPDATE briefing_runs SET workflow_run_id = ?, updated_at = ? WHERE id = ?;").run(workflowRunId, (/* @__PURE__ */ new Date()).toISOString(), id);
+	} finally {
+		database.close();
+	}
+}
+async function settleBriefingRun(dispatchId, status, error, paths = runtimePaths()) {
+	await ensureRuntimeHome(paths);
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const database = openDb(paths.neondeckDatabase);
+	try {
+		const update = database.prepare(`UPDATE briefing_runs
+         SET status = ?, error = ?, completed_at = ?, updated_at = ?
+         WHERE dispatch_id = ? AND status = 'queued';`).run(status, error, now, now, dispatchId);
+		const row = database.prepare("SELECT * FROM briefing_runs WHERE dispatch_id = ?;").get(dispatchId);
+		return {
+			changed: update.changes === 1,
+			run: row ? readRunRow(row) : null
+		};
+	} finally {
+		database.close();
+	}
+}
+async function failBriefingRunBeforeDispatch(id, error, paths = runtimePaths()) {
+	const database = openDb(paths.neondeckDatabase);
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	try {
+		database.prepare(`UPDATE briefing_runs SET status = 'failed', error = ?, completed_at = ?, updated_at = ? WHERE id = ?;`).run(error, now, now, id);
+	} finally {
+		database.close();
+	}
+}
+async function readBriefingRun(id, paths = runtimePaths()) {
+	await ensureRuntimeHome(paths);
+	const database = openDb(paths.neondeckDatabase);
+	try {
+		const row = database.prepare("SELECT * FROM briefing_runs WHERE id = ?;").get(id);
+		return row ? readRunRow(row) : null;
+	} finally {
+		database.close();
+	}
+}
+async function readBriefingRunByDispatch(dispatchId, paths = runtimePaths()) {
+	await ensureRuntimeHome(paths);
+	const database = openDb(paths.neondeckDatabase);
+	try {
+		const row = database.prepare("SELECT * FROM briefing_runs WHERE dispatch_id = ?;").get(dispatchId);
+		return row ? readRunRow(row) : null;
+	} finally {
+		database.close();
+	}
+}
+async function listBriefingRunMetadata(paths = runtimePaths(), limit = 20) {
+	await ensureRuntimeHome(paths);
+	const database = openDb(paths.neondeckDatabase);
+	try {
+		return database.prepare(`SELECT
+          id, profile_id, trigger, instructions_version, session_id,
+          command_event_id, dispatch_id, workflow_run_id, status, error,
+          queued_at, completed_at, created_at, updated_at,
+          json_extract(snapshot_json, '$.version') AS snapshot_version,
+          json_extract(snapshot_json, '$.collectedAt') AS snapshot_collected_at,
+          json_extract(snapshot_json, '$.byteSize') AS snapshot_byte_size,
+          json_extract(snapshot_json, '$.truncated') AS snapshot_truncated
+        FROM briefing_runs
+        ORDER BY created_at DESC
+        LIMIT ?;`).all(limit).map(readRunMetadataRow);
+	} finally {
+		database.close();
+	}
+}
+function readProfileRow(row, compatibility) {
+	const value = parsePersisted(persistedProfileSchema, row, "briefing profile");
+	return {
+		id: value.id,
+		name: value.name,
+		enabled: value.enabled === 1,
+		instructions: value.instructions,
+		instructionsVersion: value.instructions_version,
+		schedule: value.schedule,
+		timezone: value.timezone,
+		sessionId: value.session_id,
+		compatibility,
+		createdAt: value.created_at,
+		updatedAt: value.updated_at
+	};
+}
+function readRunRow(row) {
+	const value = parsePersisted(persistedRunSchema, row, "briefing run");
+	let snapshot;
+	try {
+		snapshot = v.parse(briefingSnapshotSchema, JSON.parse(value.snapshot_json));
+	} catch (error) {
+		throw new Error(`Invalid persisted briefing snapshot for ${value.id}.`, { cause: error });
+	}
+	return {
+		id: value.id,
+		profileId: value.profile_id,
+		trigger: value.trigger,
+		snapshot,
+		instructions: value.instructions,
+		instructionsVersion: value.instructions_version,
+		sessionId: value.session_id,
+		commandEventId: value.command_event_id,
+		dispatchId: value.dispatch_id,
+		workflowRunId: value.workflow_run_id,
+		status: value.status,
+		error: value.error,
+		queuedAt: value.queued_at,
+		completedAt: value.completed_at,
+		createdAt: value.created_at,
+		updatedAt: value.updated_at
+	};
+}
+function readRunMetadataRow(row) {
+	const value = parsePersisted(v.object({
+		...persistedRunMetadataSchema.entries,
+		snapshot_version: v.literal(1),
+		snapshot_collected_at: v.string(),
+		snapshot_byte_size: v.number(),
+		snapshot_truncated: v.number()
+	}), row, "briefing run metadata");
+	return {
+		id: value.id,
+		profileId: value.profile_id,
+		trigger: value.trigger,
+		instructionsVersion: value.instructions_version,
+		sessionId: value.session_id,
+		commandEventId: value.command_event_id,
+		dispatchId: value.dispatch_id,
+		workflowRunId: value.workflow_run_id,
+		status: value.status,
+		error: value.error,
+		queuedAt: value.queued_at,
+		completedAt: value.completed_at,
+		createdAt: value.created_at,
+		updatedAt: value.updated_at,
+		snapshot: {
+			version: 1,
+			collectedAt: value.snapshot_collected_at,
+			byteSize: value.snapshot_byte_size,
+			truncated: value.snapshot_truncated === 1
+		}
+	};
+}
+function parsePersisted(schema, value, label) {
+	try {
+		return v.parse(schema, value);
+	} catch (error) {
+		throw new Error(`Invalid persisted ${label}.`, { cause: error });
+	}
+}
+//#endregion
+//#region src/modules/briefings/service.ts
+var pendingBriefingTerminals = /* @__PURE__ */ new Map();
+var pendingTerminalTtlMs = 3e4;
+async function readBriefingState(paths = runtimePaths()) {
+	const profile = await readBriefingProfile(defaultBriefingProfileId, paths);
+	const [runs, notifications, linkedSession] = await Promise.all([
+		listBriefingRunMetadata(paths),
+		listNotifications(paths),
+		profile.sessionId ? readChatSession({
+			id: profile.sessionId,
+			reason: "briefing-state-read"
+		}, paths) : null
+	]);
+	const session = linkedSession && "session" in linkedSession ? linkedSession.session : null;
+	return {
+		ok: true,
+		action: "briefing_state_read",
+		changed: false,
+		profile,
+		latestRun: runs[0] ?? null,
+		runs,
+		sessionStaleReasons: session?.staleReasons ?? [],
+		unreadCount: notifications.filter((notification) => notification.source === "briefing" && !notification.readAt).length,
+		fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+async function rotateBriefingSession(rawInput, paths = runtimePaths()) {
+	const parsed = v.safeParse(v.object({ id: v.optional(v.string()) }), rawInput);
+	if (!parsed.success) return {
+		ok: false,
+		action: "briefing_session_rotate",
+		changed: false,
+		message: "Invalid briefing session rotation request."
+	};
+	const profile = await readBriefingProfile(parsed.output.id ?? "morning", paths);
+	if (profile.compatibility) await writeBriefingProfileAndTask({
+		id: profile.id,
+		name: profile.name,
+		enabled: profile.enabled,
+		instructions: profile.instructions,
+		instructionsVersion: profile.instructionsVersion,
+		schedule: profile.schedule,
+		timezone: profile.timezone,
+		sessionId: null
+	}, paths);
+	const created = await createChatSession({
+		title: profile.name,
+		kind: "briefing",
+		linkedTaskId: `briefing:${profile.id}:rotation:${Date.now()}`,
+		activate: false,
+		surface: "dashboard",
+		reason: "explicit-briefing-session-rotation",
+		uiMetadata: { briefingProfileId: profile.id }
+	}, paths);
+	if (!("session" in created)) return {
+		ok: false,
+		action: "briefing_session_rotate",
+		changed: false,
+		message: "A fresh briefing conversation could not be created."
+	};
+	await setBriefingProfileSession(profile.id, created.session.id, paths);
+	return {
+		ok: true,
+		action: "briefing_session_rotate",
+		changed: true,
+		message: "Started a fresh briefing conversation.",
+		profile: await readBriefingProfile(profile.id, paths),
+		session: created.session
+	};
+}
+async function readBriefingRunDetails(id, paths = runtimePaths()) {
+	const run = await readBriefingRun(id, paths);
+	if (!run) return {
+		ok: false,
+		action: "briefing_run_read",
+		changed: false,
+		message: `Briefing run "${id}" was not found.`
+	};
+	return {
+		ok: true,
+		action: "briefing_run_read",
+		changed: false,
+		message: `Read briefing run "${id}".`,
+		run
+	};
+}
+async function updateBriefingProfile(rawInput, paths = runtimePaths()) {
+	const parsed = v.safeParse(briefingProfileUpdateSchema, rawInput);
+	if (!parsed.success) return {
+		ok: false,
+		action: "briefing_profile_update",
+		changed: false,
+		message: "Invalid briefing profile.",
+		errors: [v.summarize(parsed.issues)]
+	};
+	const id = parsed.output.id ?? "morning";
+	const current = await readBriefingProfile(id, paths);
+	const instructions = parsed.output.instructions ?? current.instructions;
+	const desired = {
+		id,
+		name: parsed.output.name ?? current.name,
+		enabled: parsed.output.enabled ?? current.enabled,
+		instructions,
+		instructionsVersion: instructions === current.instructions ? current.instructionsVersion : current.instructionsVersion + 1,
+		schedule: parsed.output.schedule ?? current.schedule,
+		timezone: parsed.output.timezone ?? current.timezone,
+		sessionId: current.sessionId
+	};
+	try {
+		const updated = await writeBriefingProfileAndTask(desired, paths);
+		return {
+			ok: true,
+			action: "briefing_profile_update",
+			changed: true,
+			message: "Updated the morning briefing profile and schedule.",
+			profile: updated.profile,
+			task: updated.task
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			action: "briefing_profile_update",
+			changed: false,
+			message: `The briefing profile was not changed: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+async function runBriefingNow(rawInput, paths = runtimePaths(), dependencies = {}) {
+	const parsed = v.safeParse(briefingRunNowSchema, rawInput);
+	if (!parsed.success) return {
+		ok: false,
+		action: "briefing_run",
+		changed: false,
+		message: "Invalid briefing run request.",
+		errors: [v.summarize(parsed.issues)]
+	};
+	try {
+		const input = {
+			profileId: parsed.output.profileId ?? "morning",
+			sessionId: parsed.output.sessionId,
+			commandEventId: parsed.output.commandEventId,
+			trigger: parsed.output.trigger ?? "dashboard"
+		};
+		const { runId } = await (dependencies.invokeWorkflow ?? invokeBriefingWorkflow)(input);
+		return {
+			ok: true,
+			action: "briefing_run",
+			changed: true,
+			message: `Briefing workflow ${runId} queued.`,
+			workflowRunId: runId
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			action: "briefing_run",
+			changed: false,
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+async function invokeBriefingWorkflow(input) {
+	const { invoke } = await import("@flue/runtime");
+	return invoke((await import("./briefing-VMdQPEGc.js")).default, { input });
+}
+async function admitBriefing(input, paths = runtimePaths(), dependencies = {}) {
+	const profile = await readBriefingProfile(input.profileId, paths);
+	const sessionId = input.sessionId ? await validateRequestedBriefingSession(input.sessionId, paths) : await resolveScheduledBriefingSession(profile, paths);
+	const snapshot = await collectBriefingSnapshot(paths, dependencies);
+	const run = await createBriefingRun({
+		profileId: profile.id,
+		trigger: input.trigger,
+		snapshot,
+		instructions: profile.instructions,
+		instructionsVersion: profile.instructionsVersion,
+		sessionId,
+		commandEventId: input.commandEventId
+	}, paths);
+	if (!run) throw new Error("Briefing run could not be persisted.");
+	try {
+		const receipt = await (dependencies.dispatchAgent ?? dispatch)({
+			agent: "display-assistant",
+			id: sessionId,
+			input: composeBriefingInput(run, profile)
+		});
+		await attachBriefingDispatch(run.id, receipt.dispatchId, paths);
+		await reconcilePendingBriefingTerminal(receipt.dispatchId, paths);
+		return {
+			...run,
+			dispatchId: receipt.dispatchId
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		await failBriefingRunBeforeDispatch(run.id, message, paths);
+		await addNotification({
+			level: "attention",
+			title: "Morning briefing failed",
+			message: "Neon could not start the briefing conversation.",
+			source: "briefing",
+			sourceId: run.id,
+			data: {
+				runId: run.id,
+				sessionId,
+				error: message
+			}
+		}, paths);
+		throw error;
+	}
+}
+async function settleBriefingObservation(event, paths = runtimePaths()) {
+	if (!event.dispatchId) return null;
+	const observation = event;
+	if (observation.taskId || observation.parentSession) return null;
+	if (typeof observation.agentName === "string" && observation.agentName !== "display-assistant") return null;
+	if (event.type === "operation" && (event.operationKind !== "prompt" || !event.isError)) return null;
+	const failed = event.type === "operation" ? event.isError : event.type === "submission_settled" ? event.outcome !== "completed" : false;
+	const error = failed ? briefingObservationError(event) : null;
+	const instanceId = typeof observation.instanceId === "string" ? observation.instanceId : "";
+	let correlated = await readBriefingRunByDispatch(event.dispatchId, paths);
+	if (!correlated) {
+		const runId = briefingRunIdFromObservation(observation);
+		if (runId) {
+			const candidate = await readBriefingRun(runId, paths);
+			if (candidate?.status === "queued" && (!instanceId || candidate.sessionId === instanceId)) {
+				await attachBriefingDispatch(runId, event.dispatchId, paths);
+				correlated = await readBriefingRunByDispatch(event.dispatchId, paths);
+			}
+		}
+	}
+	if (!correlated) {
+		rememberPendingBriefingTerminal(paths, event.dispatchId, {
+			failed,
+			error,
+			instanceId,
+			recordedAt: Date.now()
+		});
+		return null;
+	}
+	if (instanceId && correlated.sessionId !== instanceId) return null;
+	return finalizeBriefingTerminal(event.dispatchId, {
+		failed,
+		error,
+		instanceId,
+		recordedAt: Date.now()
+	}, paths);
+}
+async function finalizeBriefingTerminal(dispatchId, terminal, paths) {
+	const { failed, error } = terminal;
+	const settled = await settleBriefingRun(dispatchId, failed ? "failed" : "ready", error, paths);
+	if (!settled.changed || !settled.run) return settled.run;
+	const run = settled.run;
+	if (run.commandEventId) await updateChatSessionCommandEvent({
+		sessionId: run.sessionId,
+		eventId: run.commandEventId,
+		status: failed ? "failed" : "completed",
+		result: null,
+		reason: "briefing-submission-settled"
+	}, paths);
+	await addNotification({
+		level: failed ? "attention" : "ready",
+		title: failed ? "Morning briefing failed" : "Morning briefing ready",
+		message: failed ? "Neon could not complete the briefing. Open the conversation for context." : "Neon has added today's briefing to your Morning Briefing conversation.",
+		source: "briefing",
+		sourceId: run.id,
+		data: {
+			runId: run.id,
+			sessionId: run.sessionId
+		}
+	}, paths);
+	const sessionResult = await readChatSession({
+		id: run.sessionId,
+		reason: "briefing-submission-settled"
+	}, paths);
+	if ("session" in sessionResult && sessionResult.session) publishSessionEvent("updated", sessionResult.session, null);
+	return run;
+}
+function briefingObservationError(event) {
+	if (event.type === "submission_settled") return event.error?.message ?? `Briefing submission ${event.outcome}.`;
+	if (event.type === "operation") {
+		if (event.error instanceof Error) return event.error.message;
+		if (typeof event.error === "string") return event.error;
+		return event.errorInfo?.message ?? "Briefing model operation failed.";
+	}
+	return null;
+}
+async function linkBriefingWorkflowObservation(event, paths = runtimePaths()) {
+	if (!("result" in event) || !event.result || typeof event.result !== "object") return;
+	const briefingRunId = event.result.briefingRunId;
+	if (typeof briefingRunId === "string") await attachBriefingWorkflowRun(briefingRunId, event.runId, paths);
+}
+function composeBriefingInput(run, profile) {
+	const triggerLabel = run.trigger === "scheduled" ? "scheduled morning" : "manual";
+	return [
+		`[NEONDECK_INTERNAL_BRIEFING_INPUT v1 trigger=${run.trigger} run=${run.id}]`,
+		`Prepare the ${triggerLabel} briefing for ${run.snapshot.collectedAt}.`,
+		`Briefing snapshot id: ${run.id}.`,
+		"Neondeck fact snapshot:",
+		JSON.stringify(run.snapshot, null, 2),
+		"User briefing instructions:",
+		profile.instructions,
+		"Respond to the user normally in this conversation. Use any configured MCP tools relevant to their instructions; do not assume a named external source was consulted unless you actually used it. If a deterministic or MCP source is unavailable, needs login, is denied, or awaits approval, explain that naturally and continue with the useful context you do have. Distinguish observed facts from inference. This briefing is informational; do not mutate external systems or auto-approve tool calls."
+	].join("\n\n");
+}
+function briefingRunIdFromObservation(observation) {
+	const agentInput = observation.agentInput;
+	if (!agentInput || typeof agentInput !== "object") return null;
+	const raw = agentInput.text;
+	if (typeof raw !== "string") return null;
+	let text = raw;
+	if (raw.startsWith("\"")) try {
+		const decoded = JSON.parse(raw);
+		if (typeof decoded === "string") text = decoded;
+	} catch {
+		return null;
+	}
+	return text.match(/\[NEONDECK_INTERNAL_BRIEFING_INPUT v1 trigger=\w+ run=([^\]\s]+)\]/)?.[1] ?? null;
+}
+function pendingTerminalKey(paths, dispatchId) {
+	return `${paths.home}:${dispatchId}`;
+}
+function rememberPendingBriefingTerminal(paths, dispatchId, terminal) {
+	const cutoff = Date.now() - pendingTerminalTtlMs;
+	for (const [key, value] of pendingBriefingTerminals) if (value.recordedAt < cutoff) pendingBriefingTerminals.delete(key);
+	if (pendingBriefingTerminals.size >= 100) {
+		const oldest = pendingBriefingTerminals.keys().next().value;
+		if (oldest) pendingBriefingTerminals.delete(oldest);
+	}
+	pendingBriefingTerminals.set(pendingTerminalKey(paths, dispatchId), terminal);
+}
+async function reconcilePendingBriefingTerminal(dispatchId, paths) {
+	const key = pendingTerminalKey(paths, dispatchId);
+	const terminal = pendingBriefingTerminals.get(key);
+	if (!terminal) return;
+	pendingBriefingTerminals.delete(key);
+	if (Date.now() - terminal.recordedAt > pendingTerminalTtlMs) return;
+	const run = await readBriefingRunByDispatch(dispatchId, paths);
+	if (!run || terminal.instanceId && run.sessionId !== terminal.instanceId) return;
+	await finalizeBriefingTerminal(dispatchId, terminal, paths);
+}
+async function resolveScheduledBriefingSession(profile, paths) {
+	if (profile.sessionId) {
+		const existing = await readChatSession({
+			id: profile.sessionId,
+			reason: "scheduled-briefing-reuse"
+		}, paths);
+		if ("session" in existing && !existing.session.archivedAt) {
+			if (existing.session.staleReasons.length > 0) throw new Error("The briefing conversation context is stale. Start a fresh briefing conversation before running again.");
+			return profile.sessionId;
+		}
+	}
+	if (profile.compatibility) await writeBriefingProfileAndTask({
+		id: profile.id,
+		name: profile.name,
+		enabled: profile.enabled,
+		instructions: profile.instructions,
+		instructionsVersion: profile.instructionsVersion,
+		schedule: profile.schedule,
+		timezone: profile.timezone,
+		sessionId: null
+	}, paths);
+	const created = await createChatSession({
+		title: profile.name,
+		kind: "briefing",
+		linkedTaskId: `briefing:${profile.id}`,
+		activate: false,
+		surface: "dashboard",
+		reason: "scheduled-briefing-session",
+		uiMetadata: { briefingProfileId: profile.id }
+	}, paths);
+	if (!("session" in created)) throw new Error("Briefing session could not be created.");
+	if (created.session.staleReasons.length > 0) throw new Error("The briefing conversation context is stale. Start a fresh briefing conversation before running again.");
+	await setBriefingProfileSession(profile.id, created.session.id, paths);
+	return created.session.id;
+}
+async function validateRequestedBriefingSession(sessionId, paths) {
+	const result = await readChatSession({
+		id: sessionId,
+		reason: "manual-briefing-admission"
+	}, paths);
+	if (!("session" in result) || result.session.archivedAt || result.session.agentName !== "display-assistant" || result.session.staleReasons.length > 0) throw new Error("Manual briefings require an active display-assistant chat session.");
+	return result.session.id;
+}
+//#endregion
+//#region src/modules/briefings/actions.ts
+var outputSchema = v.looseObject({
+	ok: v.boolean(),
+	action: v.string(),
+	changed: v.boolean(),
+	message: v.optional(v.string())
+});
+var neondeckBriefingActions = [
+	defineAction({
+		name: "neondeck_briefing_profile_read",
+		description: "Read the typed morning briefing profile, its durable conversation link, and recent operational run metadata.",
+		input: v.object({}),
+		output: outputSchema,
+		async run() {
+			return readBriefingState();
+		}
+	}),
+	defineAction({
+		name: "neondeck_briefing_profile_update",
+		description: "Update the enabled state, cron schedule, timezone, title, or user-authored instructions for the morning briefing profile.",
+		input: briefingProfileUpdateSchema,
+		output: outputSchema,
+		async run({ input }) {
+			return updateBriefingProfile(input);
+		}
+	}),
+	defineAction({
+		name: "neondeck_briefing_run_read",
+		description: "Read one exact persisted deterministic briefing snapshot and its operational dispatch metadata. This never reads or parses the assistant transcript.",
+		input: v.object({ id: v.pipe(v.string(), v.minLength(1)) }),
+		output: outputSchema,
+		async run({ input }) {
+			return readBriefingRunDetails(input.id);
+		}
+	}),
+	defineAction({
+		name: "neondeck_briefing_run_now",
+		description: "Queue an informational briefing in its persistent briefing conversation. All configured display-assistant MCP tools remain available under their normal auth and approval controls.",
+		input: briefingRunNowSchema,
+		output: outputSchema,
+		async run({ input }) {
+			return runBriefingNow(input);
+		}
+	}),
+	defineAction({
+		name: "neondeck_briefing_session_rotate",
+		description: "Explicitly start a fresh durable briefing conversation when its captured model, SOUL, memory, skill, or provider context is stale. The old transcript remains preserved.",
+		input: v.object({ id: v.optional(v.string()) }),
+		output: outputSchema,
+		async run({ input }) {
+			return rotateBriefingSession(input);
+		}
+	})
+];
+//#endregion
+export { completedCommand as C, compactCommandSummary as S, briefingWorkflowInputSchema as T, isActiveMemoryScope as _, readBriefingState as a, readStringArrayProperty as b, settleBriefingObservation as c, explainCiCommand as d, fixCiCommand as f, formatList as g, summarizePrCommand as h, readBriefingRunDetails as i, updateBriefingProfile as l, reviewQueueCommand as m, admitBriefing as n, rotateBriefingSession as o, reviewPrCommand as p, linkBriefingWorkflowObservation as r, runBriefingNow as s, neondeckBriefingActions as t, collectBriefingSnapshot as u, isMemoryScope as v, failedCommand as w, supportedReasoningLevelsForModel as x, parseMemoryValue as y };
+
+//# sourceMappingURL=briefings-DuApznpN.js.map