@camstack/system 1.2.8 → 1.2.10

package/dist/{dist-CxM20CkF.mjs → dist-DpKeSZel.mjs}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-//#region ../types/dist/event-category-D4HJq7Mw.mjs
+//#region ../types/dist/event-category-BLcNejAE.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -149,9 +149,6 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["RecordingSegmentWritten"] = "recording.segment.written";
 	EventCategory["RecordingPolicyFallback"] = "recording.policy.fallback";
 	EventCategory["RecordingRetentionCompleted"] = "recording.retention.completed";
-	/** Runner-sampled scrub thumbnail (~1/5 s/camera). Telemetry (D8): a lost
-	*  thumb is a scrub gap the recorder's keyframe backfill covers. */
-	EventCategory["RecordingThumbSampled"] = "recording.thumb-sampled";
 	/** Export render progress (0–100). Telemetry (D8): a lost tick is a stale
 	*  progress bar the client reconciles via `recordingExport.getExport`. */
 	EventCategory["RecordingExportProgress"] = "recording.export.progress";
@@ -4292,6 +4289,59 @@ for (const l of AUDIO_MACRO_LABELS) {
 /** The complete taxonomy dictionary, keyed by kind. */
 var EVENT_TAXONOMY = Object.freeze(Object.fromEntries(entries));
 /**
+* Notification-Center taxonomy — the fixed vocabulary the NC rule editor
+* offers as pickers instead of free text. Derived (never hand-listed) from the
+* single `EVENT_TAXONOMY` dictionary so it stays in lockstep with every other
+* taxonomy surface (timeline, filters, event page).
+*
+* Three buckets, mapped onto the rule editor's `stringList` conditions:
+*   - `videoClasses` → detection classes (person / vehicle / animal + subs)
+*     for the `classes` / `classesExclude` conditions.
+*   - `audioKinds`   → audio-analyzer sub kinds (`audio-scream`, …) shown in
+*     the same class picker, grouped under an Audio header.
+*   - `labels`       → sensor + control taxonomy kinds (doorbell / contact /
+*     lock / …) for the `sensorKinds` device-event condition.
+*
+* Each entry carries `parentKind` so the client can group video subs under
+* their macro and sensor/control kinds under their category. This surface is
+* served ADDITIVELY on the `nc.getConditionCatalog` bridge response — no cap
+* method, no codegen — so it ships train-free with an addon deploy.
+*/
+/** One selectable taxonomy value: a stable kind id + display label + parent. */
+var NcTaxonomyEntrySchema = z.object({
+	/** Stable kind id (e.g. 'person', 'car', 'audio-scream', 'doorbell'). */
+	kind: z.string(),
+	/** English fallback label (the UI translates via the event-kind i18n key). */
+	label: z.string(),
+	/** Macro/category parent for grouping ('car' → 'vehicle'); null for a top. */
+	parentKind: z.string().nullable()
+});
+z.object({
+	videoClasses: z.array(NcTaxonomyEntrySchema),
+	audioKinds: z.array(NcTaxonomyEntrySchema),
+	labels: z.array(NcTaxonomyEntrySchema)
+});
+function toEntry(kind, label, parentKind) {
+	return {
+		kind,
+		label,
+		parentKind
+	};
+}
+/**
+* Build the NC taxonomy from `EVENT_TAXONOMY`. Insertion order is preserved
+* (macros before their subs), which the client relies on for stable grouping.
+*/
+function buildNcTaxonomy() {
+	const all = Object.values(EVENT_TAXONOMY);
+	return {
+		videoClasses: all.filter((e) => e.category === "detection").map((e) => toEntry(e.kind, e.label, e.parentKind)),
+		audioKinds: all.filter((e) => e.category === "audio" && e.level === "sub").map((e) => toEntry(e.kind, e.label, e.parentKind)),
+		labels: all.filter((e) => e.category === "sensor" || e.category === "control").map((e) => toEntry(e.kind, e.label, e.parentKind))
+	};
+}
+Object.freeze(buildNcTaxonomy());
+/**
 * Error types for the safe expression engine. Two distinct classes so callers
 * can tell a compile-time (grammar) failure from a runtime (evaluation)
 * failure — both are non-fatal to the host: read paths degrade to "skip link".
@@ -12427,106 +12477,6 @@ var addonWidgetsCapability = {
 	mode: "singleton",
 	methods: { listWidgets: method(z.void(), z.array(EnrichedWidgetMetadataSchema).readonly()) }
 };
-var NotificationRuleConditionsSchema = z.object({
-	deviceIds: z.array(z.number()).readonly().optional(),
-	classNames: z.array(z.string()).readonly().optional(),
-	zoneIds: z.array(z.string()).readonly().optional(),
-	minConfidence: z.number().optional(),
-	source: z.enum([
-		"pipeline",
-		"onboard",
-		"any"
-	]).optional(),
-	schedule: z.object({
-		days: z.array(z.number()).readonly(),
-		startHour: z.number(),
-		endHour: z.number()
-	}).optional(),
-	cooldownSeconds: z.number().optional(),
-	minDwellSeconds: z.number().optional(),
-	/** Match against `event.data.eventType` token (e.g. `'press_long'`). When non-empty, only events
-	*  carrying a matching `data.eventType` string pass this condition. Rules without this field are
-	*  unaffected (back-compat). Distinct from `rule.eventTypes` which holds EventCategory strings. */
-	eventTypeTokens: z.array(z.string()).readonly().optional(),
-	/** Match detections whose CLIP image embedding is semantically similar to this free-text
-	*  description. Requires the embedding-encoder cap to have pre-warmed the text vector.
-	*  `minSimilarity` is the cosine similarity threshold in [0, 1]. */
-	clipDescription: z.object({
-		text: z.string().min(1),
-		minSimilarity: z.number().min(0).max(1)
-	}).optional(),
-	/** Match events whose recognized-entity label (face identity name or plate
-	*  vehicle name, propagated onto `event.data.label`) is one of these values.
-	*  Empty/absent → unaffected (back-compat). Enables "notify me when <named
-	*  vehicle/person> is seen". */
-	labels: z.array(z.string()).readonly().optional()
-});
-var NotificationRuleTemplateSchema = z.object({
-	title: z.string(),
-	body: z.string(),
-	imageMode: z.enum([
-		"crop",
-		"annotated",
-		"full",
-		"none"
-	])
-});
-var NotificationRuleSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	enabled: z.boolean(),
-	eventTypes: z.array(z.string()).readonly(),
-	conditions: NotificationRuleConditionsSchema,
-	outputs: z.array(z.string()).readonly(),
-	template: NotificationRuleTemplateSchema.optional(),
-	priority: z.enum([
-		"low",
-		"normal",
-		"high",
-		"critical"
-	])
-});
-var NotificationTestResultSchema = z.object({
-	ruleId: z.string(),
-	eventId: z.string(),
-	timestamp: z.number(),
-	wouldFire: z.boolean(),
-	reason: z.string().optional()
-});
-var NotificationHistoryEntrySchema = z.object({
-	id: z.string(),
-	ruleId: z.string(),
-	ruleName: z.string(),
-	eventId: z.string(),
-	timestamp: z.number(),
-	outputs: z.array(z.string()).readonly(),
-	success: z.boolean(),
-	error: z.string().optional(),
-	deviceId: z.number().optional()
-});
-var NotificationHistoryFilterSchema = z.object({
-	ruleId: z.string().optional(),
-	deviceId: z.number().optional(),
-	from: z.number().optional(),
-	to: z.number().optional(),
-	limit: z.number().optional()
-});
-var advancedNotifierCapability = {
-	name: "advanced-notifier",
-	scope: "system",
-	mode: "singleton",
-	internal: true,
-	methods: {
-		getRules: method(z.void(), z.object({ rules: z.array(NotificationRuleSchema).readonly() })),
-		upsertRule: method(z.object({ rule: NotificationRuleSchema }), z.object({ success: z.literal(true) }), { kind: "mutation" }),
-		deleteRule: method(z.object({ ruleId: z.string() }), z.object({ success: z.literal(true) }), { kind: "mutation" }),
-		testRule: method(z.object({
-			ruleId: z.string(),
-			lookbackMinutes: z.number()
-		}), z.object({ results: z.array(NotificationTestResultSchema).readonly() }), { kind: "mutation" }),
-		getHistory: method(z.object({ filter: NotificationHistoryFilterSchema.optional() }), z.object({ entries: z.array(NotificationHistoryEntrySchema).readonly() }))
-	}
-};
 /**
 * Alerts capability — collection-based internal alert system.
 *
@@ -12827,117 +12777,6 @@ var authProviderCapability = {
 	mount: { kind: "skip" }
 };
 /**
-* `login-method` — collection cap through which auth addons contribute
-* their pre-auth login surfaces to the login page. This is the SINGLE,
-* generic mechanism that supersedes the dead `auth.listProviders` reader:
-* every auth addon (OIDC, magic-link, WebAuthn/passkey) registers a
-* `login-method` provider and the PUBLIC `auth.listLoginMethods`
-* procedure aggregates them for the unauthenticated login page.
-*
-* A contribution is a discriminated union on `kind`:
-*
-*  - `redirect` — a declarative button. The login page renders a generic
-*    button that navigates to `startUrl` (an addon-owned HTTP route).
-*    Covers OIDC (`/addon/auth-oidc/<id>/start`) and magic-link with
-*    ZERO shell-side JS. A future SSO addon plugs in the same way — the
-*    login page needs NO change.
-*
-*  - `widget` — a Module-Federation widget the login page mounts (via
-*    `loadRemoteBundle`) for an in-page ceremony. `auth.listLoginMethods`
-*    stamps a public `bundleUrl` from `addonId` + `bundle`. Generic
-*    mechanism kept for future use; no shipped addon uses it on the login
-*    page (the passkey ceremony below runs natively in the shell instead).
-*
-*  - `passkey` — a declarative WebAuthn ceremony the shell renders
-*    natively (`@simplewebauthn/browser` lives in `addon-admin-ui`, not in
-*    a remotely-loaded bundle). Carries the addon's effective `rpId` /
-*    `origin` (from its `resolveRpID()` / `resolveOrigin()`) so the shell
-*    can gate visibility (IP-literal origin, hostname/rpId mismatch) WITHOUT
-*    fetching any remote code pre-auth. Contribution stays unconditional —
-*    enrollment state is never leaked pre-auth; visibility is a shell
-*    decision.
-*
-* Every contribution carries a `stage`:
-*  - `primary`        — shown on the first credentials screen (OIDC /
-*                       magic-link buttons; a future usernameless passkey).
-*  - `second-factor`  — shown AFTER the password leg, gated on the
-*                       returned `factors` (passkey-as-2FA today).
-*
-* `mount: skip` — the cap is read server-side by the core auth router
-* (`registry.getCollection('login-method')`), never mounted as its own
-* tRPC router.
-*/
-/** When a login method renders in the two-phase login flow. */
-var LoginStageEnum = z.enum(["primary", "second-factor"]);
-/**
-* A declarative redirect button — the login page navigates to `startUrl`.
-* OIDC and magic-link contribute this; a future SSO addon does too.
-*/
-var RedirectLoginMethodSchema = z.object({
-	kind: z.literal("redirect"),
-	/** Stable id within the login-method set (e.g. `auth-oidc/google`). */
-	id: z.string(),
-	/** Operator-facing button label. */
-	label: z.string(),
-	/** lucide-react icon name. */
-	icon: z.string().optional(),
-	/** Addon-owned HTTP route the button navigates to (GET). */
-	startUrl: z.string(),
-	stage: LoginStageEnum
-});
-/**
-* A Module-Federation widget the login page mounts for an in-page
-* ceremony. `bundle` + `addonId` let `auth.listLoginMethods` stamp a
-* public `bundleUrl`; `remote` is the MF descriptor `loadRemoteBundle`
-* consumes. No `bundleUrl` here — it is server-stamped on the public
-* output so the addon never encodes the static-route scheme.
-*/
-var WidgetLoginMethodSchema = z.object({
-	kind: z.literal("widget"),
-	/** Stable id within the login-method set (e.g. `auth-webauthn/passkey-login`). */
-	id: z.string(),
-	/** Owning addon id — drives the public bundle URL + the MF namespace. */
-	addonId: z.string(),
-	/** Bundle filename inside the addon's dist dir (`remoteEntry.js`). */
-	bundle: z.string(),
-	/** MF remote descriptor — `{ remoteName, exposedModule, componentKey }`. */
-	remote: WidgetRemoteSchema,
-	stage: LoginStageEnum
-});
-/**
-* A declarative WebAuthn ceremony the shell renders natively (no remote
-* code). Carries the addon's EFFECTIVE `rpId`/`origin` so the shell can
-* gate visibility (IP-literal origin, hostname/rpId mismatch) before ever
-* showing the button — the contribution itself stays unconditional.
-*/
-var PasskeyLoginMethodSchema = z.object({
-	kind: z.literal("passkey"),
-	/** Stable id within the login-method set (e.g. `auth-webauthn/passkey-direct-login`). */
-	id: z.string(),
-	/** Operator-facing button label. */
-	label: z.string(),
-	stage: LoginStageEnum,
-	/** Effective WebAuthn RP ID (`resolveRpID()`) — the shell gates visibility on it. */
-	rpId: z.string(),
-	/** Effective expected origin (`resolveOrigin()`), null when unconfigured. */
-	origin: z.string().nullable()
-});
-/** One login-method contribution — redirect button, pre-auth widget, or native passkey ceremony. */
-var LoginMethodContributionSchema = z.discriminatedUnion("kind", [
-	RedirectLoginMethodSchema,
-	WidgetLoginMethodSchema,
-	PasskeyLoginMethodSchema
-]);
-var loginMethodCapability = {
-	name: "login-method",
-	scope: "system",
-	mode: "collection",
-	internal: true,
-	methods: { getLoginMethods: method(z.void(), z.array(LoginMethodContributionSchema).readonly()) },
-	/** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
-	mount: { kind: "skip" }
-};
-/**
 * Orchestrator-side destination metadata. The orchestrator computes
 * `id = <addonId>:<subId>` from its provider lookup so consumers
 * (admin UI, restore flow) see one canonical key.
@@ -15077,1269 +14916,1658 @@ var filesystemBrowseCapability = {
 		})
 	}
 };
-var LogLevelSchema = z.enum([
-	"debug",
-	"info",
-	"warn",
-	"error"
+/**
+* Shared LLM generate contracts — imported by BOTH `llm.cap.ts` (consumer
+* surface) and `llm-runtime.cap.ts` (node-side managed executor) so the two
+* caps stay wire-compatible without a circular cap→cap import.
+*
+* Errors are a discriminated-union RESULT, never thrown: the shape survives
+* every transport tier structurally, and failed calls still write usage rows.
+* Token counts only in v1 — no costUsd (operator decision, 2026-07-15).
+*/
+var LlmUsageSchema = z.object({
+	inputTokens: z.number(),
+	outputTokens: z.number()
+});
+var LlmErrorCodeSchema = z.enum([
+	"timeout",
+	"rate-limited",
+	"auth",
+	"refusal",
+	"bad-request",
+	"unavailable",
+	"no-profile",
+	"budget-exceeded",
+	"adapter-error"
 ]);
-var LogEntrySchema = z.object({
-	timestamp: z.date(),
-	level: LogLevelSchema,
-	scope: z.array(z.string()),
-	message: z.string(),
-	meta: z.record(z.string(), z.unknown()).optional(),
-	tags: z.record(z.string(), z.string()).optional()
+var LlmGenerateOkSchema = z.object({
+	ok: z.literal(true),
+	text: z.string(),
+	model: z.string(),
+	usage: LlmUsageSchema,
+	truncated: z.boolean(),
+	latencyMs: z.number()
 });
-var logDestinationCapability = {
-	name: "log-destination",
-	scope: "system",
-	mode: "collection",
-	internal: true,
-	methods: {
-		write: method(LogEntrySchema, z.void(), { kind: "mutation" }),
-		query: method(z.object({
-			scope: z.array(z.string()).optional(),
-			level: LogLevelSchema.optional(),
-			since: z.date().optional(),
-			until: z.date().optional(),
-			limit: z.number().optional(),
-			tags: z.record(z.string(), z.string()).optional()
-		}), z.array(LogEntrySchema).readonly())
-	},
-	/** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
-	mount: { kind: "skip" }
-};
-var CpuBreakdownSchema = z.object({
-	total: z.number(),
-	user: z.number(),
-	system: z.number(),
-	irq: z.number(),
-	nice: z.number(),
-	loadAvg: z.tuple([
-		z.number(),
-		z.number(),
-		z.number()
-	]),
-	cores: z.number()
+var LlmGenerateErrSchema = z.object({
+	ok: z.literal(false),
+	code: LlmErrorCodeSchema,
+	message: z.string(),
+	retryAfterMs: z.number().optional()
 });
-var MemoryInfoSchema = z.object({
-	percent: z.number(),
-	totalBytes: z.number(),
-	usedBytes: z.number(),
-	availableBytes: z.number(),
-	swapUsedBytes: z.number(),
-	swapTotalBytes: z.number()
-});
-var DiskIoSnapshotSchema = z.object({
-	readBytes: z.number(),
-	writeBytes: z.number(),
-	readOps: z.number(),
-	writeOps: z.number(),
-	timestampMs: z.number()
-});
-var NetworkIoSnapshotSchema = z.object({
-	rxBytes: z.number(),
-	txBytes: z.number(),
-	rxPackets: z.number(),
-	txPackets: z.number(),
-	rxErrors: z.number(),
-	txErrors: z.number(),
-	timestampMs: z.number()
-});
-var MetricsGpuInfoSchema = z.object({
-	utilization: z.number(),
-	model: z.string(),
-	memoryUsedBytes: z.number(),
-	memoryTotalBytes: z.number(),
-	temperature: z.number().nullable()
-});
-var ProcessResourceInfoSchema = z.object({
-	openFds: z.number(),
-	threadCount: z.number(),
-	activeHandles: z.number(),
-	activeRequests: z.number()
-});
-var PressureAvgsSchema = z.object({
-	avg10: z.number(),
-	avg60: z.number(),
-	avg300: z.number()
+var LlmGenerateResultSchema = z.discriminatedUnion("ok", [LlmGenerateOkSchema, LlmGenerateErrSchema]);
+/**
+* `Uint8Array` is the sanctioned binary convention — superjson + the UDS
+* MsgPack channel round-trip typed arrays (embedding-encoder.cap.ts:29,
+* notification-output.cap.ts:27-31 precedents).
+*/
+var LlmImageSchema = z.object({
+	bytes: z.instanceof(Uint8Array),
+	mimeType: z.string()
 });
-var PressureInfoSchema = z.object({
-	some: PressureAvgsSchema,
-	full: PressureAvgsSchema.nullable()
+var LlmGenerateBaseInputSchema = z.object({
+	/** Collection routing (the notification-output posture). */
+	addonId: z.string().optional(),
+	/** Explicit profile; else the resolution chain (spec §3). */
+	profileId: z.string().optional(),
+	/** MANDATORY usage tag: 'ai-summary', 'notifier-rules', 'adhoc-ui', … */
+	consumer: z.string(),
+	system: z.string().optional(),
+	/** v1: single-turn. `messages[]` is a v2 additive field. */
+	prompt: z.string(),
+	/** Structured output — adapter-mapped (response_format / forced tool / responseSchema). */
+	jsonSchema: z.record(z.string(), z.unknown()).optional(),
+	/** Per-call override of the profile default. */
+	maxTokens: z.number().int().positive().optional(),
+	temperature: z.number().optional()
 });
-var SystemResourceSnapshotSchema = z.object({
-	cpu: CpuBreakdownSchema,
-	memory: MemoryInfoSchema,
-	gpu: MetricsGpuInfoSchema.nullable(),
-	network: NetworkIoSnapshotSchema,
-	disk: DiskIoSnapshotSchema,
-	pressure: z.object({
-		cpu: PressureInfoSchema.nullable(),
-		memory: PressureInfoSchema.nullable(),
-		io: PressureInfoSchema.nullable()
+/**
+* `llm-runtime` — node-side managed llama.cpp executor (spec §4). Registered
+* on EVERY node where `addon-ai` is installed; the hub `llm` provider reaches
+* a specific node's runtime with `nodePin(profile.runtime.nodeId)` — normal
+* cap routing, zero bespoke plumbing. `internal: true`: the operator reaches
+* this only through the `llm` cap's methods.
+*
+* One running llama-server child per node in v1 (models are RAM-heavy).
+* Resource ceiling = llama-server flags + idleStopMinutes ONLY (no RSS
+* watchdog — operator decision #3).
+*/
+var ManagedModelRefSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("catalog"),
+		catalogId: z.string()
 	}),
-	process: ProcessResourceInfoSchema,
-	cpuTemperature: z.number().nullable(),
-	timestampMs: z.number()
-});
-var DiskSpaceInfoSchema = z.object({
-	path: z.string(),
-	totalBytes: z.number(),
-	usedBytes: z.number(),
-	availableBytes: z.number(),
-	percent: z.number()
-});
-var PidResourceStatsSchema = z.object({
-	pid: z.number(),
-	cpu: z.number(),
-	memory: z.number(),
-	/**
-	* Private (anonymous) resident bytes — the per-process V8 heap + native
-	* allocations NOT shared with other processes (Linux RssAnon). This is the
-	* "real" per-runner cost; summing it across runners is meaningful, unlike
-	* `memory` (RSS), which double-counts the shared mmap'd framework code.
-	* Undefined where /proc is unavailable (e.g. macOS).
-	*/
-	privateBytes: z.number().optional(),
-	/**
-	* Shared file-backed resident bytes (Linux RssFile) — mmap'd framework/lib
-	* code shared copy-on-write across runners. Undefined on macOS.
-	*/
-	sharedBytes: z.number().optional()
+	z.object({
+		kind: z.literal("url"),
+		url: z.string(),
+		sha256: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("path"),
+		path: z.string()
+	})
+]);
+var ManagedRuntimeConfigSchema = z.object({
+	/** WHERE the runtime lives — hub or any agent. */
+	nodeId: z.string(),
+	/** Closed for v1; 'ollama' is a v2 candidate. */
+	engine: z.enum(["llama-cpp"]),
+	model: ManagedModelRefSchema,
+	contextSize: z.number().int().default(4096),
+	/** 0 = CPU-only. */
+	gpuLayers: z.number().int().default(0),
+	/** Default: cpus-2, clamped ≥1 (resolved node-side). */
+	threads: z.number().int().optional(),
+	/** Concurrent slots. */
+	parallel: z.number().int().default(1),
+	/** Else lazy: first generate boots it. */
+	autoStart: z.boolean().default(false),
+	/** 0 = never; frees RAM after quiet periods. */
+	idleStopMinutes: z.number().int().default(30)
 });
-var AddonInstanceSchema = z.object({
-	addonId: z.string(),
+var LlmRuntimeStatusSchema = z.object({
+	/** Status is ALWAYS node-qualified. */
 	nodeId: z.string(),
-	role: z.enum(["hub", "worker"]),
-	pid: z.number(),
 	state: z.enum([
-		"starting",
-		"running",
-		"stopping",
 		"stopped",
-		"crashed"
-	]),
-	uptimeSec: z.number()
-});
-var NodeProcessSchema = z.object({
-	pid: z.number(),
-	ppid: z.number(),
-	pgid: z.number(),
-	classification: z.enum([
-		"root",
-		"managed",
-		"system",
-		"ghost"
+		"downloading",
+		"starting",
+		"ready",
+		"crashed",
+		"failed"
 	]),
-	/** `$process` addon binding when `managed`, else null. */
-	addonId: z.string().nullable(),
-	/** Kernel-reported nodeId when the process is a known agent/worker. */
-	nodeId: z.string().nullable(),
-	/** Truncated command line. */
-	command: z.string(),
-	cpuPercent: z.number(),
-	memoryRssBytes: z.number(),
-	/** Wall-clock uptime (seconds). Parsed from `ps etime`. */
-	uptimeSec: z.number(),
-	/** True when ancestor walk reaches `ppid=1` (reparented to init/launchd). */
-	orphaned: z.boolean()
-});
-var KillProcessInputSchema = z.object({
-	pid: z.number(),
-	/** Force = SIGKILL. Default is SIGTERM. */
-	force: z.boolean().optional()
-});
-var KillProcessResultSchema = z.object({
-	success: z.boolean(),
-	reason: z.string().optional(),
-	signal: z.enum(["SIGTERM", "SIGKILL"]).optional()
-});
-var DumpHeapSnapshotInputSchema = z.object({ 
-/** The addon whose runner should dump a heap snapshot. */
-addonId: z.string() });
-var DumpHeapSnapshotResultSchema = z.object({
-	success: z.boolean(),
-	/** Path of the written .heapsnapshot inside the runner's container/host. */
-	path: z.string().optional(),
-	/** Process pid that was signalled. */
 	pid: z.number().optional(),
-	reason: z.string().optional()
+	port: z.number().optional(),
+	modelPath: z.string().optional(),
+	modelId: z.string().optional(),
+	downloadProgress: z.number().min(0).max(1).optional(),
+	lastError: z.string().optional(),
+	crashesInWindow: z.number(),
+	/** Child RSS (sampled best-effort). */
+	memoryBytes: z.number().optional(),
+	vramBytes: z.number().optional()
 });
-var SystemMetricsSchema = z.object({
-	cpuPercent: z.number(),
-	memoryPercent: z.number(),
-	memoryUsedMB: z.number(),
-	memoryTotalMB: z.number(),
-	diskPercent: z.number().optional(),
-	temperature: z.number().optional(),
-	gpuPercent: z.number().optional(),
-	gpuMemoryPercent: z.number().optional()
+var LlmNodeModelSchema = z.object({
+	file: z.string(),
+	sizeBytes: z.number(),
+	catalogId: z.string().optional(),
+	installedAt: z.number().optional()
 });
-var metricsProviderCapability = {
-	name: "metrics-provider",
+var LlmRuntimeDiskUsageSchema = z.object({
+	nodeId: z.string(),
+	modelsBytes: z.number(),
+	freeBytes: z.number().optional()
+});
+var llmRuntimeCapability = {
+	name: "llm-runtime",
 	scope: "system",
 	mode: "singleton",
+	internal: true,
 	methods: {
-		/** Fresh, full system snapshot (triggers OS-level collection). */
-		collectSnapshot: method(z.void(), SystemResourceSnapshotSchema),
-		/** Most recent cached snapshot from the background sampler, or null pre-first-sample. */
-		getCached: method(z.void(), SystemResourceSnapshotSchema.nullable()),
-		/** Light-weight cached summary for heartbeats and list views. */
-		getCurrent: method(z.void(), SystemMetricsSchema),
-		/** Disk space for the given mount/path. */
-		getDiskSpace: method(z.object({ dirPath: z.string() }), DiskSpaceInfoSchema),
-		/** GPU info (null if unavailable). */
-		getGpuInfo: method(z.void(), MetricsGpuInfoSchema.nullable()),
-		/** CPU temperature in °C (null if unavailable). */
-		getCpuTemperature: method(z.void(), z.number().nullable()),
-		/** Per-PID resource stats. Missing/dead PIDs are omitted from the result. */
-		getProcessStats: method(z.object({ pids: z.array(z.number()) }), z.array(PidResourceStatsSchema)),
-		/**
-		* List addon instances known to this node — one entry per forked worker
-		* plus a synthetic 'hub' entry representing the local hub process.
-		* Used by benchmarks/observability to detect whether a given addon runs
-		* in its own process (measurable independently) or inline with the hub.
-		*/
-		listAddonInstances: method(z.void(), z.array(AddonInstanceSchema).readonly()),
-		/**
-		* Resource stats for the process hosting the given addon.
-		* Returns null when the addon runs in-process on the hub (can't measure
-		* independently — caller should detect via listAddonInstances). Returns
-		* hub process stats for addonId '$hub'.
-		*/
-		getAddonStats: method(z.object({ addonId: z.string() }), PidResourceStatsSchema.nullable()),
-		/**
-		* Snapshot of every camstack-related process on this node with a
-		* ghost/managed/root classification. Powers the Cluster → Agent →
-		* Processes tab: cross-references `$process.list` against a `ps` scan
-		* so orphaned trees (PPID=1) or unknown children show up as `ghost`
-		* and can be killed from the UI.
-		*/
-		listNodeProcesses: method(z.void(), z.array(NodeProcessSchema).readonly()),
-		/**
-		* Send SIGTERM (or SIGKILL when `force`) to a pid inside this node's
-		* process tree. The provider refuses pids that aren't in the live
-		* `listNodeProcesses()` snapshot — callers can't use this endpoint
-		* to kill arbitrary system processes.
-		*/
-		killProcess: method(KillProcessInputSchema, KillProcessResultSchema, {
+		complete: method(LlmGenerateBaseInputSchema.extend({
+			images: z.array(LlmImageSchema).optional(),
+			runtime: ManagedRuntimeConfigSchema,
+			/** The managed profile's timeout, threaded by the hub provider. */
+			timeoutMs: z.number().int().positive().optional()
+		}), LlmGenerateResultSchema, { kind: "mutation" }),
+		ensureStarted: method(z.object({ runtime: ManagedRuntimeConfigSchema }), LlmRuntimeStatusSchema, {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		/**
-		* Tell the addon's forked runner to write a V8 heap snapshot to disk (via
-		* SIGUSR2 — the runner's diagnostic handler). Also logs its
-		* `process.memoryUsage()` + heap-space breakdown. Refuses pids not in the
-		* live `listNodeProcesses()` snapshot. Use for deep per-addon memory
-		* attribution; copy the returned path off the node to analyze.
-		*/
-		dumpHeapSnapshot: method(DumpHeapSnapshotInputSchema, DumpHeapSnapshotResultSchema, {
+		stop: method(z.object({}), z.void(), {
 			kind: "mutation",
 			auth: "admin"
-		})
+		}),
+		status: method(z.object({}), LlmRuntimeStatusSchema),
+		installModel: method(z.object({ model: ManagedModelRefSchema }), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteModel: method(z.object({ file: z.string() }), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		listLocalModels: method(z.object({}), z.array(LlmNodeModelSchema)),
+		getDiskUsage: method(z.object({}), LlmRuntimeDiskUsageSchema)
 	}
 };
-var modelConvertCapability = {
-	name: "model-convert",
-	scope: "system",
-	mode: "singleton",
-	internal: true,
-	methods: { convert: method(z.object({
-		sourceUrl: z.string(),
-		metadata: ModelConvertMetadataSchema,
-		targets: z.array(ConvertTargetSchema).min(1).readonly(),
-		calibrationRef: z.string().optional(),
-		sessionId: z.string().optional()
-	}), ConvertResultSchema, {
-		kind: "mutation",
-		auth: "admin",
-		timeoutMs: 6e5
-	}) }
-};
-var modelDistributorCapability = {
-	name: "model-distributor",
-	scope: "system",
-	mode: "singleton",
-	internal: true,
-	methods: { distributeModel: method(z.object({
-		nodeId: z.string(),
-		modelId: z.string(),
-		format: z.enum(MODEL_FORMATS),
-		entry: ModelCatalogEntrySchema
-	}), z.object({
-		ok: z.boolean(),
-		/** sha256 of the staged tarball (empty for a hub-local no-op). */
-		sha256: z.string(),
-		bytes: z.number(),
-		/** The target node's modelsDir the artifact landed in. */
-		path: z.string()
-	}), {
-		kind: "mutation",
-		auth: "admin"
-	}) }
-};
-/**
-* `mqtt-broker` — broker-registry cap.
-*
-* NOT a pub/sub proxy. The cap exposes (a) a registry of configured
-* MQTT brokers (external + optionally an embedded `aedes`-backed one)
-* and (b) the connection details a consumer addon needs to spin up
-* its OWN `mqtt.js` client.
-*
-* Why: pub/sub routing over the system event-bus loses fidelity
-* (callback shape, QoS guarantees, will/retain semantics) and adds
-* refcount bookkeeping that addons would rather own themselves. The
-* canonical consumer (`addon-export-ha-mqtt`) needs raw `mqtt.js`
-* features anyway — give it the connection config, get out of the way.
-*
-* Consumer flow:
-*   const cfg = await ctx.api.mqttBroker.getBrokerConfig({ id })
-*   const client = mqtt.connect(cfg.url, { username: cfg.username, … })
-*   client.subscribe('zigbee2mqtt/+')
-*
-* Collection mode: multiple brokers (e.g. one local mosquitto + one
-* cloud bridge). The "embedded" entry (when present) is just another
-* broker in the registry — its lifecycle is owned by the addon that
-* spawned it.
-*/
-var BrokerKindSchema = z.enum(["external", "embedded"]);
 /**
-* Broker live-probe status.
+* `llm` — consumer-facing LLM surface (spec §1-§3). Collection-mode: array
+* methods concat-fan across providers; single-row methods route to ONE
+* provider by the `addonId` in the call input (the notification-output
+* posture, notification-output.cap.ts:215-250). Provided by `addon-ai`
+* (hub-placed); the cap stays open for future providers.
 *
-* - `connected` — last probe completed a clean CONNACK
-* - `disconnected` — no probe has run yet (cold cache)
-* - `auth-failed` — CONNACK refused with auth error (RC 4 / 5)
-* - `unreachable` — TCP connect timed out / refused
-* - `tls-error` — TLS handshake failed (cert / SNI / cipher)
+* Profiles are ROWS (data), not addons: one row = one usable model endpoint.
+* `apiKey` is a password field — providers REDACT it on read and merge on
+* write; a stored key NEVER round-trips to a client.
 */
-var BrokerStatusSchema$1 = z.enum([
-	"connected",
-	"disconnected",
-	"auth-failed",
-	"unreachable",
-	"tls-error"
+var LlmProfileKindSchema = z.enum([
+	"openai-compatible",
+	"openai",
+	"anthropic",
+	"google",
+	"managed-local"
 ]);
-var BrokerInfoSchema = z.object({
+var LlmProfileSchema = z.object({
 	id: z.string(),
 	name: z.string(),
-	url: z.string(),
-	kind: BrokerKindSchema,
-	status: BrokerStatusSchema$1,
-	latencyMs: z.number().nullable(),
-	error: z.string().optional(),
-	/** Embedded brokers only: number of MQTT clients currently connected. */
-	connectedClients: z.number().int().nonnegative().optional(),
-	/** Epoch ms of the last live probe (external) or aedes snapshot (embedded). */
-	lastCheckedAt: z.number().optional()
+	kind: LlmProfileKindSchema,
+	/** Stamped by the provider — keeps the fanned catalog routable. */
+	addonId: z.string(),
+	enabled: z.boolean(),
+	/** Vendor model id, or the managed runtime's loaded model. */
+	model: z.string(),
+	/** Required for openai-compatible; override for cloud kinds. */
+	baseUrl: z.string().optional(),
+	/** ConfigUISchema type:'password' — never round-trips (spec §5). */
+	apiKey: z.string().optional(),
+	supportsVision: z.boolean(),
+	temperature: z.number().min(0).max(2).optional(),
+	maxTokens: z.number().int().positive().optional(),
+	timeoutMs: z.number().int().positive().default(6e4),
+	extraHeaders: z.record(z.string(), z.string()).optional(),
+	/** kind === 'managed-local' only (spec §4). */
+	runtime: ManagedRuntimeConfigSchema.optional()
 });
-/**
-* Connection details — what a consumer needs to call
-* `mqtt.connect(url, options)`. We split URL + credentials so the
-* consumer can pass them as `mqtt.connect(url, { username, password })`
-* instead of stuffing creds into the URL (which leaks them into logs).
-*/
-var BrokerConnectionDetailsSchema = z.object({
-	url: z.string(),
-	username: z.string().optional(),
-	password: z.string().optional(),
-	/**
-	* Suggested prefix for `clientId`. Each consumer should suffix this
-	* with its own discriminator (addon id, instance id) so reconnects
-	* don't kick each other off (MQTT spec: clientId must be unique per
-	* broker).
-	*/
-	clientIdPrefix: z.string().optional()
+/** ConfigUISchema tree passed through untyped on the wire (the
+*  notification-output `ConfigSchemaPassthrough` precedent at
+*  notification-output.cap.ts:151); the exported TS type re-tightens it. */
+var ConfigSchemaPassthrough$1 = z.unknown();
+var LlmProfileKindDescriptorSchema = z.object({
+	kind: LlmProfileKindSchema,
+	label: z.string(),
+	icon: z.string(),
+	/** Stamped by each provider so the concat-fanned catalog stays routable. */
+	addonId: z.string(),
+	configSchema: ConfigSchemaPassthrough$1
 });
-var AddBrokerInputSchema = z.object({
-	name: z.string().min(1),
-	url: z.string().regex(/^(mqtt|mqtts|ws|wss):\/\//, "URL must start with mqtt(s):// or ws(s)://"),
-	username: z.string().optional(),
-	password: z.string().optional(),
-	clientIdPrefix: z.string().optional()
+var LlmDefaultSelectorSchema = z.union([z.object({ consumer: z.string() }), z.object({ purpose: z.enum(["text", "vision"]) })]);
+var LlmDefaultSchema = z.object({
+	selector: LlmDefaultSelectorSchema,
+	profileId: z.string()
 });
-var AddBrokerResultSchema = z.object({ id: z.string() });
-var IdInputSchema = z.object({ id: z.string() });
-var TestResultSchema$1 = z.discriminatedUnion("ok", [z.object({
-	ok: z.literal(true),
-	latencyMs: z.number()
-}), z.object({
-	ok: z.literal(false),
-	error: z.string()
-})]);
-var StartEmbeddedInputSchema = z.object({
-	port: z.number().int().min(1).max(65535).default(1883),
-	/** Allow anonymous connect (no username/password). Default: false. */
-	allowAnonymous: z.boolean().default(false),
-	/** Optional shared username/password for clients. */
-	username: z.string().optional(),
-	password: z.string().optional()
+/** Server-side rollup row — getUsage never dumps raw call rows (spec §6). */
+var LlmUsageRollupSchema = z.object({
+	day: z.string(),
+	consumer: z.string(),
+	profileId: z.string(),
+	calls: z.number(),
+	okCalls: z.number(),
+	errorCalls: z.number(),
+	inputTokens: z.number(),
+	outputTokens: z.number(),
+	avgLatencyMs: z.number()
 });
-var StartEmbeddedResultSchema = z.object({
+/** LLM-facing view over the reused ModelCatalogEntry mechanism (spec §4.2). */
+var ManagedModelCatalogEntrySchema = z.object({
 	id: z.string(),
-	url: z.string()
+	label: z.string(),
+	family: z.string(),
+	purpose: z.enum(["text", "vision"]),
+	url: z.string(),
+	sha256: z.string(),
+	sizeBytes: z.number(),
+	quantization: z.string(),
+	/** Load-time guidance shown in the picker. */
+	minRamBytes: z.number(),
+	contextSizeDefault: z.number().int(),
+	/** Vision models: companion projector file. */
+	mmprojUrl: z.string().optional()
 });
-var StatusSchema = z.object({
-	brokerCount: z.number(),
-	embeddedRunning: z.boolean()
+var LlmRuntimeNodeSchema = z.object({
+	nodeId: z.string(),
+	reachable: z.boolean(),
+	status: LlmRuntimeStatusSchema.optional(),
+	disk: LlmRuntimeDiskUsageSchema.optional(),
+	error: z.string().optional()
 });
-var mqttBrokerCapability = {
-	name: "mqtt-broker",
+var GenerateVisionInputSchema = LlmGenerateBaseInputSchema.extend({ images: z.array(LlmImageSchema).min(1) });
+var ProfileRefInputSchema = z.object({
+	addonId: z.string(),
+	profileId: z.string()
+});
+var llmCapability = {
+	name: "llm",
 	scope: "system",
 	mode: "collection",
-	providerKind: "broker",
-	status: {
-		schema: StatusSchema,
-		kind: "poll"
-	},
+	internal: false,
+	providerKind: "ai",
+	/** `nodeId` inputs below are DATA (the hub provider pins itself), never routing. */
+	nodeIdMode: "data",
 	methods: {
-		listBrokers: method(z.void(), z.array(BrokerInfoSchema)),
-		getBrokerConfig: method(IdInputSchema, BrokerConnectionDetailsSchema),
-		addBroker: method(AddBrokerInputSchema, AddBrokerResultSchema, { kind: "mutation" }),
-		removeBroker: method(IdInputSchema, z.void(), { kind: "mutation" }),
-		testConnection: method(IdInputSchema, TestResultSchema$1, { kind: "mutation" }),
-		startEmbeddedBroker: method(StartEmbeddedInputSchema, StartEmbeddedResultSchema, { kind: "mutation" }),
-		stopEmbeddedBroker: method(IdInputSchema, z.void(), { kind: "mutation" }),
-		getStatus: method(z.void(), StatusSchema)
+		generate: method(LlmGenerateBaseInputSchema, LlmGenerateResultSchema, { kind: "mutation" }),
+		generateVision: method(GenerateVisionInputSchema, LlmGenerateResultSchema, { kind: "mutation" }),
+		listProfileKinds: method(z.object({}), z.array(LlmProfileKindDescriptorSchema)),
+		listProfiles: method(z.object({}), z.array(LlmProfileSchema)),
+		upsertProfile: method(z.object({ profile: LlmProfileSchema }), LlmProfileSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteProfile: method(ProfileRefInputSchema, z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		testProfile: method(ProfileRefInputSchema, LlmGenerateResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Live vendor enumeration (GET /models etc.). */
+		listModels: method(ProfileRefInputSchema, z.array(z.string())),
+		getDefaults: method(z.object({}), z.array(LlmDefaultSchema)),
+		setDefault: method(z.object({
+			selector: LlmDefaultSelectorSchema,
+			profileId: z.string().nullable()
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getUsage: method(z.object({
+			since: z.number().optional(),
+			until: z.number().optional(),
+			consumer: z.string().optional(),
+			profileId: z.string().optional()
+		}), z.array(LlmUsageRollupSchema)),
+		listModelCatalog: method(z.object({}), z.array(ManagedModelCatalogEntrySchema)),
+		listRuntimeNodes: method(z.object({}), z.array(LlmRuntimeNodeSchema)),
+		listNodeModels: method(z.object({ nodeId: z.string() }), z.array(LlmNodeModelSchema)),
+		installModel: method(z.object({
+			nodeId: z.string(),
+			model: ManagedModelRefSchema
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteModel: method(z.object({
+			nodeId: z.string(),
+			file: z.string()
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getRuntimeStatus: method(ProfileRefInputSchema, LlmRuntimeStatusSchema),
+		startRuntime: method(ProfileRefInputSchema, LlmRuntimeStatusSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		stopRuntime: method(ProfileRefInputSchema, z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
-var NetworkEndpointSchema = z.object({
-	url: z.string(),
-	hostname: z.string(),
-	port: z.number(),
-	protocol: z.enum(["http", "https"])
-});
-var NetworkAccessStatusSchema = z.object({
-	connected: z.boolean(),
-	endpoint: NetworkEndpointSchema.nullable(),
-	error: z.string().optional()
-});
-/**
-* Optional, richer endpoint shape returned by providers that expose
-* MORE than one ingress concurrently (Tailscale Ingress with mixed
-* serve+funnel rules, future ngrok multi-tunnel, …). Each entry carries
-* the originating provider config (mode + sourcePort) so the
-* orchestrator UI can label rows distinctly. Providers that expose only
-* one endpoint just omit `listEndpoints` from their provider impl.
-*/
-var NetworkEndpointEntrySchema = NetworkEndpointSchema.extend({
-	/**
-	* Stable id within the provider — typically `<mode>-<sourcePort>` so
-	* the orchestrator can dedupe across `listEndpoints` polls.
-	*/
-	id: z.string(),
-	/** Operator-facing label (mirrors `MeshEndpoint.label`). */
-	label: z.string(),
-	/** Optional provider-specific mode tag, used for icon/colour in admin UI. */
-	mode: z.string().optional(),
-	/** Originating local port the ingress fronts (informational). */
-	sourcePort: z.number().optional()
+var LogLevelSchema = z.enum([
+	"debug",
+	"info",
+	"warn",
+	"error"
+]);
+var LogEntrySchema = z.object({
+	timestamp: z.date(),
+	level: LogLevelSchema,
+	scope: z.array(z.string()),
+	message: z.string(),
+	meta: z.record(z.string(), z.unknown()).optional(),
+	tags: z.record(z.string(), z.string()).optional()
 });
-var networkAccessCapability = {
-	name: "network-access",
+var logDestinationCapability = {
+	name: "log-destination",
 	scope: "system",
 	mode: "collection",
-	providerKind: "ingress",
+	internal: true,
 	methods: {
-		start: method(z.void(), NetworkEndpointSchema, { kind: "mutation" }),
-		stop: method(z.void(), z.void(), { kind: "mutation" }),
-		getEndpoint: method(z.void(), NetworkEndpointSchema.nullable()),
-		getStatus: method(z.void(), NetworkAccessStatusSchema),
-		/**
-		* Enumerate every active ingress entry. Providers that expose only a
-		* single endpoint may omit this method; callers fall back to
-		* `getEndpoint()` in that case.
-		*/
-		listEndpoints: method(z.void(), z.array(NetworkEndpointEntrySchema).readonly())
-	}
+		write: method(LogEntrySchema, z.void(), { kind: "mutation" }),
+		query: method(z.object({
+			scope: z.array(z.string()).optional(),
+			level: LogLevelSchema.optional(),
+			since: z.date().optional(),
+			until: z.date().optional(),
+			limit: z.number().optional(),
+			tags: z.record(z.string(), z.string()).optional()
+		}), z.array(LogEntrySchema).readonly())
+	},
+	/** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
+	mount: { kind: "skip" }
 };
 /**
-* notification-output — canonical, capability-gated notification delivery.
+* `login-method` — collection cap through which auth addons contribute
+* their pre-auth login surfaces to the login page. This is the SINGLE,
+* generic mechanism that supersedes the dead `auth.listProviders` reader:
+* every auth addon (OIDC, magic-link, WebAuthn/passkey) registers a
+* `login-method` provider and the PUBLIC `auth.listLoginMethods`
+* procedure aggregates them for the unauthenticated login page.
 *
-* Apprise-derived model (see
-* `docs/superpowers/specs/2026-07-03-notification-output-notifier-matrix.md`):
-* callers emit ONE canonical `Notification`; each provider declares a
-* per-kind capability descriptor (`TargetKind`), and the pure degrade
-* engine (`@camstack/types` `prepareNotification`) transcodes / degrades the
-* message to what the kind supports — callers never special-case a service.
+* A contribution is a discriminated union on `kind`:
 *
-* DESIGN DECISIONS (locked):
-*  - Target CRUD lives on THIS cap (`upsertTarget` / `deleteTarget` /
-*    `setTargetEnabled`), each provider persisting via the `settings-store`
-*    cap. Rationale: the admin UI needs one uniform surface across the
-*    notifiers addon AND the HA addon; the addon-`globalSettingsSchema`-array
-*    alternative would fork the UI per addon and cannot host the
-*    discovery→adopt flow.
-*  - `listTargetKinds` / `listTargets` / `discoverTargets` return arrays →
-*    the generated cap-mount auto-`concatCollection`-fans them across every
-*    registered provider (notifiers addon + HA addon) so one catalog is
-*    routable. `send` / `testTarget` / CRUD route to ONE provider by the
-*    `addonId` the generated collection router extracts from the call input.
-*  - `Attachment.bytes` is `Uint8Array`. Transport-safe: superjson (the tRPC
-*    transformer) + UDS MsgPack both round-trip typed arrays — already used by
-*    `storage` / `storage-provider` / `recording` caps over the same path. No
-*    base64 fallback needed.
+*  - `redirect` — a declarative button. The login page renders a generic
+*    button that navigates to `startUrl` (an addon-owned HTTP route).
+*    Covers OIDC (`/addon/auth-oidc/<id>/start`) and magic-link with
+*    ZERO shell-side JS. A future SSO addon plugs in the same way — the
+*    login page needs NO change.
 *
-* TODO (deferred, closed-set change — separate decision): add
-* `providerKind: 'notify'` so notification providers surface on the unified
-* admin "Integrations" page.
-*/
-/**
-* Zentik-derived typed-media enum — the superset across every kind. Each
-* adapter picks what it supports and the degrade engine filters the rest.
+*  - `widget` — a Module-Federation widget the login page mounts (via
+*    `loadRemoteBundle`) for an in-page ceremony. `auth.listLoginMethods`
+*    stamps a public `bundleUrl` from `addonId` + `bundle`. Generic
+*    mechanism kept for future use; no shipped addon uses it on the login
+*    page (the passkey ceremony below runs natively in the shell instead).
+*
+*  - `passkey` — a declarative WebAuthn ceremony the shell renders
+*    natively (`@simplewebauthn/browser` lives in `addon-admin-ui`, not in
+*    a remotely-loaded bundle). Carries the addon's effective `rpId` /
+*    `origin` (from its `resolveRpID()` / `resolveOrigin()`) so the shell
+*    can gate visibility (IP-literal origin, hostname/rpId mismatch) WITHOUT
+*    fetching any remote code pre-auth. Contribution stays unconditional —
+*    enrollment state is never leaked pre-auth; visibility is a shell
+*    decision.
+*
+* Every contribution carries a `stage`:
+*  - `primary`        — shown on the first credentials screen (OIDC /
+*                       magic-link buttons; a future usernameless passkey).
+*  - `second-factor`  — shown AFTER the password leg, gated on the
+*                       returned `factors` (passkey-as-2FA today).
+*
+* `mount: skip` — the cap is read server-side by the core auth router
+* (`registry.getCollection('login-method')`), never mounted as its own
+* tRPC router.
 */
-var AttachmentMediaTypeSchema = z.enum([
-	"image",
-	"video",
-	"gif",
-	"audio",
-	"icon"
-]);
+/** When a login method renders in the two-phase login flow. */
+var LoginStageEnum = z.enum(["primary", "second-factor"]);
 /**
-* A single attachment. Exactly one of `url` (remote source, most adapters
-* prefer this) or `bytes` (inline source; required for Pushover-style
-* bytes-only kinds) MUST be present — the degrade engine expresses a
-* url→bytes fetch as a `needsFetch` directive the adapter executes.
+* A declarative redirect button — the login page navigates to `startUrl`.
+* OIDC and magic-link contribute this; a future SSO addon does too.
 */
-var AttachmentSchema = z.object({
-	mediaType: AttachmentMediaTypeSchema,
-	url: z.string().optional(),
-	bytes: z.instanceof(Uint8Array).optional(),
-	mime: z.string().optional(),
-	name: z.string().optional()
-}).refine((a) => a.url !== void 0 || a.bytes !== void 0, { message: "Attachment requires either `url` or `bytes`" });
-var NotificationFormatSchema = z.enum([
-	"text",
-	"markdown",
-	"html"
-]);
-/** A single tap-through action button. */
-var NotificationActionSchema = z.object({
+var RedirectLoginMethodSchema = z.object({
+	kind: z.literal("redirect"),
+	/** Stable id within the login-method set (e.g. `auth-oidc/google`). */
 	id: z.string(),
+	/** Operator-facing button label. */
 	label: z.string(),
-	url: z.string().optional()
+	/** lucide-react icon name. */
+	icon: z.string().optional(),
+	/** Addon-owned HTTP route the button navigates to (GET). */
+	startUrl: z.string(),
+	stage: LoginStageEnum
 });
 /**
-* The canonical notification. `body` is the only hard field (Apprise model).
-* `priority` is a 5-level ORDINAL (1=lowest … 3=normal(default) … 5=urgent),
-* NOT a fixed severity enum — each kind declares its own `caps.levels` and
-* the adapter maps this ordinal onto its native level. `level?` is an
-* optional kind-native level id (`emergency`, `silent`, …) that overrides
-* `priority` for that one target.
+* A Module-Federation widget the login page mounts for an in-page
+* ceremony. `bundle` + `addonId` let `auth.listLoginMethods` stamp a
+* public `bundleUrl`; `remote` is the MF descriptor `loadRemoteBundle`
+* consumes. No `bundleUrl` here — it is server-stamped on the public
+* output so the addon never encodes the static-route scheme.
 */
-var NotificationSchema = z.object({
-	body: z.string(),
-	title: z.string().optional(),
-	format: NotificationFormatSchema.default("text"),
-	priority: z.number().int().min(1).max(5).default(3),
-	level: z.string().optional(),
-	attachments: z.array(AttachmentSchema).optional(),
-	clickUrl: z.string().optional(),
-	actions: z.array(NotificationActionSchema).optional(),
-	sound: z.string().optional(),
-	ttl: z.number().optional(),
-	tag: z.string().optional(),
-	deviceId: z.number().optional(),
-	eventId: z.string().optional(),
-	metadata: z.record(z.string(), z.unknown()).optional()
-});
-/** One declared native severity/priority level for a kind. */
-var TargetKindLevelSchema = z.object({
+var WidgetLoginMethodSchema = z.object({
+	kind: z.literal("widget"),
+	/** Stable id within the login-method set (e.g. `auth-webauthn/passkey-login`). */
 	id: z.string(),
-	label: z.string(),
-	/** Which canonical priority (1..5) this level maps to. `null` = qualitative-only. */
-	ordinal: z.number().int().min(1).max(5).nullable(),
-	flags: z.object({
-		critical: z.boolean().optional(),
-		silent: z.boolean().optional(),
-		noPush: z.boolean().optional()
-	}).optional(),
-	/** e.g. Pushover `emergency` requires `retry` / `expire`. */
-	requires: z.array(z.string()).optional(),
-	description: z.string().optional()
-});
-/** Attachment capabilities for a kind (drives the degrade engine + test panel). */
-var TargetKindAttachmentsCapsSchema = z.object({
-	mediaTypes: z.array(AttachmentMediaTypeSchema),
-	mode: z.enum([
-		"url",
-		"bytes",
-		"both"
-	]),
-	max: z.number().int().nonnegative(),
-	maxBytes: z.number().int().positive().optional()
-});
-/** The full capability block consulted before dispatch. */
-var TargetKindCapsSchema = z.object({
-	attachments: TargetKindAttachmentsCapsSchema,
-	/** Max action buttons (0 = none). */
-	actions: z.number().int().nonnegative(),
-	levels: z.array(TargetKindLevelSchema),
-	format: z.array(NotificationFormatSchema),
-	clickUrl: z.boolean(),
-	sound: z.boolean(),
-	ttl: z.boolean(),
-	bodyMaxLen: z.number().int().positive()
-});
-/**
-* `configSchema` is a `ConfigUISchema` tree passed through to the admin
-* FormBuilder. Stored as `z.unknown()` at the cap seam (mirrors
-* `device-provider.getChildCreationSchema` `CreationSchemaOutputSchema`) —
-* the union is large and not meant for runtime validation here; the exported
-* `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
-*/
-var ConfigSchemaPassthrough$1 = z.unknown();
-var TargetKindSchema = z.object({
-	kind: z.string(),
-	label: z.string(),
-	icon: z.string(),
-	/** Stamped by each provider so the concat-fanned catalog stays routable. */
+	/** Owning addon id — drives the public bundle URL + the MF namespace. */
 	addonId: z.string(),
-	configSchema: ConfigSchemaPassthrough$1,
-	supportsDiscovery: z.boolean(),
-	caps: TargetKindCapsSchema
+	/** Bundle filename inside the addon's dist dir (`remoteEntry.js`). */
+	bundle: z.string(),
+	/** MF remote descriptor — `{ remoteName, exposedModule, componentKey }`. */
+	remote: WidgetRemoteSchema,
+	stage: LoginStageEnum
 });
 /**
-* A persisted target. `config` holds secrets; providers REDACT secret fields
-* (return a presence marker only) when serving `listTargets` — never
-* round-trip a stored secret to the UI.
+* A declarative WebAuthn ceremony the shell renders natively (no remote
+* code). Carries the addon's EFFECTIVE `rpId`/`origin` so the shell can
+* gate visibility (IP-literal origin, hostname/rpId mismatch) before ever
+* showing the button — the contribution itself stays unconditional.
 */
-var TargetSchema = z.object({
+var PasskeyLoginMethodSchema = z.object({
+	kind: z.literal("passkey"),
+	/** Stable id within the login-method set (e.g. `auth-webauthn/passkey-direct-login`). */
 	id: z.string(),
-	name: z.string(),
-	kind: z.string(),
-	addonId: z.string(),
-	enabled: z.boolean(),
-	config: z.record(z.string(), z.unknown())
-});
-/** A discovery-surfaced candidate (config is partial + non-secret). */
-var DiscoveredTargetSchema = z.object({
-	kind: z.string(),
-	suggestedName: z.string(),
-	config: z.record(z.string(), z.unknown())
-});
-/** The degrade engine's report — what was resolved / dropped / degraded. */
-var RenderedAsSchema = z.object({
-	level: z.string(),
-	format: NotificationFormatSchema,
-	attachmentsSent: z.number().int().nonnegative(),
-	actionsSent: z.number().int().nonnegative(),
-	truncated: z.boolean(),
-	dropped: z.array(z.string())
-});
-var SendResultSchema = z.object({
-	success: z.boolean(),
-	error: z.string().optional(),
-	renderedAs: RenderedAsSchema.optional()
+	/** Operator-facing button label. */
+	label: z.string(),
+	stage: LoginStageEnum,
+	/** Effective WebAuthn RP ID (`resolveRpID()`) — the shell gates visibility on it. */
+	rpId: z.string(),
+	/** Effective expected origin (`resolveOrigin()`), null when unconfigured. */
+	origin: z.string().nullable()
 });
-/** Same shape as SendResult — kept as a distinct name for the test panel. */
-var TestResultSchema = SendResultSchema;
-var notificationOutputCapability = {
-	name: "notification-output",
+/** One login-method contribution — redirect button, pre-auth widget, or native passkey ceremony. */
+var LoginMethodContributionSchema = z.discriminatedUnion("kind", [
+	RedirectLoginMethodSchema,
+	WidgetLoginMethodSchema,
+	PasskeyLoginMethodSchema
+]);
+var loginMethodCapability = {
+	name: "login-method",
 	scope: "system",
 	mode: "collection",
-	methods: {
-		listTargetKinds: method(z.object({}), z.array(TargetKindSchema)),
-		listTargets: method(z.object({}), z.array(TargetSchema)),
-		discoverTargets: method(z.object({
-			kind: z.string(),
-			config: z.record(z.string(), z.unknown()).optional()
-		}), z.array(DiscoveredTargetSchema)),
-		send: method(z.object({
-			targetId: z.string(),
-			notification: NotificationSchema
-		}), SendResultSchema, { kind: "mutation" }),
-		testTarget: method(z.object({
-			targetId: z.string(),
-			sample: NotificationSchema.optional()
-		}), TestResultSchema, { kind: "mutation" }),
-		upsertTarget: method(z.object({ target: TargetSchema }), TargetSchema, { kind: "mutation" }),
-		deleteTarget: method(z.object({ targetId: z.string() }), z.void(), { kind: "mutation" }),
-		setTargetEnabled: method(z.object({
-			targetId: z.string(),
-			enabled: z.boolean()
-		}), z.void(), { kind: "mutation" })
-	}
+	internal: true,
+	methods: { getLoginMethods: method(z.void(), z.array(LoginMethodContributionSchema).readonly()) },
+	/** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
+	mount: { kind: "skip" }
 };
-/**
-* notification-rules — the Notification Center rule surface (P1 core).
-*
-* Spec: `docs/superpowers/specs/2026-07-22-notification-center-requirements.md`
-* (operator decisions D-1/D-2/D-3 are binding):
-*
-*  - D-2: rule EVALUATION lives in `addon-post-analysis` (the
-*    `notification-center` module), hooked on the durable persistence
-*    moments (object-event insert, TrackCloser.closeExpired) with a
-*    persisted outbox + retry — never the lossy telemetry bus (D8).
-*  - D-3: urgency belongs to the RULE. `delivery: 'immediate'` fires on the
-*    FIRST persisted detection matching the conditions (per-track dedup,
-*    `maxPerTrack` fixed at 1 — see {@link NC_MAX_PER_TRACK_IMMEDIATE});
-*    `delivery: 'track-end'` evaluates the finalized track record at close.
-*  - DISPATCH stays behind `notification-output` (rules reference targets
-*    by id; per-backend params are a passthrough blob capped by the
-*    target kind's own caps/degrade engine).
-*
-* P1 scope: admin-authored rules only (`createdBy` stamped from the
-* server-injected caller identity — the first `caller: 'required'`
-* adopter). The P1 condition subset is: devices, classes(+exclude),
-* minConfidence, admin zones (any/all + exclude), weekly schedule
-* windows, and the optional label/identity/plate matchers. User rules,
-* private zones, per-recipient fan-out and the wider condition table are
-* P2+ (see spec §7).
-*
-* All schemas here are the single source of truth — `NcRule` etc. are
-* `z.infer` exports; no duplicate interfaces (the advanced-notifier
-* schema/interface drift is explicitly not repeated).
-*/
-/** D-3: the urgency of a rule — which persistence moment evaluates it. */
-var NcDeliverySchema = z.enum(["immediate", "track-end"]);
-/** One weekly activation window. `startMinute > endMinute` crosses midnight. */
-var NcScheduleWindowSchema = z.object({
-	/** Days of week the window STARTS on (0 = Sunday … 6 = Saturday). */
-	days: z.array(z.number().int().min(0).max(6)).min(1),
-	startMinute: z.number().int().min(0).max(1439),
-	endMinute: z.number().int().min(0).max(1439)
-});
-/** Weekly schedule — OR of windows; absence on the rule = always active. */
-var NcScheduleSchema = z.object({
-	windows: z.array(NcScheduleWindowSchema).min(1),
-	/** IANA timezone; default = hub host timezone. */
-	timezone: z.string().optional(),
-	/** Active OUTSIDE the windows (e.g. "only outside business hours"). */
-	invert: z.boolean().optional()
+var CpuBreakdownSchema = z.object({
+	total: z.number(),
+	user: z.number(),
+	system: z.number(),
+	irq: z.number(),
+	nice: z.number(),
+	loadAvg: z.tuple([
+		z.number(),
+		z.number(),
+		z.number()
+	]),
+	cores: z.number()
 });
-/** Fuzzy plate matcher — OCR noise makes exact match useless (spec row 12/13). */
-var NcPlateMatcherSchema = z.object({
-	values: z.array(z.string().min(1)).min(1),
-	/** Max Levenshtein distance after normalization (uppercase alphanumeric). */
-	maxDistance: z.number().int().min(0).max(3).default(1)
+var MemoryInfoSchema = z.object({
+	percent: z.number(),
+	totalBytes: z.number(),
+	usedBytes: z.number(),
+	availableBytes: z.number(),
+	swapUsedBytes: z.number(),
+	swapTotalBytes: z.number()
 });
-/** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
-var NcZoneConditionSchema = z.object({
-	ids: z.array(z.string().min(1)).min(1),
-	/** Quantifier over `ids` — at least one / every one visited. */
-	match: z.enum(["any", "all"]).default("any")
+var DiskIoSnapshotSchema = z.object({
+	readBytes: z.number(),
+	writeBytes: z.number(),
+	readOps: z.number(),
+	writeOps: z.number(),
+	timestampMs: z.number()
 });
-/**
-* The P1 condition set — a flat AND of groups; absent group = pass;
-* membership lists are OR within the list (spec §2.3).
-*/
-var NcConditionsSchema = z.object({
-	/** Device scope — absent = all devices. */
-	devices: z.array(z.number()).optional(),
-	/** Detector class names (any overlap with the record's class set). */
-	classes: z.array(z.string().min(1)).optional(),
-	/** Veto classes — any overlap fails the rule. */
-	classesExclude: z.array(z.string().min(1)).optional(),
-	/** Minimum detection confidence 0–1 (fails when the record has none). */
-	minConfidence: z.number().min(0).max(1).optional(),
-	/** Admin zone membership over event `zones` / track `zonesVisited`. */
-	zones: NcZoneConditionSchema.optional(),
-	/** Veto zones — any hit fails the rule. */
-	zonesExclude: z.array(z.string().min(1)).optional(),
+var NetworkIoSnapshotSchema = z.object({
+	rxBytes: z.number(),
+	txBytes: z.number(),
+	rxPackets: z.number(),
+	txPackets: z.number(),
+	rxErrors: z.number(),
+	txErrors: z.number(),
+	timestampMs: z.number()
+});
+var MetricsGpuInfoSchema = z.object({
+	utilization: z.number(),
+	model: z.string(),
+	memoryUsedBytes: z.number(),
+	memoryTotalBytes: z.number(),
+	temperature: z.number().nullable()
+});
+var ProcessResourceInfoSchema = z.object({
+	openFds: z.number(),
+	threadCount: z.number(),
+	activeHandles: z.number(),
+	activeRequests: z.number()
+});
+var PressureAvgsSchema = z.object({
+	avg10: z.number(),
+	avg60: z.number(),
+	avg300: z.number()
+});
+var PressureInfoSchema = z.object({
+	some: PressureAvgsSchema,
+	full: PressureAvgsSchema.nullable()
+});
+var SystemResourceSnapshotSchema = z.object({
+	cpu: CpuBreakdownSchema,
+	memory: MemoryInfoSchema,
+	gpu: MetricsGpuInfoSchema.nullable(),
+	network: NetworkIoSnapshotSchema,
+	disk: DiskIoSnapshotSchema,
+	pressure: z.object({
+		cpu: PressureInfoSchema.nullable(),
+		memory: PressureInfoSchema.nullable(),
+		io: PressureInfoSchema.nullable()
+	}),
+	process: ProcessResourceInfoSchema,
+	cpuTemperature: z.number().nullable(),
+	timestampMs: z.number()
+});
+var DiskSpaceInfoSchema = z.object({
+	path: z.string(),
+	totalBytes: z.number(),
+	usedBytes: z.number(),
+	availableBytes: z.number(),
+	percent: z.number()
+});
+var PidResourceStatsSchema = z.object({
+	pid: z.number(),
+	cpu: z.number(),
+	memory: z.number(),
 	/**
-	* Exact (case-insensitive) match on the record's collapsed `label`
-	* (identity name / plate text / subclass).
+	* Private (anonymous) resident bytes — the per-process V8 heap + native
+	* allocations NOT shared with other processes (Linux RssAnon). This is the
+	* "real" per-runner cost; summing it across runners is meaningful, unlike
+	* `memory` (RSS), which double-counts the shared mmap'd framework code.
+	* Undefined where /proc is unavailable (e.g. macOS).
 	*/
-	labelEquals: z.array(z.string().min(1)).optional(),
+	privateBytes: z.number().optional(),
 	/**
-	* Identity matcher. P1 boundary: matched against the record's collapsed
-	* `label` (the identity display name propagated by the face pipeline) —
-	* identity-ID matching rides in P2 when identity ids reach the record.
+	* Shared file-backed resident bytes (Linux RssFile) — mmap'd framework/lib
+	* code shared copy-on-write across runners. Undefined on macOS.
 	*/
-	identities: z.array(z.string().min(1)).optional(),
-	/** Fuzzy plate matcher against the record's `label` (plate text). */
-	plates: NcPlateMatcherSchema.optional()
+	sharedBytes: z.number().optional()
 });
-/** One delivery target: a `notification-output` Target ref + passthrough params. */
-var NcRuleTargetSchema = z.object({
-	/** `notification-output` Target id. */
-	targetId: z.string().min(1),
-	/**
-	* Per-backend passthrough. Recognized keys are mapped onto the canonical
-	* Notification (`priority`, `level`, `sound`, `clickUrl`, `ttl`); the
-	* degrade engine drops what the backend can't render.
-	*/
-	params: z.record(z.string(), z.unknown()).optional()
+var AddonInstanceSchema = z.object({
+	addonId: z.string(),
+	nodeId: z.string(),
+	role: z.enum(["hub", "worker"]),
+	pid: z.number(),
+	state: z.enum([
+		"starting",
+		"running",
+		"stopping",
+		"stopped",
+		"crashed"
+	]),
+	uptimeSec: z.number()
 });
-/**
-* Media attachment policy (P1 still-image subset). `best` = the best
-* AVAILABLE media at dispatch time (D-3); `best-matching` (track-end
-* condition-best) is deferred — operator open point.
-*/
-var NcMediaPolicySchema = z.object({ attach: z.enum([
-	"best",
-	"keyFrame",
-	"none"
-]).default("best") });
-/** Throttle — cooldown survives restarts (rebuilt from the outbox on boot). */
-var NcThrottleSchema = z.object({
-	cooldownSec: z.number().int().min(0).max(86400).default(60),
-	/** `rule` = one shared cooldown; `rule-device` = per-camera cooldown. */
-	scope: z.enum(["rule", "rule-device"]).default("rule-device")
+var NodeProcessSchema = z.object({
+	pid: z.number(),
+	ppid: z.number(),
+	pgid: z.number(),
+	classification: z.enum([
+		"root",
+		"managed",
+		"system",
+		"ghost"
+	]),
+	/** `$process` addon binding when `managed`, else null. */
+	addonId: z.string().nullable(),
+	/** Kernel-reported nodeId when the process is a known agent/worker. */
+	nodeId: z.string().nullable(),
+	/** Truncated command line. */
+	command: z.string(),
+	cpuPercent: z.number(),
+	memoryRssBytes: z.number(),
+	/** Wall-clock uptime (seconds). Parsed from `ps etime`. */
+	uptimeSec: z.number(),
+	/** True when ancestor walk reaches `ppid=1` (reparented to init/launchd). */
+	orphaned: z.boolean()
 });
-/** Client-supplied rule fields (server stamps id/createdBy/createdAt/updatedAt). */
-var NcRuleInputSchema = z.object({
-	name: z.string().min(1).max(200),
-	enabled: z.boolean().default(true),
-	delivery: NcDeliverySchema,
-	conditions: NcConditionsSchema.default({}),
-	schedule: NcScheduleSchema.optional(),
-	targets: z.array(NcRuleTargetSchema).min(1),
-	media: NcMediaPolicySchema.default({ attach: "best" }),
-	throttle: NcThrottleSchema.default({
-		cooldownSec: 60,
-		scope: "rule-device"
-	}),
-	/** `{{var}}` templating over camera/class/label/zones/confidence/time. */
-	template: z.object({
-		title: z.string().max(500).optional(),
-		body: z.string().max(2e3).optional()
-	}).optional(),
-	/** Canonical notification priority ordinal (1..5); per-target overridable. */
-	priority: z.number().int().min(1).max(5).default(3)
+var KillProcessInputSchema = z.object({
+	pid: z.number(),
+	/** Force = SIGKILL. Default is SIGTERM. */
+	force: z.boolean().optional()
 });
-/** Partial patch for `updateRule` — any subset of the input fields. */
-var NcRulePatchSchema = NcRuleInputSchema.partial();
-/** A persisted rule. */
-var NcRuleSchema = NcRuleInputSchema.extend({
-	id: z.string(),
-	/** userId of the admin who created the rule (server-stamped caller). */
-	createdBy: z.string(),
-	createdAt: z.number(),
-	updatedAt: z.number()
+var KillProcessResultSchema = z.object({
+	success: z.boolean(),
+	reason: z.string().optional(),
+	signal: z.enum(["SIGTERM", "SIGKILL"]).optional()
 });
-var NcTestResultSchema = z.object({
-	recordId: z.string(),
-	recordKind: z.enum(["object-event", "track"]),
-	deviceId: z.number(),
-	timestamp: z.number(),
-	wouldFire: z.boolean(),
-	/** Condition id that failed (first failing group), when `wouldFire` is false. */
-	failedCondition: z.string().optional(),
-	className: z.string().optional(),
-	label: z.string().optional()
+var DumpHeapSnapshotInputSchema = z.object({ 
+/** The addon whose runner should dump a heap snapshot. */
+addonId: z.string() });
+var DumpHeapSnapshotResultSchema = z.object({
+	success: z.boolean(),
+	/** Path of the written .heapsnapshot inside the runner's container/host. */
+	path: z.string().optional(),
+	/** Process pid that was signalled. */
+	pid: z.number().optional(),
+	reason: z.string().optional()
 });
-var NcConditionDescriptorSchema = z.object({
-	/** Field id inside `NcConditions` (or `'schedule'` for the rule-level group). */
-	id: z.string(),
-	group: z.enum([
-		"scope",
-		"class",
-		"zones",
-		"quality",
-		"label",
-		"schedule"
-	]),
-	label: z.string(),
-	/** Editor widget the UI renders — never hardcode per-condition forms. */
-	valueType: z.enum([
-		"deviceIdList",
-		"stringList",
-		"number01",
-		"zoneSelection",
-		"zoneIdList",
-		"schedule",
-		"plateMatcher"
-	]),
-	operator: z.enum([
-		"in",
-		"notIn",
-		"anyOf",
-		"allOf",
-		"gte",
-		"fuzzyIn",
-		"withinSchedule"
-	]),
-	/** Which delivery kinds the condition applies to. */
-	appliesTo: z.array(NcDeliverySchema),
-	phase: z.string(),
-	description: z.string().optional()
+var SystemMetricsSchema = z.object({
+	cpuPercent: z.number(),
+	memoryPercent: z.number(),
+	memoryUsedMB: z.number(),
+	memoryTotalMB: z.number(),
+	diskPercent: z.number().optional(),
+	temperature: z.number().optional(),
+	gpuPercent: z.number().optional(),
+	gpuMemoryPercent: z.number().optional()
 });
-var notificationRulesCapability = {
-	name: "notification-rules",
+var metricsProviderCapability = {
+	name: "metrics-provider",
 	scope: "system",
 	mode: "singleton",
 	methods: {
-		listRules: method(z.object({}), z.object({ rules: z.array(NcRuleSchema) }), { auth: "admin" }),
-		getRule: method(z.object({ ruleId: z.string() }), z.object({ rule: NcRuleSchema.nullable() }), { auth: "admin" }),
-		createRule: method(z.object({ rule: NcRuleInputSchema }), z.object({ rule: NcRuleSchema }), {
-			kind: "mutation",
-			auth: "admin",
-			caller: "required"
-		}),
-		updateRule: method(z.object({
-			ruleId: z.string(),
-			patch: NcRulePatchSchema
-		}), z.object({ rule: NcRuleSchema }), {
-			kind: "mutation",
-			auth: "admin",
-			caller: "required"
-		}),
-		deleteRule: method(z.object({ ruleId: z.string() }), z.object({ success: z.literal(true) }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		setRuleEnabled: method(z.object({
-			ruleId: z.string(),
-			enabled: z.boolean()
-		}), z.object({ success: z.literal(true) }), {
+		/** Fresh, full system snapshot (triggers OS-level collection). */
+		collectSnapshot: method(z.void(), SystemResourceSnapshotSchema),
+		/** Most recent cached snapshot from the background sampler, or null pre-first-sample. */
+		getCached: method(z.void(), SystemResourceSnapshotSchema.nullable()),
+		/** Light-weight cached summary for heartbeats and list views. */
+		getCurrent: method(z.void(), SystemMetricsSchema),
+		/** Disk space for the given mount/path. */
+		getDiskSpace: method(z.object({ dirPath: z.string() }), DiskSpaceInfoSchema),
+		/** GPU info (null if unavailable). */
+		getGpuInfo: method(z.void(), MetricsGpuInfoSchema.nullable()),
+		/** CPU temperature in °C (null if unavailable). */
+		getCpuTemperature: method(z.void(), z.number().nullable()),
+		/** Per-PID resource stats. Missing/dead PIDs are omitted from the result. */
+		getProcessStats: method(z.object({ pids: z.array(z.number()) }), z.array(PidResourceStatsSchema)),
+		/**
+		* List addon instances known to this node — one entry per forked worker
+		* plus a synthetic 'hub' entry representing the local hub process.
+		* Used by benchmarks/observability to detect whether a given addon runs
+		* in its own process (measurable independently) or inline with the hub.
+		*/
+		listAddonInstances: method(z.void(), z.array(AddonInstanceSchema).readonly()),
+		/**
+		* Resource stats for the process hosting the given addon.
+		* Returns null when the addon runs in-process on the hub (can't measure
+		* independently — caller should detect via listAddonInstances). Returns
+		* hub process stats for addonId '$hub'.
+		*/
+		getAddonStats: method(z.object({ addonId: z.string() }), PidResourceStatsSchema.nullable()),
+		/**
+		* Snapshot of every camstack-related process on this node with a
+		* ghost/managed/root classification. Powers the Cluster → Agent →
+		* Processes tab: cross-references `$process.list` against a `ps` scan
+		* so orphaned trees (PPID=1) or unknown children show up as `ghost`
+		* and can be killed from the UI.
+		*/
+		listNodeProcesses: method(z.void(), z.array(NodeProcessSchema).readonly()),
+		/**
+		* Send SIGTERM (or SIGKILL when `force`) to a pid inside this node's
+		* process tree. The provider refuses pids that aren't in the live
+		* `listNodeProcesses()` snapshot — callers can't use this endpoint
+		* to kill arbitrary system processes.
+		*/
+		killProcess: method(KillProcessInputSchema, KillProcessResultSchema, {
 			kind: "mutation",
 			auth: "admin"
 		}),
 		/**
-		* Dry-run a rule against recently persisted records (object events for
-		* `immediate`, closed tracks for `track-end`). Mutation kind only to
-		* carry the full rule object safely; no side effects.
+		* Tell the addon's forked runner to write a V8 heap snapshot to disk (via
+		* SIGUSR2 — the runner's diagnostic handler). Also logs its
+		* `process.memoryUsage()` + heap-space breakdown. Refuses pids not in the
+		* live `listNodeProcesses()` snapshot. Use for deep per-addon memory
+		* attribution; copy the returned path off the node to analyze.
 		*/
-		testRule: method(z.object({
-			rule: NcRuleInputSchema,
-			lookbackMinutes: z.number().int().min(1).max(1440).default(60)
-		}), z.object({ results: z.array(NcTestResultSchema) }), {
+		dumpHeapSnapshot: method(DumpHeapSnapshotInputSchema, DumpHeapSnapshotResultSchema, {
 			kind: "mutation",
 			auth: "admin"
-		}),
-		getConditionCatalog: method(z.object({}), z.object({ catalog: z.array(NcConditionDescriptorSchema) }))
+		})
 	}
 };
+var modelConvertCapability = {
+	name: "model-convert",
+	scope: "system",
+	mode: "singleton",
+	internal: true,
+	methods: { convert: method(z.object({
+		sourceUrl: z.string(),
+		metadata: ModelConvertMetadataSchema,
+		targets: z.array(ConvertTargetSchema).min(1).readonly(),
+		calibrationRef: z.string().optional(),
+		sessionId: z.string().optional()
+	}), ConvertResultSchema, {
+		kind: "mutation",
+		auth: "admin",
+		timeoutMs: 6e5
+	}) }
+};
+var modelDistributorCapability = {
+	name: "model-distributor",
+	scope: "system",
+	mode: "singleton",
+	internal: true,
+	methods: { distributeModel: method(z.object({
+		nodeId: z.string(),
+		modelId: z.string(),
+		format: z.enum(MODEL_FORMATS),
+		entry: ModelCatalogEntrySchema
+	}), z.object({
+		ok: z.boolean(),
+		/** sha256 of the staged tarball (empty for a hub-local no-op). */
+		sha256: z.string(),
+		bytes: z.number(),
+		/** The target node's modelsDir the artifact landed in. */
+		path: z.string()
+	}), {
+		kind: "mutation",
+		auth: "admin"
+	}) }
+};
 /**
-* Shared LLM generate contracts — imported by BOTH `llm.cap.ts` (consumer
-* surface) and `llm-runtime.cap.ts` (node-side managed executor) so the two
-* caps stay wire-compatible without a circular cap→cap import.
+* `mqtt-broker` — broker-registry cap.
 *
-* Errors are a discriminated-union RESULT, never thrown: the shape survives
-* every transport tier structurally, and failed calls still write usage rows.
-* Token counts only in v1 — no costUsd (operator decision, 2026-07-15).
+* NOT a pub/sub proxy. The cap exposes (a) a registry of configured
+* MQTT brokers (external + optionally an embedded `aedes`-backed one)
+* and (b) the connection details a consumer addon needs to spin up
+* its OWN `mqtt.js` client.
+*
+* Why: pub/sub routing over the system event-bus loses fidelity
+* (callback shape, QoS guarantees, will/retain semantics) and adds
+* refcount bookkeeping that addons would rather own themselves. The
+* canonical consumer (`addon-export-ha-mqtt`) needs raw `mqtt.js`
+* features anyway — give it the connection config, get out of the way.
+*
+* Consumer flow:
+*   const cfg = await ctx.api.mqttBroker.getBrokerConfig({ id })
+*   const client = mqtt.connect(cfg.url, { username: cfg.username, … })
+*   client.subscribe('zigbee2mqtt/+')
+*
+* Collection mode: multiple brokers (e.g. one local mosquitto + one
+* cloud bridge). The "embedded" entry (when present) is just another
+* broker in the registry — its lifecycle is owned by the addon that
+* spawned it.
 */
-var LlmUsageSchema = z.object({
-	inputTokens: z.number(),
-	outputTokens: z.number()
-});
-var LlmErrorCodeSchema = z.enum([
-	"timeout",
-	"rate-limited",
-	"auth",
-	"refusal",
-	"bad-request",
-	"unavailable",
-	"no-profile",
-	"budget-exceeded",
-	"adapter-error"
+var BrokerKindSchema = z.enum(["external", "embedded"]);
+/**
+* Broker live-probe status.
+*
+* - `connected` — last probe completed a clean CONNACK
+* - `disconnected` — no probe has run yet (cold cache)
+* - `auth-failed` — CONNACK refused with auth error (RC 4 / 5)
+* - `unreachable` — TCP connect timed out / refused
+* - `tls-error` — TLS handshake failed (cert / SNI / cipher)
+*/
+var BrokerStatusSchema$1 = z.enum([
+	"connected",
+	"disconnected",
+	"auth-failed",
+	"unreachable",
+	"tls-error"
 ]);
-var LlmGenerateOkSchema = z.object({
-	ok: z.literal(true),
-	text: z.string(),
-	model: z.string(),
-	usage: LlmUsageSchema,
-	truncated: z.boolean(),
-	latencyMs: z.number()
-});
-var LlmGenerateErrSchema = z.object({
-	ok: z.literal(false),
-	code: LlmErrorCodeSchema,
-	message: z.string(),
-	retryAfterMs: z.number().optional()
+var BrokerInfoSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	url: z.string(),
+	kind: BrokerKindSchema,
+	status: BrokerStatusSchema$1,
+	latencyMs: z.number().nullable(),
+	error: z.string().optional(),
+	/** Embedded brokers only: number of MQTT clients currently connected. */
+	connectedClients: z.number().int().nonnegative().optional(),
+	/** Epoch ms of the last live probe (external) or aedes snapshot (embedded). */
+	lastCheckedAt: z.number().optional()
 });
-var LlmGenerateResultSchema = z.discriminatedUnion("ok", [LlmGenerateOkSchema, LlmGenerateErrSchema]);
 /**
-* `Uint8Array` is the sanctioned binary convention — superjson + the UDS
-* MsgPack channel round-trip typed arrays (embedding-encoder.cap.ts:29,
-* notification-output.cap.ts:27-31 precedents).
+* Connection details — what a consumer needs to call
+* `mqtt.connect(url, options)`. We split URL + credentials so the
+* consumer can pass them as `mqtt.connect(url, { username, password })`
+* instead of stuffing creds into the URL (which leaks them into logs).
 */
-var LlmImageSchema = z.object({
-	bytes: z.instanceof(Uint8Array),
-	mimeType: z.string()
+var BrokerConnectionDetailsSchema = z.object({
+	url: z.string(),
+	username: z.string().optional(),
+	password: z.string().optional(),
+	/**
+	* Suggested prefix for `clientId`. Each consumer should suffix this
+	* with its own discriminator (addon id, instance id) so reconnects
+	* don't kick each other off (MQTT spec: clientId must be unique per
+	* broker).
+	*/
+	clientIdPrefix: z.string().optional()
 });
-var LlmGenerateBaseInputSchema = z.object({
-	/** Collection routing (the notification-output posture). */
-	addonId: z.string().optional(),
-	/** Explicit profile; else the resolution chain (spec §3). */
-	profileId: z.string().optional(),
-	/** MANDATORY usage tag: 'ai-summary', 'notifier-rules', 'adhoc-ui', … */
-	consumer: z.string(),
-	system: z.string().optional(),
-	/** v1: single-turn. `messages[]` is a v2 additive field. */
-	prompt: z.string(),
-	/** Structured output — adapter-mapped (response_format / forced tool / responseSchema). */
-	jsonSchema: z.record(z.string(), z.unknown()).optional(),
-	/** Per-call override of the profile default. */
-	maxTokens: z.number().int().positive().optional(),
-	temperature: z.number().optional()
+var AddBrokerInputSchema = z.object({
+	name: z.string().min(1),
+	url: z.string().regex(/^(mqtt|mqtts|ws|wss):\/\//, "URL must start with mqtt(s):// or ws(s)://"),
+	username: z.string().optional(),
+	password: z.string().optional(),
+	clientIdPrefix: z.string().optional()
 });
-/**
-* `llm-runtime` — node-side managed llama.cpp executor (spec §4). Registered
-* on EVERY node where `addon-ai` is installed; the hub `llm` provider reaches
-* a specific node's runtime with `nodePin(profile.runtime.nodeId)` — normal
-* cap routing, zero bespoke plumbing. `internal: true`: the operator reaches
-* this only through the `llm` cap's methods.
-*
-* One running llama-server child per node in v1 (models are RAM-heavy).
-* Resource ceiling = llama-server flags + idleStopMinutes ONLY (no RSS
-* watchdog — operator decision #3).
-*/
-var ManagedModelRefSchema = z.discriminatedUnion("kind", [
-	z.object({
-		kind: z.literal("catalog"),
-		catalogId: z.string()
-	}),
-	z.object({
-		kind: z.literal("url"),
-		url: z.string(),
-		sha256: z.string().optional()
-	}),
-	z.object({
-		kind: z.literal("path"),
-		path: z.string()
-	})
-]);
-var ManagedRuntimeConfigSchema = z.object({
-	/** WHERE the runtime lives — hub or any agent. */
-	nodeId: z.string(),
-	/** Closed for v1; 'ollama' is a v2 candidate. */
-	engine: z.enum(["llama-cpp"]),
-	model: ManagedModelRefSchema,
-	contextSize: z.number().int().default(4096),
-	/** 0 = CPU-only. */
-	gpuLayers: z.number().int().default(0),
-	/** Default: cpus-2, clamped ≥1 (resolved node-side). */
-	threads: z.number().int().optional(),
-	/** Concurrent slots. */
-	parallel: z.number().int().default(1),
-	/** Else lazy: first generate boots it. */
-	autoStart: z.boolean().default(false),
-	/** 0 = never; frees RAM after quiet periods. */
-	idleStopMinutes: z.number().int().default(30)
+var AddBrokerResultSchema = z.object({ id: z.string() });
+var IdInputSchema = z.object({ id: z.string() });
+var TestResultSchema$1 = z.discriminatedUnion("ok", [z.object({
+	ok: z.literal(true),
+	latencyMs: z.number()
+}), z.object({
+	ok: z.literal(false),
+	error: z.string()
+})]);
+var StartEmbeddedInputSchema = z.object({
+	port: z.number().int().min(1).max(65535).default(1883),
+	/** Allow anonymous connect (no username/password). Default: false. */
+	allowAnonymous: z.boolean().default(false),
+	/** Optional shared username/password for clients. */
+	username: z.string().optional(),
+	password: z.string().optional()
 });
-var LlmRuntimeStatusSchema = z.object({
-	/** Status is ALWAYS node-qualified. */
-	nodeId: z.string(),
-	state: z.enum([
-		"stopped",
-		"downloading",
-		"starting",
-		"ready",
-		"crashed",
-		"failed"
-	]),
-	pid: z.number().optional(),
-	port: z.number().optional(),
-	modelPath: z.string().optional(),
-	modelId: z.string().optional(),
-	downloadProgress: z.number().min(0).max(1).optional(),
-	lastError: z.string().optional(),
-	crashesInWindow: z.number(),
-	/** Child RSS (sampled best-effort). */
-	memoryBytes: z.number().optional(),
-	vramBytes: z.number().optional()
+var StartEmbeddedResultSchema = z.object({
+	id: z.string(),
+	url: z.string()
 });
-var LlmNodeModelSchema = z.object({
-	file: z.string(),
-	sizeBytes: z.number(),
-	catalogId: z.string().optional(),
-	installedAt: z.number().optional()
+var StatusSchema = z.object({
+	brokerCount: z.number(),
+	embeddedRunning: z.boolean()
 });
-var LlmRuntimeDiskUsageSchema = z.object({
-	nodeId: z.string(),
-	modelsBytes: z.number(),
-	freeBytes: z.number().optional()
+var mqttBrokerCapability = {
+	name: "mqtt-broker",
+	scope: "system",
+	mode: "collection",
+	providerKind: "broker",
+	status: {
+		schema: StatusSchema,
+		kind: "poll"
+	},
+	methods: {
+		listBrokers: method(z.void(), z.array(BrokerInfoSchema)),
+		getBrokerConfig: method(IdInputSchema, BrokerConnectionDetailsSchema),
+		addBroker: method(AddBrokerInputSchema, AddBrokerResultSchema, { kind: "mutation" }),
+		removeBroker: method(IdInputSchema, z.void(), { kind: "mutation" }),
+		testConnection: method(IdInputSchema, TestResultSchema$1, { kind: "mutation" }),
+		startEmbeddedBroker: method(StartEmbeddedInputSchema, StartEmbeddedResultSchema, { kind: "mutation" }),
+		stopEmbeddedBroker: method(IdInputSchema, z.void(), { kind: "mutation" }),
+		getStatus: method(z.void(), StatusSchema)
+	}
+};
+var NetworkEndpointSchema = z.object({
+	url: z.string(),
+	hostname: z.string(),
+	port: z.number(),
+	protocol: z.enum(["http", "https"])
 });
-var llmRuntimeCapability = {
-	name: "llm-runtime",
+var NetworkAccessStatusSchema = z.object({
+	connected: z.boolean(),
+	endpoint: NetworkEndpointSchema.nullable(),
+	error: z.string().optional()
+});
+/**
+* Optional, richer endpoint shape returned by providers that expose
+* MORE than one ingress concurrently (Tailscale Ingress with mixed
+* serve+funnel rules, future ngrok multi-tunnel, …). Each entry carries
+* the originating provider config (mode + sourcePort) so the
+* orchestrator UI can label rows distinctly. Providers that expose only
+* one endpoint just omit `listEndpoints` from their provider impl.
+*/
+var NetworkEndpointEntrySchema = NetworkEndpointSchema.extend({
+	/**
+	* Stable id within the provider — typically `<mode>-<sourcePort>` so
+	* the orchestrator can dedupe across `listEndpoints` polls.
+	*/
+	id: z.string(),
+	/** Operator-facing label (mirrors `MeshEndpoint.label`). */
+	label: z.string(),
+	/** Optional provider-specific mode tag, used for icon/colour in admin UI. */
+	mode: z.string().optional(),
+	/** Originating local port the ingress fronts (informational). */
+	sourcePort: z.number().optional()
+});
+var networkAccessCapability = {
+	name: "network-access",
 	scope: "system",
-	mode: "singleton",
-	internal: true,
+	mode: "collection",
+	providerKind: "ingress",
 	methods: {
-		complete: method(LlmGenerateBaseInputSchema.extend({
-			images: z.array(LlmImageSchema).optional(),
-			runtime: ManagedRuntimeConfigSchema,
-			/** The managed profile's timeout, threaded by the hub provider. */
-			timeoutMs: z.number().int().positive().optional()
-		}), LlmGenerateResultSchema, { kind: "mutation" }),
-		ensureStarted: method(z.object({ runtime: ManagedRuntimeConfigSchema }), LlmRuntimeStatusSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		stop: method(z.object({}), z.void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		status: method(z.object({}), LlmRuntimeStatusSchema),
-		installModel: method(z.object({ model: ManagedModelRefSchema }), z.void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		deleteModel: method(z.object({ file: z.string() }), z.void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		listLocalModels: method(z.object({}), z.array(LlmNodeModelSchema)),
-		getDiskUsage: method(z.object({}), LlmRuntimeDiskUsageSchema)
+		start: method(z.void(), NetworkEndpointSchema, { kind: "mutation" }),
+		stop: method(z.void(), z.void(), { kind: "mutation" }),
+		getEndpoint: method(z.void(), NetworkEndpointSchema.nullable()),
+		getStatus: method(z.void(), NetworkAccessStatusSchema),
+		/**
+		* Enumerate every active ingress entry. Providers that expose only a
+		* single endpoint may omit this method; callers fall back to
+		* `getEndpoint()` in that case.
+		*/
+		listEndpoints: method(z.void(), z.array(NetworkEndpointEntrySchema).readonly())
 	}
 };
 /**
-* `llm` — consumer-facing LLM surface (spec §1-§3). Collection-mode: array
-* methods concat-fan across providers; single-row methods route to ONE
-* provider by the `addonId` in the call input (the notification-output
-* posture, notification-output.cap.ts:215-250). Provided by `addon-ai`
-* (hub-placed); the cap stays open for future providers.
+* notification-output — canonical, capability-gated notification delivery.
 *
-* Profiles are ROWS (data), not addons: one row = one usable model endpoint.
-* `apiKey` is a password field — providers REDACT it on read and merge on
-* write; a stored key NEVER round-trips to a client.
+* Apprise-derived model (see
+* `docs/superpowers/specs/2026-07-03-notification-output-notifier-matrix.md`):
+* callers emit ONE canonical `Notification`; each provider declares a
+* per-kind capability descriptor (`TargetKind`), and the pure degrade
+* engine (`@camstack/types` `prepareNotification`) transcodes / degrades the
+* message to what the kind supports — callers never special-case a service.
+*
+* DESIGN DECISIONS (locked):
+*  - Target CRUD lives on THIS cap (`upsertTarget` / `deleteTarget` /
+*    `setTargetEnabled`), each provider persisting via the `settings-store`
+*    cap. Rationale: the admin UI needs one uniform surface across the
+*    notifiers addon AND the HA addon; the addon-`globalSettingsSchema`-array
+*    alternative would fork the UI per addon and cannot host the
+*    discovery→adopt flow.
+*  - `listTargetKinds` / `listTargets` / `discoverTargets` return arrays →
+*    the generated cap-mount auto-`concatCollection`-fans them across every
+*    registered provider (notifiers addon + HA addon) so one catalog is
+*    routable. `send` / `testTarget` / CRUD route to ONE provider by the
+*    `addonId` the generated collection router extracts from the call input.
+*  - `Attachment.bytes` is `Uint8Array`. Transport-safe: superjson (the tRPC
+*    transformer) + UDS MsgPack both round-trip typed arrays — already used by
+*    `storage` / `storage-provider` / `recording` caps over the same path. No
+*    base64 fallback needed.
+*
+* TODO (deferred, closed-set change — separate decision): add
+* `providerKind: 'notify'` so notification providers surface on the unified
+* admin "Integrations" page.
 */
-var LlmProfileKindSchema = z.enum([
-	"openai-compatible",
-	"openai",
-	"anthropic",
-	"google",
-	"managed-local"
+/**
+* Zentik-derived typed-media enum — the superset across every kind. Each
+* adapter picks what it supports and the degrade engine filters the rest.
+*/
+var AttachmentMediaTypeSchema = z.enum([
+	"image",
+	"video",
+	"gif",
+	"audio",
+	"icon"
 ]);
-var LlmProfileSchema = z.object({
+/**
+* A single attachment. Exactly one of `url` (remote source, most adapters
+* prefer this) or `bytes` (inline source; required for Pushover-style
+* bytes-only kinds) MUST be present — the degrade engine expresses a
+* url→bytes fetch as a `needsFetch` directive the adapter executes.
+*/
+var AttachmentSchema = z.object({
+	mediaType: AttachmentMediaTypeSchema,
+	url: z.string().optional(),
+	bytes: z.instanceof(Uint8Array).optional(),
+	mime: z.string().optional(),
+	name: z.string().optional()
+}).refine((a) => a.url !== void 0 || a.bytes !== void 0, { message: "Attachment requires either `url` or `bytes`" });
+var NotificationFormatSchema = z.enum([
+	"text",
+	"markdown",
+	"html"
+]);
+/** A single tap-through action button. */
+var NotificationActionSchema = z.object({
 	id: z.string(),
-	name: z.string(),
-	kind: LlmProfileKindSchema,
-	/** Stamped by the provider — keeps the fanned catalog routable. */
-	addonId: z.string(),
-	enabled: z.boolean(),
-	/** Vendor model id, or the managed runtime's loaded model. */
-	model: z.string(),
-	/** Required for openai-compatible; override for cloud kinds. */
-	baseUrl: z.string().optional(),
-	/** ConfigUISchema type:'password' — never round-trips (spec §5). */
-	apiKey: z.string().optional(),
-	supportsVision: z.boolean(),
-	temperature: z.number().min(0).max(2).optional(),
-	maxTokens: z.number().int().positive().optional(),
-	timeoutMs: z.number().int().positive().default(6e4),
-	extraHeaders: z.record(z.string(), z.string()).optional(),
-	/** kind === 'managed-local' only (spec §4). */
-	runtime: ManagedRuntimeConfigSchema.optional()
+	label: z.string(),
+	url: z.string().optional()
 });
-/** ConfigUISchema tree passed through untyped on the wire (the
-*  notification-output `ConfigSchemaPassthrough` precedent at
-*  notification-output.cap.ts:151); the exported TS type re-tightens it. */
+/**
+* The canonical notification. `body` is the only hard field (Apprise model).
+* `priority` is a 5-level ORDINAL (1=lowest … 3=normal(default) … 5=urgent),
+* NOT a fixed severity enum — each kind declares its own `caps.levels` and
+* the adapter maps this ordinal onto its native level. `level?` is an
+* optional kind-native level id (`emergency`, `silent`, …) that overrides
+* `priority` for that one target.
+*/
+var NotificationSchema = z.object({
+	body: z.string(),
+	title: z.string().optional(),
+	format: NotificationFormatSchema.default("text"),
+	priority: z.number().int().min(1).max(5).default(3),
+	level: z.string().optional(),
+	attachments: z.array(AttachmentSchema).optional(),
+	clickUrl: z.string().optional(),
+	actions: z.array(NotificationActionSchema).optional(),
+	sound: z.string().optional(),
+	ttl: z.number().optional(),
+	tag: z.string().optional(),
+	deviceId: z.number().optional(),
+	eventId: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+/** One declared native severity/priority level for a kind. */
+var TargetKindLevelSchema = z.object({
+	id: z.string(),
+	label: z.string(),
+	/** Which canonical priority (1..5) this level maps to. `null` = qualitative-only. */
+	ordinal: z.number().int().min(1).max(5).nullable(),
+	flags: z.object({
+		critical: z.boolean().optional(),
+		silent: z.boolean().optional(),
+		noPush: z.boolean().optional()
+	}).optional(),
+	/** e.g. Pushover `emergency` requires `retry` / `expire`. */
+	requires: z.array(z.string()).optional(),
+	description: z.string().optional()
+});
+/** Attachment capabilities for a kind (drives the degrade engine + test panel). */
+var TargetKindAttachmentsCapsSchema = z.object({
+	mediaTypes: z.array(AttachmentMediaTypeSchema),
+	mode: z.enum([
+		"url",
+		"bytes",
+		"both"
+	]),
+	max: z.number().int().nonnegative(),
+	maxBytes: z.number().int().positive().optional()
+});
+/** The full capability block consulted before dispatch. */
+var TargetKindCapsSchema = z.object({
+	attachments: TargetKindAttachmentsCapsSchema,
+	/** Max action buttons (0 = none). */
+	actions: z.number().int().nonnegative(),
+	levels: z.array(TargetKindLevelSchema),
+	format: z.array(NotificationFormatSchema),
+	clickUrl: z.boolean(),
+	sound: z.boolean(),
+	ttl: z.boolean(),
+	bodyMaxLen: z.number().int().positive()
+});
+/**
+* `configSchema` is a `ConfigUISchema` tree passed through to the admin
+* FormBuilder. Stored as `z.unknown()` at the cap seam (mirrors
+* `device-provider.getChildCreationSchema` `CreationSchemaOutputSchema`) —
+* the union is large and not meant for runtime validation here; the exported
+* `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
+*/
 var ConfigSchemaPassthrough = z.unknown();
-var LlmProfileKindDescriptorSchema = z.object({
-	kind: LlmProfileKindSchema,
+var TargetKindSchema = z.object({
+	kind: z.string(),
 	label: z.string(),
 	icon: z.string(),
 	/** Stamped by each provider so the concat-fanned catalog stays routable. */
 	addonId: z.string(),
-	configSchema: ConfigSchemaPassthrough
+	configSchema: ConfigSchemaPassthrough,
+	supportsDiscovery: z.boolean(),
+	caps: TargetKindCapsSchema
 });
-var LlmDefaultSelectorSchema = z.union([z.object({ consumer: z.string() }), z.object({ purpose: z.enum(["text", "vision"]) })]);
-var LlmDefaultSchema = z.object({
-	selector: LlmDefaultSelectorSchema,
-	profileId: z.string()
+/**
+* A persisted target. `config` holds secrets; providers REDACT secret fields
+* (return a presence marker only) when serving `listTargets` — never
+* round-trip a stored secret to the UI.
+*/
+var TargetSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	kind: z.string(),
+	addonId: z.string(),
+	enabled: z.boolean(),
+	config: z.record(z.string(), z.unknown())
 });
-/** Server-side rollup row — getUsage never dumps raw call rows (spec §6). */
-var LlmUsageRollupSchema = z.object({
-	day: z.string(),
-	consumer: z.string(),
-	profileId: z.string(),
-	calls: z.number(),
-	okCalls: z.number(),
-	errorCalls: z.number(),
-	inputTokens: z.number(),
-	outputTokens: z.number(),
-	avgLatencyMs: z.number()
+/** A discovery-surfaced candidate (config is partial + non-secret). */
+var DiscoveredTargetSchema = z.object({
+	kind: z.string(),
+	suggestedName: z.string(),
+	config: z.record(z.string(), z.unknown())
 });
-/** LLM-facing view over the reused ModelCatalogEntry mechanism (spec §4.2). */
-var ManagedModelCatalogEntrySchema = z.object({
+/** The degrade engine's report — what was resolved / dropped / degraded. */
+var RenderedAsSchema = z.object({
+	level: z.string(),
+	format: NotificationFormatSchema,
+	attachmentsSent: z.number().int().nonnegative(),
+	actionsSent: z.number().int().nonnegative(),
+	truncated: z.boolean(),
+	dropped: z.array(z.string())
+});
+var SendResultSchema = z.object({
+	success: z.boolean(),
+	error: z.string().optional(),
+	renderedAs: RenderedAsSchema.optional()
+});
+/** Same shape as SendResult — kept as a distinct name for the test panel. */
+var TestResultSchema = SendResultSchema;
+var notificationOutputCapability = {
+	name: "notification-output",
+	scope: "system",
+	mode: "collection",
+	methods: {
+		listTargetKinds: method(z.object({}), z.array(TargetKindSchema)),
+		listTargets: method(z.object({}), z.array(TargetSchema)),
+		discoverTargets: method(z.object({
+			kind: z.string(),
+			config: z.record(z.string(), z.unknown()).optional()
+		}), z.array(DiscoveredTargetSchema)),
+		send: method(z.object({
+			targetId: z.string(),
+			notification: NotificationSchema
+		}), SendResultSchema, { kind: "mutation" }),
+		testTarget: method(z.object({
+			targetId: z.string(),
+			sample: NotificationSchema.optional()
+		}), TestResultSchema, { kind: "mutation" }),
+		upsertTarget: method(z.object({ target: TargetSchema }), TargetSchema, { kind: "mutation" }),
+		deleteTarget: method(z.object({ targetId: z.string() }), z.void(), { kind: "mutation" }),
+		setTargetEnabled: method(z.object({
+			targetId: z.string(),
+			enabled: z.boolean()
+		}), z.void(), { kind: "mutation" })
+	}
+};
+/**
+* notification-rules — the Notification Center rule surface (P1 core).
+*
+* Spec: `docs/superpowers/specs/2026-07-22-notification-center-requirements.md`
+* (operator decisions D-1/D-2/D-3 are binding):
+*
+*  - D-2: rule EVALUATION lives in `addon-post-analysis` (the
+*    `notification-center` module), hooked on the durable persistence
+*    moments (object-event insert, TrackCloser.closeExpired) with a
+*    persisted outbox + retry — never the lossy telemetry bus (D8).
+*  - D-3: urgency belongs to the RULE. `delivery: 'immediate'` fires on the
+*    FIRST persisted detection matching the conditions (per-track dedup,
+*    `maxPerTrack` fixed at 1 — see {@link NC_MAX_PER_TRACK_IMMEDIATE});
+*    `delivery: 'track-end'` evaluates the finalized track record at close.
+*  - DISPATCH stays behind `notification-output` (rules reference targets
+*    by id; per-backend params are a passthrough blob capped by the
+*    target kind's own caps/degrade engine).
+*
+* P1 scope: admin-authored rules only (`createdBy` stamped from the
+* server-injected caller identity — the first `caller: 'required'`
+* adopter). The P1 condition subset is: devices, classes(+exclude),
+* minConfidence, admin zones (any/all + exclude), weekly schedule
+* windows, and the optional label/identity/plate matchers. User rules,
+* private zones, per-recipient fan-out and the wider condition table are
+* P2+ (see spec §7).
+*
+* All schemas here are the single source of truth — `NcRule` etc. are
+* `z.infer` exports; no duplicate interfaces (the advanced-notifier
+* schema/interface drift is explicitly not repeated).
+*/
+/**
+* D-3: the trigger/urgency of a rule — which persistence moment evaluates it.
+* The value maps 1:1 onto the evaluated record kind:
+*  - `immediate`     ↔ object-event persist (lowest-latency detection burst)
+*  - `track-end`     ↔ TrackCloser.closeExpired (finalized track record)
+*  - `device-event`  ↔ SensorEventStore insert (doorbell press / sensor state
+*                       change of a LINKED device, one row per linked camera)
+*  - `package-event` ↔ PackageDropDetector object-event insert (a `package`
+*                       delivery / pick-up)
+*
+* `immediate`/`track-end` carry the D-3 urgency semantics; `device-event`/
+* `package-event` are pure trigger kinds (no urgency dimension). Extending
+* this one field keeps the schema additive — a rule still declares exactly
+* one trigger.
+*/
+var NcDeliverySchema = z.enum([
+	"immediate",
+	"track-end",
+	"device-event",
+	"package-event"
+]);
+/** One weekly activation window. `startMinute > endMinute` crosses midnight. */
+var NcScheduleWindowSchema = z.object({
+	/** Days of week the window STARTS on (0 = Sunday … 6 = Saturday). */
+	days: z.array(z.number().int().min(0).max(6)).min(1),
+	startMinute: z.number().int().min(0).max(1439),
+	endMinute: z.number().int().min(0).max(1439)
+});
+/** Weekly schedule — OR of windows; absence on the rule = always active. */
+var NcScheduleSchema = z.object({
+	windows: z.array(NcScheduleWindowSchema).min(1),
+	/** IANA timezone; default = hub host timezone. */
+	timezone: z.string().optional(),
+	/** Active OUTSIDE the windows (e.g. "only outside business hours"). */
+	invert: z.boolean().optional()
+});
+/** Fuzzy plate matcher — OCR noise makes exact match useless (spec row 12/13). */
+var NcPlateMatcherSchema = z.object({
+	values: z.array(z.string().min(1)).min(1),
+	/** Max Levenshtein distance after normalization (uppercase alphanumeric). */
+	maxDistance: z.number().int().min(0).max(3).default(1)
+});
+/**
+* Occupancy condition (DEVICE-EVENT trigger). Fires on a ZoneAnalytics
+* occupancy edge for a device — optionally narrowed to a single admin
+* `zoneId` and/or object `className`. `op` selects the edge/threshold:
+*  - `became-occupied` (default) — count crossed 0 → ≥ `count`
+*  - `became-free`               — count crossed ≥ `count` → below it
+*  - `>=` / `<=`                 — count is at/over or at/under `count`
+* `sustainSeconds` requires the condition hold continuously that long
+* before firing (debounces flicker; 0 = fire on the first matching edge).
+* Fail-closed: no ZoneAnalytics snapshot / missing zone / null snapshot ⇒
+* the condition never matches. Confirmed edge-state survives addon restarts
+* (declared SQLite collection, reseeded on boot).
+*/
+var NcOccupancyConditionSchema = z.object({
+	/** Admin zone id to scope the count to; absent = whole-frame occupancy. */
+	zoneId: z.string().optional(),
+	/** Object class to count; absent = any class. */
+	className: z.string().optional(),
+	op: z.enum([
+		"became-occupied",
+		"became-free",
+		">=",
+		"<="
+	]).default("became-occupied"),
+	count: z.number().int().min(0).default(1),
+	sustainSeconds: z.number().int().min(0).max(3600).default(15)
+});
+/** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
+var NcZoneConditionSchema = z.object({
+	ids: z.array(z.string().min(1)).min(1),
+	/** Quantifier over `ids` — at least one / every one visited. */
+	match: z.enum(["any", "all"]).default("any")
+});
+/**
+* The P1 condition set — a flat AND of groups; absent group = pass;
+* membership lists are OR within the list (spec §2.3).
+*/
+var NcConditionsSchema = z.object({
+	/** Device scope — absent = all devices. */
+	devices: z.array(z.number()).optional(),
+	/** Detector class names (any overlap with the record's class set). */
+	classes: z.array(z.string().min(1)).optional(),
+	/** Veto classes — any overlap fails the rule. */
+	classesExclude: z.array(z.string().min(1)).optional(),
+	/** Minimum detection confidence 0–1 (fails when the record has none). */
+	minConfidence: z.number().min(0).max(1).optional(),
+	/** Admin zone membership over event `zones` / track `zonesVisited`. */
+	zones: NcZoneConditionSchema.optional(),
+	/** Veto zones — any hit fails the rule. */
+	zonesExclude: z.array(z.string().min(1)).optional(),
+	/**
+	* Exact (case-insensitive) match on the record's collapsed `label`
+	* (identity name / plate text / subclass).
+	*/
+	labelEquals: z.array(z.string().min(1)).optional(),
+	/**
+	* Identity matcher. P1 boundary: matched against the record's collapsed
+	* `label` (the identity display name propagated by the face pipeline) —
+	* identity-ID matching rides in P2 when identity ids reach the record.
+	*/
+	identities: z.array(z.string().min(1)).optional(),
+	/** Fuzzy plate matcher against the record's `label` (plate text). */
+	plates: NcPlateMatcherSchema.optional(),
+	/**
+	* Identity EXCLUDE — mirror of {@link identities} with `notIn` semantics.
+	* Same P1 boundary: matched against the record's collapsed `label` (the
+	* identity display name). A record with NO label passes (nothing to
+	* exclude), unlike the include variant which fails on an absent label.
+	*/
+	identitiesExclude: z.array(z.string().min(1)).optional(),
+	/**
+	* Minimum server-computed key-event importance in [0,1] (`Track.importance`).
+	* TRACK-END only: importance is scored at track close, so it does not exist
+	* at immediate / object-event evaluation time (see catalog `appliesTo`). At
+	* close the value is threaded via the close-time info (the `Track` clone is
+	* captured before the DB row is updated, so it would otherwise read stale).
+	* Fails when the record carries no importance (never guess quality — the
+	* `minConfidence` precedent). MVP cut: a single scalar threshold.
+	*/
+	minImportance: z.number().min(0).max(1).optional(),
+	/**
+	* Minimum track dwell in SECONDS — `(lastSeen − firstSeen) / 1000`.
+	* TRACK-END only: an `immediate` / object-event subject has no closed
+	* lifespan, so a dwell condition never matches immediate delivery
+	* (documented choice — the object-event record carries no `firstSeen`,
+	* so dwell cannot be computed from what the subject actually carries).
+	*/
+	minDwellSeconds: z.number().min(0).optional(),
+	/**
+	* Detection provenance filter. `any` (default / absent) matches every
+	* source; otherwise the subject's source must equal it. Legacy records
+	* with no stamped source are treated as `pipeline`. The union spans both
+	* record kinds — object events carry `pipeline` | `onboard`, synthetic
+	* tracks carry `sensor`.
+	*/
+	source: z.enum([
+		"pipeline",
+		"onboard",
+		"sensor",
+		"any"
+	]).optional(),
+	/**
+	* Minimum identity / plate MATCH confidence in [0,1] — DISTINCT from the
+	* detector `minConfidence` (that gates the object-detection score; this
+	* gates the recognition/OCR match score). Fails when the subject carries
+	* no label-match confidence (never guess). TRACK-END only: the confidence
+	* lives on the recognition result and reaches the subject at track close.
+	*
+	* What it measures precisely (plumbed at track close — the closer threads
+	* the value into `NcTrackClosedInfo.labelConfidence`, the same seam as
+	* `importance`): the BEST recognition match confidence observed for the
+	* label the track carries at close — for a face, the peak cosine similarity
+	* of the ASSIGNED identity (`FaceMatch.score`, reset on an identity switch);
+	* for a plate, the peak OCR read score of the best-held plate
+	* (`plateText.confidence`). When BOTH a face and a plate were recognized on
+	* one track the higher of the two is used. A track that ended with no
+	* confident identity/plate match carries no value, so the condition fails
+	* closed for it (an un-recognized subject).
+	*/
+	minLabelConfidence: z.number().min(0).max(1).optional(),
+	/**
+	* DEVICE-EVENT only. Raw device event-type tokens (`EventFire.eventType`,
+	* e.g. a doorbell `press` / `press_long`) — matched case-insensitively
+	* against the token carried on the device-event subject (extracted from the
+	* event-emitter runtime slice's `lastEvent.eventType`). Fails when the
+	* subject carries no token. Doorbell-pulse / passive-sensor kinds emit no
+	* eventType, so gate those with {@link sensorKinds} instead.
+	*/
+	eventTypeTokens: z.array(z.string().min(1)).optional(),
+	/**
+	* DEVICE-EVENT only. Sensor/control taxonomy kinds (e.g. `doorbell`,
+	* `contact`, `button`, `device-event`) — matched against the persisted
+	* `SensorEvent.kind` (see `sensor-event-kinds.ts`). Membership is OR.
+	*/
+	sensorKinds: z.array(z.string().min(1)).optional(),
+	/**
+	* PACKAGE-EVENT only. Which package phase fires the rule — `delivered`
+	* (a parked parcel appeared), `picked-up` (it departed), or `both`. Fails
+	* when the subject's phase does not match (a subject always carries a phase
+	* on the package-event trigger).
+	*/
+	packagePhase: z.enum([
+		"delivered",
+		"picked-up",
+		"both"
+	]).optional(),
+	/**
+	* PERSONAL-RULE custom zones (viewer-drawn). Inline normalized polygons
+	* (MaskShape vocabulary). A record passes when its bbox overlaps ANY
+	* listed polygon (ZoneEngine membership semantics). Evaluated only when
+	* the subject carries a bbox; absent bbox ⇒ the condition FAILS.
+	*/
+	customZones: z.array(MaskPolygonShapeSchema).optional(),
+	/**
+	* DEVICE-EVENT only. ZoneAnalytics occupancy edge — fires when a device's
+	* (optionally zone/class-scoped) occupancy count crosses the configured
+	* threshold and holds for `sustainSeconds`. Fail-closed on missing
+	* substrate (no snapshot / missing zone). See {@link NcOccupancyCondition}.
+	*/
+	occupancy: NcOccupancyConditionSchema.optional()
+});
+/** One delivery target: a `notification-output` Target ref + passthrough params. */
+var NcRuleTargetSchema = z.object({
+	/** `notification-output` Target id. */
+	targetId: z.string().min(1),
+	/**
+	* Per-backend passthrough. Recognized keys are mapped onto the canonical
+	* Notification (`priority`, `level`, `sound`, `clickUrl`, `ttl`); the
+	* degrade engine drops what the backend can't render.
+	*/
+	params: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* Media attachment policy (P1 still-image subset).
+*  - `best` — the best AVAILABLE subject image at dispatch time (D-3).
+*  - `best-matching` — the media that explains WHY the rule fired: a rule
+*    matched on identities attaches the subject's `faceCrop`, one matched on
+*    plates attaches the `plateCrop`; a rule with no identity/plate condition
+*    (or when the specific crop is missing) degrades to `best`, then
+*    `keyFrame`, then no attachment — never delaying the send. The matched
+*    condition summary is frozen on the outbox row at enqueue (like the rule
+*    name), so the choice never drifts from the record that fired it.
+*  - `keyFrame` — the clean scene frame (no subject box).
+*  - `none` — no attachment.
+*/
+var NcMediaPolicySchema = z.object({ attach: z.enum([
+	"best",
+	"best-matching",
+	"keyFrame",
+	"none"
+]).default("best") });
+/** Throttle — cooldown survives restarts (rebuilt from the outbox on boot). */
+var NcThrottleSchema = z.object({
+	cooldownSec: z.number().int().min(0).max(86400).default(60),
+	/** `rule` = one shared cooldown; `rule-device` = per-camera cooldown. */
+	scope: z.enum(["rule", "rule-device"]).default("rule-device")
+});
+/** Client-supplied rule fields (server stamps id/createdBy/createdAt/updatedAt). */
+var NcRuleInputSchema = z.object({
+	name: z.string().min(1).max(200),
+	enabled: z.boolean().default(true),
+	delivery: NcDeliverySchema,
+	conditions: NcConditionsSchema.default({}),
+	schedule: NcScheduleSchema.optional(),
+	targets: z.array(NcRuleTargetSchema).min(1),
+	media: NcMediaPolicySchema.default({ attach: "best" }),
+	throttle: NcThrottleSchema.default({
+		cooldownSec: 60,
+		scope: "rule-device"
+	}),
+	/** `{{var}}` templating over camera/class/label/zones/confidence/time. */
+	template: z.object({
+		title: z.string().max(500).optional(),
+		body: z.string().max(2e3).optional()
+	}).optional(),
+	/** Canonical notification priority ordinal (1..5); per-target overridable. */
+	priority: z.number().int().min(1).max(5).default(3),
+	/**
+	* Ownership/visibility key. Absent = admin/global rule (unchanged legacy
+	* behaviour, visible to all, read-only in the viewer). Present = personal
+	* rule owned by this userId. Server-stamped; never trusted from a client.
+	*/
+	ownerUserId: z.string().optional()
+});
+/**
+* Partial patch for `updateRule` — any subset of the input fields, plus the
+* persisted-only {@link NcRuleSchema} `disabledTargetIds` set. The latter is
+* NOT a client-authored input field (it lives on the persisted rule, not the
+* input), so it is added here explicitly to let the store's per-target opt-out
+* toggle round-trip through the shared `update` path. Viewer opt-out mutations
+* still flow through `nc.setRuleTargetEnabled` (owner-checked), never a raw
+* `updateRule` patch.
+*/
+var NcRulePatchSchema = NcRuleInputSchema.partial().extend({ disabledTargetIds: z.array(z.string()).optional() });
+/** A persisted rule. */
+var NcRuleSchema = NcRuleInputSchema.extend({
+	id: z.string(),
+	/** userId of the admin who created the rule (server-stamped caller). */
+	createdBy: z.string(),
+	createdAt: z.number(),
+	updatedAt: z.number(),
+	/**
+	* Per-target opt-out set. A targetId here is suppressed for THIS rule at
+	* send time. Only a target's OWNER may add/remove its id (server-checked
+	* in `nc.setRuleTargetEnabled`). Defaults to empty.
+	*/
+	disabledTargetIds: z.array(z.string()).default([])
+});
+var NcTestResultSchema = z.object({
+	recordId: z.string(),
+	recordKind: z.enum([
+		"object-event",
+		"track",
+		"device-event",
+		"package-event"
+	]),
+	deviceId: z.number(),
+	timestamp: z.number(),
+	wouldFire: z.boolean(),
+	/** Condition id that failed (first failing group), when `wouldFire` is false. */
+	failedCondition: z.string().optional(),
+	className: z.string().optional(),
+	label: z.string().optional()
+});
+var NcConditionDescriptorSchema = z.object({
+	/** Field id inside `NcConditions` (or `'schedule'` for the rule-level group). */
 	id: z.string(),
+	group: z.enum([
+		"scope",
+		"class",
+		"zones",
+		"quality",
+		"label",
+		"schedule",
+		"device",
+		"package",
+		"occupancy"
+	]),
 	label: z.string(),
-	family: z.string(),
-	purpose: z.enum(["text", "vision"]),
-	url: z.string(),
-	sha256: z.string(),
-	sizeBytes: z.number(),
-	quantization: z.string(),
-	/** Load-time guidance shown in the picker. */
-	minRamBytes: z.number(),
-	contextSizeDefault: z.number().int(),
-	/** Vision models: companion projector file. */
-	mmprojUrl: z.string().optional()
+	/** Editor widget the UI renders — never hardcode per-condition forms. */
+	valueType: z.enum([
+		"deviceIdList",
+		"stringList",
+		"number01",
+		"number",
+		"sourceSelect",
+		"zoneSelection",
+		"zoneIdList",
+		"schedule",
+		"plateMatcher",
+		"packagePhase",
+		"polygonDraw",
+		"occupancy"
+	]),
+	operator: z.enum([
+		"in",
+		"notIn",
+		"anyOf",
+		"allOf",
+		"gte",
+		"fuzzyIn",
+		"withinSchedule"
+	]),
+	/** Which delivery kinds the condition applies to. */
+	appliesTo: z.array(NcDeliverySchema),
+	phase: z.string(),
+	description: z.string().optional()
 });
-var LlmRuntimeNodeSchema = z.object({
-	nodeId: z.string(),
-	reachable: z.boolean(),
-	status: LlmRuntimeStatusSchema.optional(),
-	disk: LlmRuntimeDiskUsageSchema.optional(),
-	error: z.string().optional()
+/**
+* The delivery lifecycle status of a history row — a straight read of the
+* durable outbox row's own status (single source of truth):
+*  - `pending` — enqueued, in-flight or retrying with backoff
+*  - `sent`    — delivered (terminal)
+*  - `dead`    — dead-lettered after exhausting retries / a permanent
+*                backend rejection / a deleted target (terminal; carries
+*                the failure `error`)
+*
+* P1 has no `suppressed-quiet-hours` / `snoozed` states — those ride the P2
+* user dimension (quiet hours / snooze) and are additive when they land.
+*/
+var NcHistoryStatusSchema = z.enum([
+	"pending",
+	"sent",
+	"dead"
+]);
+/** The evaluated record kind a history row descends from (one per trigger). */
+var NcHistoryRecordKindSchema = z.enum([
+	"object-event",
+	"track-end",
+	"device-event",
+	"package-event"
+]);
+/** Subject summary frozen on the row at fire time (survives rule/record edits). */
+var NcHistorySubjectSchema = z.object({
+	className: z.string(),
+	label: z.string().optional(),
+	confidence: z.number().optional(),
+	zones: z.array(z.string()),
+	timestamp: z.number()
 });
-var GenerateVisionInputSchema = LlmGenerateBaseInputSchema.extend({ images: z.array(LlmImageSchema).min(1) });
-var ProfileRefInputSchema = z.object({
-	addonId: z.string(),
-	profileId: z.string()
+/**
+* One delivery-history row. This is a read-only VIEW over the durable
+* outbox row (single source of truth — the same row the drain loop drives;
+* NO second write path, so history can never drift from delivery state).
+* The §3.2 fields map directly: `ruleId`/`targetId`/`deviceId` are columns,
+* `eventRef` is `recordKind`+`recordId`, `timestamps` are `createdAt`
+* (fire) / `updatedAt` (last transition), `status` + `error` are the
+* lifecycle. `ruleName` + `subject` are the intent snapshot frozen at
+* enqueue. `userId?` (per-recipient history) is P2 — no user dimension in
+* P1 (admin scope only).
+*/
+var NcHistoryEntrySchema = z.object({
+	/** Outbox row id — the stable dedup id `ruleId:dedupRef:targetId`. */
+	id: z.string(),
+	ruleId: z.string(),
+	/** Rule name frozen at fire time (outlives a later rename / delete). */
+	ruleName: z.string(),
+	/** The rule urgency/trigger that produced this delivery. */
+	delivery: NcDeliverySchema,
+	targetId: z.string(),
+	deviceId: z.number(),
+	recordKind: NcHistoryRecordKindSchema,
+	/** Event / track ref of the evaluated record (§3.2 `eventRef`). */
+	recordId: z.string(),
+	/** Present for track-scoped deliveries (object-event / track-end). */
+	trackId: z.string().optional(),
+	status: NcHistoryStatusSchema,
+	/** Delivery attempts made so far. */
+	attempts: z.number().int(),
+	/** Fire time (outbox enqueue). */
+	createdAt: z.number(),
+	/** Last transition time (terminal for sent / dead). */
+	updatedAt: z.number(),
+	/** Failure detail — present on a `dead` row. */
+	error: z.string().optional(),
+	subject: NcHistorySubjectSchema
 });
-var llmCapability = {
-	name: "llm",
+/**
+* Query filter for `getHistory` (spec §4.2). Every field is a narrowing
+* AND; absent = unbounded on that axis. `since`/`until` bound the fire time
+* (`createdAt`, epoch ms, inclusive). `limit` is clamped to
+* {@link NC_HISTORY_LIMIT_MAX}. `userId` (per-recipient filtering) is P2.
+*/
+var NcHistoryFilterSchema = z.object({
+	ruleId: z.string().optional(),
+	deviceId: z.number().optional(),
+	status: NcHistoryStatusSchema.optional(),
+	since: z.number().optional(),
+	until: z.number().optional(),
+	limit: z.number().int().min(1).max(500).default(100)
+});
+var notificationRulesCapability = {
+	name: "notification-rules",
 	scope: "system",
-	mode: "collection",
-	internal: false,
-	providerKind: "ai",
-	/** `nodeId` inputs below are DATA (the hub provider pins itself), never routing. */
-	nodeIdMode: "data",
+	mode: "singleton",
 	methods: {
-		generate: method(LlmGenerateBaseInputSchema, LlmGenerateResultSchema, { kind: "mutation" }),
-		generateVision: method(GenerateVisionInputSchema, LlmGenerateResultSchema, { kind: "mutation" }),
-		listProfileKinds: method(z.object({}), z.array(LlmProfileKindDescriptorSchema)),
-		listProfiles: method(z.object({}), z.array(LlmProfileSchema)),
-		upsertProfile: method(z.object({ profile: LlmProfileSchema }), LlmProfileSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		deleteProfile: method(ProfileRefInputSchema, z.void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		testProfile: method(ProfileRefInputSchema, LlmGenerateResultSchema, {
+		listRules: method(z.object({}), z.object({ rules: z.array(NcRuleSchema) }), { auth: "admin" }),
+		getRule: method(z.object({ ruleId: z.string() }), z.object({ rule: NcRuleSchema.nullable() }), { auth: "admin" }),
+		createRule: method(z.object({ rule: NcRuleInputSchema }), z.object({ rule: NcRuleSchema }), {
 			kind: "mutation",
-			auth: "admin"
+			auth: "admin",
+			caller: "required"
 		}),
-		/** Live vendor enumeration (GET /models etc.). */
-		listModels: method(ProfileRefInputSchema, z.array(z.string())),
-		getDefaults: method(z.object({}), z.array(LlmDefaultSchema)),
-		setDefault: method(z.object({
-			selector: LlmDefaultSelectorSchema,
-			profileId: z.string().nullable()
-		}), z.void(), {
+		updateRule: method(z.object({
+			ruleId: z.string(),
+			patch: NcRulePatchSchema
+		}), z.object({ rule: NcRuleSchema }), {
 			kind: "mutation",
-			auth: "admin"
+			auth: "admin",
+			caller: "required"
 		}),
-		getUsage: method(z.object({
-			since: z.number().optional(),
-			until: z.number().optional(),
-			consumer: z.string().optional(),
-			profileId: z.string().optional()
-		}), z.array(LlmUsageRollupSchema)),
-		listModelCatalog: method(z.object({}), z.array(ManagedModelCatalogEntrySchema)),
-		listRuntimeNodes: method(z.object({}), z.array(LlmRuntimeNodeSchema)),
-		listNodeModels: method(z.object({ nodeId: z.string() }), z.array(LlmNodeModelSchema)),
-		installModel: method(z.object({
-			nodeId: z.string(),
-			model: ManagedModelRefSchema
-		}), z.void(), {
+		deleteRule: method(z.object({ ruleId: z.string() }), z.object({ success: z.literal(true) }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		deleteModel: method(z.object({
-			nodeId: z.string(),
-			file: z.string()
-		}), z.void(), {
+		setRuleEnabled: method(z.object({
+			ruleId: z.string(),
+			enabled: z.boolean()
+		}), z.object({ success: z.literal(true) }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		getRuntimeStatus: method(ProfileRefInputSchema, LlmRuntimeStatusSchema),
-		startRuntime: method(ProfileRefInputSchema, LlmRuntimeStatusSchema, {
+		/**
+		* Dry-run a rule against recently persisted records (object events for
+		* `immediate`, closed tracks for `track-end`). Mutation kind only to
+		* carry the full rule object safely; no side effects.
+		*/
+		testRule: method(z.object({
+			rule: NcRuleInputSchema,
+			lookbackMinutes: z.number().int().min(1).max(1440).default(60)
+		}), z.object({ results: z.array(NcTestResultSchema) }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		stopRuntime: method(ProfileRefInputSchema, z.void(), {
-			kind: "mutation",
-			auth: "admin"
-		})
+		getConditionCatalog: method(z.object({}), z.object({ catalog: z.array(NcConditionDescriptorSchema) })),
+		/**
+		* Queryable delivery history — a read-only view over the durable outbox
+		* (fired rule, subject summary, target, status, timestamps, error on a
+		* dead row). Newest-first, bounded by `filter.limit`. Retention follows
+		* the outbox's own terminal-row prune horizon (no separate history
+		* horizon — single collection, single source of truth). Admin-only in
+		* P1 (no user dimension); the P2 viewer History screen adds per-caller
+		* scoping on the same method.
+		*/
+		getHistory: method(z.object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), z.object({ entries: z.array(NcHistoryEntrySchema) }), { auth: "admin" })
 	}
 };
 /**
@@ -17212,76 +17440,6 @@ var pipelineAnalyticsCapability = {
 		}) }
 	}
 };
-/**
-* Cap → event-kind mapping for the SENSOR / CONTROL cap families — the table
-* `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
-* caps into per-camera event-kind descriptors.
-*
-* The descriptor DATA (color / iconId / labelKey / parentKind / category)
-* is NOT duplicated here — every entry is derived from the single
-* `EVENT_TAXONOMY` dictionary (`catalogs/event-taxonomy.ts`). This file owns
-* ONLY the cap-name → taxonomy-kind mapping. Adding a new eventful sensor /
-* control cap means adding one line here (and a taxonomy entry); the anti-
-* drift guard `scripts/check-event-kind-coverage.ts` fails the build if an
-* eventful cap is missing.
-*/
-/** Map a taxonomy `iconId` onto the legacy closed `EventKindIcon` enum. */
-var LEGACY_ICON = {
-	motion: "motion",
-	audio: "audio",
-	person: "person",
-	vehicle: "vehicle",
-	animal: "animal",
-	package: "package",
-	door: "door",
-	pir: "pir",
-	smoke: "smoke",
-	water: "water",
-	button: "button",
-	generic: "generic",
-	gas: "smoke",
-	vibration: "generic",
-	tamper: "generic",
-	presence: "person",
-	lock: "generic",
-	siren: "generic",
-	switch: "generic",
-	doorbell: "button"
-};
-function legacyIcon(iconId) {
-	return LEGACY_ICON[iconId] ?? "generic";
-}
-/**
-* Cap name → taxonomy kind id. Covers EVERY eventful sensor / control cap.
-* The anti-drift guard cross-checks this against the eventful caps declared
-* in `packages/types/src/capabilities/*.cap.ts`.
-*/
-var CAP_TO_KIND = {
-	contact: "contact",
-	motion: "motion-sensor",
-	smoke: "smoke",
-	flood: "flood",
-	gas: "gas",
-	"carbon-monoxide": "carbon-monoxide",
-	vibration: "vibration",
-	tamper: "tamper",
-	presence: "presence",
-	"enum-sensor": "enum-sensor",
-	"event-emitter": "device-event",
-	"lock-control": "lock",
-	switch: "switch",
-	button: "button",
-	doorbell: "doorbell"
-};
-function buildDescriptor(capName, kind) {
-	const t = EVENT_TAXONOMY[kind];
-	if (t === void 0) throw new Error(`EVENT_KIND_BY_CAP: cap '${capName}' maps to unknown taxonomy kind '${kind}'`);
-	return {
-		...t,
-		icon: legacyIcon(t.iconId)
-	};
-}
-Object.freeze(Object.fromEntries(Object.entries(CAP_TO_KIND).map(([capName, kind]) => [capName, buildDescriptor(capName, kind)])));
 var CameraPipelineConfigSchema = z.object({
 	engine: PipelineEngineChoiceSchema.optional(),
 	steps: z.array(PipelineStepInputSchema).readonly(),
@@ -18037,6 +18195,76 @@ var pipelineOrchestratorCapability = {
 	}
 };
 /**
+* Cap → event-kind mapping for the SENSOR / CONTROL cap families — the table
+* `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
+* caps into per-camera event-kind descriptors.
+*
+* The descriptor DATA (color / iconId / labelKey / parentKind / category)
+* is NOT duplicated here — every entry is derived from the single
+* `EVENT_TAXONOMY` dictionary (`catalogs/event-taxonomy.ts`). This file owns
+* ONLY the cap-name → taxonomy-kind mapping. Adding a new eventful sensor /
+* control cap means adding one line here (and a taxonomy entry); the anti-
+* drift guard `scripts/check-event-kind-coverage.ts` fails the build if an
+* eventful cap is missing.
+*/
+/** Map a taxonomy `iconId` onto the legacy closed `EventKindIcon` enum. */
+var LEGACY_ICON = {
+	motion: "motion",
+	audio: "audio",
+	person: "person",
+	vehicle: "vehicle",
+	animal: "animal",
+	package: "package",
+	door: "door",
+	pir: "pir",
+	smoke: "smoke",
+	water: "water",
+	button: "button",
+	generic: "generic",
+	gas: "smoke",
+	vibration: "generic",
+	tamper: "generic",
+	presence: "person",
+	lock: "generic",
+	siren: "generic",
+	switch: "generic",
+	doorbell: "button"
+};
+function legacyIcon(iconId) {
+	return LEGACY_ICON[iconId] ?? "generic";
+}
+/**
+* Cap name → taxonomy kind id. Covers EVERY eventful sensor / control cap.
+* The anti-drift guard cross-checks this against the eventful caps declared
+* in `packages/types/src/capabilities/*.cap.ts`.
+*/
+var CAP_TO_KIND = {
+	contact: "contact",
+	motion: "motion-sensor",
+	smoke: "smoke",
+	flood: "flood",
+	gas: "gas",
+	"carbon-monoxide": "carbon-monoxide",
+	vibration: "vibration",
+	tamper: "tamper",
+	presence: "presence",
+	"enum-sensor": "enum-sensor",
+	"event-emitter": "device-event",
+	"lock-control": "lock",
+	switch: "switch",
+	button: "button",
+	doorbell: "doorbell"
+};
+function buildDescriptor(capName, kind) {
+	const t = EVENT_TAXONOMY[kind];
+	if (t === void 0) throw new Error(`EVENT_KIND_BY_CAP: cap '${capName}' maps to unknown taxonomy kind '${kind}'`);
+	return {
+		...t,
+		icon: legacyIcon(t.iconId)
+	};
+}
+Object.freeze(Object.fromEntries(Object.entries(CAP_TO_KIND).map(([capName, kind]) => [capName, buildDescriptor(capName, kind)])));
+/**
 * server-management — per-NODE singleton capability for a node's ROOT
 * package lifecycle (runtime-updatable node packages).
 *
@@ -20164,7 +20392,28 @@ var FaceInfoSchema = z.object({
 	*  (`/addon/<addonId>/event-media/<keyFrameMediaKey>`). Absent when the
 	*  track produced no key frame (e.g. native/onboard source) — the UI falls
 	*  back to the inline `base64` face crop. */
-	keyFrameMediaKey: z.string().optional()
+	keyFrameMediaKey: z.string().optional(),
+	/** Winning identity-match cosine (0..1) for this face's track, when an
+	*  identity was auto-confirmed. Lets the UI surface WHY a face was assigned
+	*  (confidence badge / low-confidence audit). Absent on legacy rows and on
+	*  faces that were never auto-recognized. */
+	bestMatchScore: z.number().optional(),
+	/** Native-scale face short side (px) at recognition time, when the runner
+	*  measured it. Lets the UI flag low-resolution auto-assignments. Absent on
+	*  legacy rows / runners that reported no native measure. */
+	nativeFaceShortSidePx: z.number().optional(),
+	/** SUGGESTED identity for this face — a plausible-but-not-confident match that
+	*  MISSED auto-assignment (cosine in the suggestion band, or above threshold
+	*  but blocked only by the recognition size floor). Mutually exclusive with
+	*  `recognizedIdentityId` (a suggestion is NEVER an assignment): the face stays
+	*  UNASSIGNED and everything else keeps treating it as unrecognized — the UI
+	*  merely offers a one-tap "is this <name>?" confirm. Absent on legacy rows and
+	*  on faces that were auto-assigned or below the suggestion band. (2026-07-24) */
+	suggestedIdentityId: z.string().optional(),
+	/** Peak identity-match cosine (0..1) for `suggestedIdentityId`, captured at the
+	*  same moment as `bestMatchScore` (track peak, at close). Lets the UI rank /
+	*  badge suggestion confidence. Present iff `suggestedIdentityId` is. (2026-07-24) */
+	suggestedMatchScore: z.number().optional()
 });
 var FaceFilterEnum = z.enum([
 	"unassigned",
@@ -22770,7 +23019,6 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	addonWidgetsSourceCapability,
 	addonsCapability,
 	adminUiCapability,
-	advancedNotifierCapability,
 	airQualitySensorCapability,
 	alarmPanelCapability,
 	alertsCapability,
@@ -23257,36 +23505,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"advancedNotifier.deleteRule": {
-		capName: "advanced-notifier",
-		capScope: "system",
-		addonId: null,
-		access: "delete"
-	},
-	"advancedNotifier.getHistory": {
-		capName: "advanced-notifier",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
-	"advancedNotifier.getRules": {
-		capName: "advanced-notifier",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
-	"advancedNotifier.testRule": {
-		capName: "advanced-notifier",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
-	"advancedNotifier.upsertRule": {
-		capName: "advanced-notifier",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"alarmPanel.arm": {
 		capName: "alarm-panel",
 		capScope: "device",
@@ -25609,6 +25827,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.getHistory": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.getRule": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -27965,4 +28189,4 @@ function enumerateInferenceDevices(hw) {
 	return out;
 }
 //#endregion
-export { storageProviderCapability as $, getByPath as A, EventCategory as At, metricsProviderCapability as B, doorbellCapability as C, isDeviceConfigCap as Ct, evaluateLinkExpression as D, resolveCapMount as Dt, enumerateSchemaFields as E, readinessKey as Et, kebabToCamel as F, platformProbeCapability as G, normalizeUnit as H, lifecycleJobSchema as I, scoreRuntimes as J, procedureAuthKey as K, localNetworkCapability as L, isCollectionArrayMethod as M, isObjectInput as N, extractNestedAddonId as O, scopeKey as Ot, isVoidInput as P, storageCapability as Q, logDestinationCapability as R, deviceStatusCapability as S, hydrateSchema as St, enumerateItemArrayFields as T, parseJsonUnknown as Tt, objectInputDeclaresAddonId as U, nodePin as V, parseStreamParamsFormPatch as W, settingsStoreCapability as X, setByPath as Y, snapshotCapability as Z, authProviderCapability as _, asString as _t, DeviceStatusSchema as a, BaseAddon as at, deviceManagerCapability as b, emitReadiness as bt, STREAM_PROFILE_META as c, DEVICE_STATUS_METHOD as ct, UserRecordSchema as d, DeviceType as dt, streamQualityLabel as et, addonPagesCapability as f, ReadinessRegistry as ft, applyTransform as g, asNumber as gt, alertsCapability as h, asJsonObject as ht, CAP_NAMES_WITH_STATUS as i, errMsg as it, isArrayOutputSchema as j, filesystemBrowseCapability as k, sleep as kt, ScopedTokenSchema as l, DeviceFeature as lt, addonWidgetsCapability as m, WELL_KNOWN_TAB_MAP as mt, AlertSchema as n, userManagementCapability as nt, METHOD_ACCESS_MAP as o, DATAPLANE_SECRET_HEADER as ot, addonSettingsCapability as p, ReadinessTimeoutError as pt, readNodePin as q, ApiKeyRecordSchema as r, validateExpressionSource as rt, RUNTIME_DEFAULTS as s, DEVICE_SETTINGS_CONTRIBUTION_METHODS as st, ALL_CAPABILITY_DEFINITIONS as t, toExpressionValue as tt, StorageLocationTypeSchema as u, DeviceRole as ut, backupCapability as v, createEvent as vt, enumerateInferenceDevices as w, parseJsonObject as wt, deviceStateCapability as x, expandCapMethods as xt, buildStreamParamsConfigSchema as y, emitDownForOwnedCaps as yt, looseSchema as z };
+export { storageCapability as $, filesystemBrowseCapability as A, sleep as At, looseSchema as B, deviceStatusCapability as C, hydrateSchema as Ct, enumerateSchemaFields as D, readinessKey as Dt, enumerateItemArrayFields as E, parseJsonUnknown as Et, isVoidInput as F, parseStreamParamsFormPatch as G, nodePin as H, kebabToCamel as I, readNodePin as J, platformProbeCapability as K, lifecycleJobSchema as L, isArrayOutputSchema as M, isCollectionArrayMethod as N, evaluateLinkExpression as O, resolveCapMount as Ot, isObjectInput as P, snapshotCapability as Q, localNetworkCapability as R, deviceStateCapability as S, expandCapMethods as St, enumerateInferenceDevices as T, parseJsonObject as Tt, normalizeUnit as U, metricsProviderCapability as V, objectInputDeclaresAddonId as W, setByPath as X, scoreRuntimes as Y, settingsStoreCapability as Z, applyTransform as _, asNumber as _t, CAP_NAMES_WITH_STATUS as a, errMsg as at, buildStreamParamsConfigSchema as b, emitDownForOwnedCaps as bt, RUNTIME_DEFAULTS as c, DEVICE_SETTINGS_CONTRIBUTION_METHODS as ct, StorageLocationTypeSchema as d, DeviceRole as dt, storageProviderCapability as et, UserRecordSchema as f, DeviceType as ft, alertsCapability as g, asJsonObject as gt, addonWidgetsCapability as h, WELL_KNOWN_TAB_MAP as ht, BatteryStatusSchema as i, validateExpressionSource as it, getByPath as j, EventCategory as jt, extractNestedAddonId as k, scopeKey as kt, STREAM_PROFILE_META as l, DEVICE_STATUS_METHOD as lt, addonSettingsCapability as m, ReadinessTimeoutError as mt, AlertSchema as n, toExpressionValue as nt, DeviceStatusSchema as o, BaseAddon as ot, addonPagesCapability as p, ReadinessRegistry as pt, procedureAuthKey as q, ApiKeyRecordSchema as r, userManagementCapability as rt, METHOD_ACCESS_MAP as s, DATAPLANE_SECRET_HEADER as st, ALL_CAPABILITY_DEFINITIONS as t, streamQualityLabel as tt, ScopedTokenSchema as u, DeviceFeature as ut, authProviderCapability as v, asString as vt, doorbellCapability as w, isDeviceConfigCap as wt, deviceManagerCapability as x, emitReadiness as xt, backupCapability as y, createEvent as yt, logDestinationCapability as z };