@camstack/addon-post-analysis 1.2.319 → 1.2.321

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry-BjYpZuuI.js");
+const require_clip_model_registry = require("../clip-model-registry-BCx3qCL5.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -604,7 +604,19 @@ var ARM_ANYWAY_TTL_MS = 5 * 6e4;
 var NcAlarmOpenDeviceSchema = require_clip_model_registry.object({
 	deviceId: require_clip_model_registry.number().int(),
 	name: require_clip_model_registry.string(),
-	state: require_clip_model_registry.string()
+	state: require_clip_model_registry.string(),
+	/**
+	* Cover / lock / switch — default false so an older bridge answer still
+	* parses as a contact-style opening.
+	*/
+	controllable: require_clip_model_registry.boolean().default(false),
+	/** Opening cap that produced the reading; used to actuate secure-on-arm. */
+	cap: require_clip_model_registry._enum([
+		"contact",
+		"cover",
+		"lock-control",
+		"switch"
+	]).optional()
 }).readonly();
 /** Why an Arm anyway was not honoured — see `NcAlarmPanelDevice.armAnyway`. */
 var NcAlarmArmAnywayRejectionSchema = require_clip_model_registry._enum([
@@ -669,23 +681,22 @@ function alarmCoveredDevices(rules, panelDeviceId, mode) {
 /**
 * Refuse or arm — the whole decision, as one partition of the open devices.
 *
-* A device may be open at arm time for exactly two reasons: the mode TOLERATES
-* it (its non-blocking list), or the operator was shown it in a refusal and
-* pressed that refusal's Arm anyway (`acknowledged`). Anything else open
-* refuses — including a device that opened AFTER the refusal the operator is
-* confirming: they were never shown it, and excluding it would arm the alarm
-* around an opening nobody agreed to.
+* A device may be open at arm time when:
+*  - the mode TOLERATES it (`nonBlocking` for contacts),
+*  - it is controllable and NOT on the mode's `blocking` list (default),
+*  - or the operator confirmed it with Arm anyway (`acknowledged`).
 *
-* There is no memory here. A plain arm pressed twice is the same question
-* twice and gets the same answer; the only way past a refusal is the explicit
-* Arm anyway, whose lifecycle (one-shot, stale, expired) the panel owns.
+* Anything else open refuses — including a device that opened AFTER the refusal
+* the operator is confirming.
 *
 * Excluded is EVERY open device — tolerated and acknowledged alike — and the
 * exclusion is two-phase (`alarm-exclusions.ts`): each one is watched again
 * once it has closed and opened.
 */
 function decideArm(input) {
+	const forceBlock = new Set(input.blocking ?? []);
 	const tolerated = new Set([...input.nonBlocking, ...input.acknowledged ?? []]);
+	for (const d of input.open) if (d.controllable && !forceBlock.has(d.deviceId)) tolerated.add(d.deviceId);
 	const blocking = input.open.filter((d) => !tolerated.has(d.deviceId));
 	if (blocking.length > 0) return {
 		kind: "refused",
@@ -1073,39 +1084,24 @@ var NcActionPlane = class {
 * and never open):
 *
 *  - `not-opening` — no opening slice at all: a camera named by an intrusion
-*    rule, a switch. It takes no part in the arm decision.
+*    rule. It takes no part in the arm decision.
 *  - `unknown` — an opening cap's slice IS there, but its field is missing or
 *    is not a word that cap defines, or the slice is a provider's PLACEHOLDER
-*    (`lastChangedAt === 0`: written by a constructor before anybody read the
-*    device — an HA lock's `unlocked`, an HA cover's `closed`, a binary
-*    sensor's `entryOpen: false`). It carries the cap and the raw value (for a
-*    placeholder, the whole slice) so the caller's log line can say what it
-*    saw. It never blocks and is never armed as secure on a guess — and a
-*    placeholder is never taken for a state, so neither the reconcile tick,
-*    the arm check nor an exclusion lift acts on one.
-*  - `reading` — open or secure, with the state word a person will read.
-*    ANY non-zero `lastChangedAt` is a reading, however old — including `1`,
-*    the stamp a provider writes on a value it REPLAYED after a respawn with
-*    no upstream change time (Homematic `HM_SEEDED_CHANGED_AT`): the value is
-*    known, only its change time is not. The transition gate
-*    (`sensor-transition-gate.ts`, "A placeholder slice is not a state") reads
-*    the same stamp as "not a fresh event"; `0` alone means "not read yet".
+*    (`lastChangedAt === 0`). It never blocks and is never armed as secure on a
+*    guess.
+*  - `reading` — open or secure, with the state word a person will read and the
+*    cap that produced it (so secure-on-arm knows what to actuate).
 *
 * A read that FAILED never reaches {@link alarmOpeningFrom}: the caller leaves
 * that id out of its answer (see {@link readAlarmOpenings}).
 *
 * Anything short of fully secure is open: a cover stopped half-way, a lock that
-* jammed, a cover still closing when the arm is decided.
+* jammed, a cover still closing when the arm is decided, a switch that is on.
 *
 * PRECEDENCE, when one device carries more than one opening slice: `contact`
-* first, then `cover`, then `lock-control`. The contact is the physical truth
-* about the opening — a reed switch on the frame says the window is open even
-* when the motor's last reported word says `closed`. A slice that cannot be
-* read falls through to the next; only when none of them reads is the device
-* `unknown`, naming the first unreadable cap.
-*
-* The vocabulary of each word is its cap's own schema (`CoverStateSchema`,
-* `LockStateSchema`) — a word the cap does not define is not guessed at.
+* first, then `cover`, then `lock-control`, then `switch`. The contact is the
+* physical truth about the opening — a reed switch on the frame says the window
+* is open even when the motor's last reported word says `closed`.
 */
 /** The one state word, per cap, that counts as secure. Everything else is open. */
 var COVER_SECURE = "closed";
@@ -1124,11 +1120,12 @@ function fieldOf(slice, field) {
 function isPlaceholder(slice) {
 	return fieldOf(slice, "lastChangedAt") === 0;
 }
-function reading(word, secure) {
+function reading(word, secure, cap) {
 	return {
 		kind: "reading",
 		reading: word === secure ? "secure" : "open",
-		state: word
+		state: word,
+		cap
 	};
 }
 function readContact(runtime) {
@@ -1148,11 +1145,13 @@ function readContact(runtime) {
 	return raw ? {
 		kind: "reading",
 		reading: "open",
-		state: "open"
+		state: "open",
+		cap: "contact"
 	} : {
 		kind: "reading",
 		reading: "secure",
-		state: "closed"
+		state: "closed",
+		cap: "contact"
 	};
 }
 function readCover(runtime) {
@@ -1165,7 +1164,7 @@ function readCover(runtime) {
 	};
 	const raw = fieldOf(slice, "state");
 	const parsed = require_clip_model_registry.CoverStateSchema.safeParse(raw);
-	return parsed.success ? reading(parsed.data, COVER_SECURE) : {
+	return parsed.success ? reading(parsed.data, COVER_SECURE, "cover") : {
 		kind: "unknown",
 		cap: "cover",
 		raw
@@ -1181,19 +1180,46 @@ function readLock(runtime) {
 	};
 	const raw = fieldOf(slice, "state");
 	const parsed = require_clip_model_registry.LockStateSchema.safeParse(raw);
-	return parsed.success ? reading(parsed.data, LOCK_SECURE) : {
+	return parsed.success ? reading(parsed.data, LOCK_SECURE, "lock-control") : {
 		kind: "unknown",
 		cap: "lock-control",
 		raw
 	};
 }
+function readSwitch(runtime) {
+	const slice = sliceOf(runtime, "switch");
+	if (slice === void 0) return { kind: "absent" };
+	if (isPlaceholder(slice)) return {
+		kind: "unknown",
+		cap: "switch",
+		raw: slice
+	};
+	const raw = fieldOf(slice, "on");
+	if (typeof raw !== "boolean") return {
+		kind: "unknown",
+		cap: "switch",
+		raw
+	};
+	return raw ? {
+		kind: "reading",
+		reading: "open",
+		state: "on",
+		cap: "switch"
+	} : {
+		kind: "reading",
+		reading: "secure",
+		state: "off",
+		cap: "switch"
+	};
+}
 /** D630's table over one device's runtime slices — see the header for the three answers. */
 function alarmOpeningFrom(runtime) {
 	let firstUnknown = null;
 	for (const read of [
 		readContact(runtime),
 		readCover(runtime),
-		readLock(runtime)
+		readLock(runtime),
+		readSwitch(runtime)
 	]) {
 		if (read.kind === "reading") return read;
 		if (read.kind === "unknown" && firstUnknown === null) firstUnknown = read;
@@ -1208,13 +1234,14 @@ function alarmOpeningFrom(runtime) {
 var OPENING_CAP_BY_EVENT_KIND = {
 	contact: "contact",
 	cover: "cover",
-	lock: "lock-control"
+	lock: "lock-control",
+	switch: "switch"
 };
 /**
 * The same table, read off one sensor-event row: its `value` IS the slice of
 * the cap its `kind` names, so the event path and the reconcile read answer in
 * one vocabulary — a cover is secure only when `closed`, a lock only when
-* `locked`, whichever path saw it.
+* `locked`, a switch only when off, whichever path saw it.
 */
 function alarmOpeningFromSensorEvent(kind, value) {
 	const cap = OPENING_CAP_BY_EVENT_KIND[kind];
@@ -1235,7 +1262,9 @@ function classifyCoveredOpening(opening) {
 	if (opening.kind === "not-opening" || opening.reading !== "open") return { kind: "skip" };
 	return {
 		kind: "open",
-		state: opening.state
+		state: opening.state,
+		controllable: require_clip_model_registry.isAlarmControllableCap(opening.cap),
+		cap: opening.cap
 	};
 }
 /**
@@ -1892,6 +1921,22 @@ var ncAlarmPanelSchema = require_clip_model_registry.object({
 		deviceIds: require_clip_model_registry.array(require_clip_model_registry.number().int())
 	})).default([]),
 	/**
+	* Controllable openings that DO block when open (opt-in). Loose + guarded like
+	* {@link nonBlocking}.
+	*/
+	blocking: require_clip_model_registry.array(require_clip_model_registry.object({
+		mode: require_clip_model_registry.string(),
+		deviceIds: require_clip_model_registry.array(require_clip_model_registry.number().int())
+	})).default([]),
+	/**
+	* Controllable openings that must NOT secure on arm (opt-out). Loose + guarded
+	* like {@link nonBlocking}.
+	*/
+	secureOnArmOff: require_clip_model_registry.array(require_clip_model_registry.object({
+		mode: require_clip_model_registry.string(),
+		deviceIds: require_clip_model_registry.array(require_clip_model_registry.number().int())
+	})).default([]),
+	/**
 	* Per arm mode, the delays that override the global ones (D697). Loose on purpose — `mode` is
 	* a string and the numbers are unbounded here — and read back through
 	* {@link modeDelaysFromPersisted}, never a cast: an entry this release cannot trust is dropped
@@ -1910,7 +1955,7 @@ var ncAlarmPanelSchema = require_clip_model_registry.object({
 * per mode kept — the same "at most one list per mode" the settings schema
 * enforces at the boundary. A type guard (`safeParse`), never a cast.
 */
-function nonBlockingFromPersisted(raw) {
+function modeDeviceListFromPersisted(raw) {
 	const seen = /* @__PURE__ */ new Set();
 	const lists = [];
 	for (const entry of raw) {
@@ -2015,7 +2060,9 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 			...this.readDelays(),
 			announceArm: this.config.get("announceArm"),
 			announceTargets: [...this.config.get("announceTargets")],
-			nonBlocking: nonBlockingFromPersisted(this.config.get("nonBlocking")),
+			nonBlocking: modeDeviceListFromPersisted(this.config.get("nonBlocking")),
+			blocking: modeDeviceListFromPersisted(this.config.get("blocking")),
+			secureOnArmOff: modeDeviceListFromPersisted(this.config.get("secureOnArmOff")),
 			modeDelays: modeDelaysFromPersisted(this.config.get("modeDelays")).entries
 		};
 	}
@@ -2042,30 +2089,73 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 	async applySettings(patch) {
 		const edits = patch.modeDelays ?? [];
 		const membership = patch.nonBlockingEdit;
+		const blockingEdit = patch.blockingEdit;
+		const secureEdit = patch.secureOnArmEdit;
 		for (const edit of edits) this.refuseUnofferedMode(edit.mode);
 		if (membership !== void 0) {
 			this.refuseUnofferedMode(membership.mode, membership.deviceId);
-			const verdict = require_clip_model_registry.applyNonBlockingEdit(patch.nonBlocking !== void 0 ? patch.nonBlocking : nonBlockingFromPersisted(this.config.get("nonBlocking")), membership);
+			const verdict = require_clip_model_registry.applyNonBlockingEdit(patch.nonBlocking !== void 0 ? patch.nonBlocking : modeDeviceListFromPersisted(this.config.get("nonBlocking")), membership);
 			if (verdict.kind === "refused") {
 				this.ctx.logger.info("alarm settings refused", {
 					tags: { deviceId: membership.deviceId },
 					meta: {
 						panelId: this.id,
 						reason: "list-full",
-						mode: verdict.mode
+						mode: verdict.mode,
+						list: "nonBlocking"
 					}
 				});
 				throw new Error(`the ${verdict.mode} non-blocking list already holds ${verdict.max} devices — remove one first`);
 			}
 		}
+		if (blockingEdit !== void 0) {
+			this.refuseUnofferedMode(blockingEdit.mode, blockingEdit.deviceId);
+			const verdict = require_clip_model_registry.applyBlockingEdit(patch.blocking !== void 0 ? patch.blocking : modeDeviceListFromPersisted(this.config.get("blocking")), blockingEdit);
+			if (verdict.kind === "refused") {
+				this.ctx.logger.info("alarm settings refused", {
+					tags: { deviceId: blockingEdit.deviceId },
+					meta: {
+						panelId: this.id,
+						reason: "list-full",
+						mode: verdict.mode,
+						list: "blocking"
+					}
+				});
+				throw new Error(`the ${verdict.mode} blocking list already holds ${verdict.max} devices — remove one first`);
+			}
+		}
+		if (secureEdit !== void 0) {
+			this.refuseUnofferedMode(secureEdit.mode, secureEdit.deviceId);
+			const verdict = require_clip_model_registry.applySecureOnArmEdit(patch.secureOnArmOff !== void 0 ? patch.secureOnArmOff : modeDeviceListFromPersisted(this.config.get("secureOnArmOff")), secureEdit);
+			if (verdict.kind === "refused") {
+				this.ctx.logger.info("alarm settings refused", {
+					tags: { deviceId: secureEdit.deviceId },
+					meta: {
+						panelId: this.id,
+						reason: "list-full",
+						mode: verdict.mode,
+						list: "secureOnArmOff"
+					}
+				});
+				throw new Error(`the ${verdict.mode} secure-on-arm-off list already holds ${verdict.max} devices — remove one first`);
+			}
+		}
 		const listWrites = [];
 		if (patch.nonBlocking !== void 0) listWrites.push(this.config.set("nonBlocking", patch.nonBlocking.map((l) => ({
 			mode: l.mode,
 			deviceIds: [...l.deviceIds]
 		}))));
+		if (patch.blocking !== void 0) listWrites.push(this.config.set("blocking", patch.blocking.map((l) => ({
+			mode: l.mode,
+			deviceIds: [...l.deviceIds]
+		}))));
+		if (patch.secureOnArmOff !== void 0) listWrites.push(this.config.set("secureOnArmOff", patch.secureOnArmOff.map((l) => ({
+			mode: l.mode,
+			deviceIds: [...l.deviceIds]
+		}))));
 		let membershipChanged = null;
 		if (membership !== void 0) {
-			const result = require_clip_model_registry.applyNonBlockingEdit(nonBlockingFromPersisted(this.config.get("nonBlocking")), membership);
+			const result = require_clip_model_registry.applyNonBlockingEdit(modeDeviceListFromPersisted(this.config.get("nonBlocking")), membership);
 			if (result.kind === "applied") {
 				membershipChanged = result.changed;
 				if (result.changed) listWrites.push(this.config.set("nonBlocking", result.lists.map((l) => ({
@@ -2074,6 +2164,26 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 				}))));
 			}
 		}
+		if (blockingEdit !== void 0) {
+			const result = require_clip_model_registry.applyBlockingEdit(modeDeviceListFromPersisted(this.config.get("blocking")), blockingEdit);
+			if (result.kind === "applied" && result.changed) {
+				membershipChanged = true;
+				listWrites.push(this.config.set("blocking", result.lists.map((l) => ({
+					mode: l.mode,
+					deviceIds: [...l.deviceIds]
+				}))));
+			}
+		}
+		if (secureEdit !== void 0) {
+			const result = require_clip_model_registry.applySecureOnArmEdit(modeDeviceListFromPersisted(this.config.get("secureOnArmOff")), secureEdit);
+			if (result.kind === "applied" && result.changed) {
+				membershipChanged = true;
+				listWrites.push(this.config.set("secureOnArmOff", result.lists.map((l) => ({
+					mode: l.mode,
+					deviceIds: [...l.deviceIds]
+				}))));
+			}
+		}
 		const persistedDelays = modeDelaysFromPersisted(this.config.get("modeDelays"));
 		const beforeDelays = persistedDelays.entries;
 		const afterDelays = edits.length > 0 ? require_clip_model_registry.applyModeDelaysEdits(beforeDelays, edits) : beforeDelays;
@@ -2212,7 +2322,7 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 		if (read.verdict.kind === "refused") return this.refuse(mode, read.verdict.blocking, now);
 		return this.settleArm(mode, read.verdict.excluded.map((device) => ({
 			device,
-			why: "non-blocking"
+			why: this.exclusionWhyFor(mode, device)
 		})), now);
 	}
 	/**
@@ -2261,12 +2371,14 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 			return outcome;
 		}
 		const tolerated = this.nonBlockingFor(held.mode);
+		const forceBlock = this.blockingFor(held.mode);
 		const unknown = new Set(read.openings.unknown);
 		if (read.verdict.kind === "refused") {
 			const plain = decideArm({
 				mode: held.mode,
 				open: read.openings.open,
-				nonBlocking: tolerated
+				nonBlocking: tolerated,
+				blocking: forceBlock
 			});
 			const blockingNow = plain.kind === "refused" ? plain.blocking : read.verdict.blocking;
 			const shownIds = new Set(blockingNow.map((d) => d.deviceId));
@@ -2396,10 +2508,17 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 				error: String(err)
 			};
 		}
+		const toSecure = openings.open.filter((d) => require_clip_model_registry.alarmDeviceSecureOnArm({
+			controllable: d.controllable,
+			deviceId: d.deviceId,
+			secureOnArmOff: this.secureOnArmOffFor(mode)
+		}));
+		if (toSecure.length > 0) this.armGuard?.secureOnArm(toSecure);
 		const verdict = decideArm({
 			mode,
 			open: openings.open,
 			nonBlocking: this.nonBlockingFor(mode),
+			blocking: this.blockingFor(mode),
 			...acknowledged !== void 0 ? { acknowledged } : {}
 		});
 		return {
@@ -2424,7 +2543,28 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 	}
 	/** This mode's non-blocking ids, from the persisted lists. */
 	nonBlockingFor(mode) {
-		return nonBlockingFromPersisted(this.config.get("nonBlocking")).find((l) => l.mode === mode)?.deviceIds ?? [];
+		return this.modeListIds("nonBlocking", mode);
+	}
+	/** Controllable openings that force-block when open. */
+	blockingFor(mode) {
+		return this.modeListIds("blocking", mode);
+	}
+	/** Controllable openings that opt out of secure-on-arm. */
+	secureOnArmOffFor(mode) {
+		return this.modeListIds("secureOnArmOff", mode);
+	}
+	modeListIds(key, mode) {
+		return modeDeviceListFromPersisted(this.config.get(key)).find((l) => l.mode === mode)?.deviceIds ?? [];
+	}
+	/** Why an open device was armed around on a plain (non–Arm-anyway) arm. */
+	exclusionWhyFor(mode, device) {
+		if (this.nonBlockingFor(mode).includes(device.deviceId)) return "non-blocking";
+		if (require_clip_model_registry.alarmDeviceSecureOnArm({
+			controllable: device.controllable,
+			deviceId: device.deviceId,
+			secureOnArmOff: this.secureOnArmOffFor(mode)
+		})) return "secure-on-arm";
+		return "non-blocking";
 	}
 	/**
 	* Arm, with these exclusions.
@@ -5308,7 +5448,7 @@ function isAdoptable(record, nowMs) {
 * what `localDayMinute` does for the same input — one behaviour for a bad
 * zone, not two.
 */
-function clockOf$5(atMs, timeZone) {
+function clockOf$6(atMs, timeZone) {
 	if (timeZone !== void 0) try {
 		return new Intl.DateTimeFormat("en-GB", {
 			timeZone,
@@ -5444,7 +5584,7 @@ var TimelapseRenderer = class {
 				includeAudio: false,
 				maxLifeMs: await this.ports.exportLifeMs(),
 				deleteAfterDownload: false,
-				title: `${request.ruleName} ${clockOf$5(window.startMs, request.timezone)}→${clockOf$5(window.endMs, request.timezone)}`,
+				title: `${request.ruleName} ${clockOf$6(window.startMs, request.timezone)}→${clockOf$6(window.endMs, request.timezone)}`,
 				timelapse: {
 					everyMs,
 					outputFps: request.framerate,
@@ -5775,7 +5915,7 @@ var TimelapseRenderer = class {
 					...meta,
 					unservedWindowCount: verdict.unservedWindows.length,
 					unservedWindows: verdict.unservedWindows.slice(0, 12).map((w) => ({
-						at: clockOf$5(request.window.startMs + w.fromSec * 1e3, request.timezone),
+						at: clockOf$6(request.window.startMs + w.fromSec * 1e3, request.timezone),
 						fromSec: Math.round(w.fromSec),
 						toSec: Math.round(w.toSec),
 						expectedDenseFrames: w.expectedDenseFrames,
@@ -8618,6 +8758,7 @@ function sameWord(a, b) {
 * therefore moves the table with the arm.
 */
 function alarmSensorStateOf(deviceId, opening, online) {
+	const controllable = opening?.kind === "reading" ? require_clip_model_registry.isAlarmControllableCap(opening.cap) : false;
 	const verdict = classifyCoveredOpening(opening);
 	switch (verdict.kind) {
 		case "unknown": return {
@@ -8625,27 +8766,31 @@ function alarmSensorStateOf(deviceId, opening, online) {
 			reading: "unknown",
 			state: null,
 			unknownWhy: verdict.why,
-			online
+			online,
+			controllable
 		};
 		case "open": return {
 			deviceId,
 			reading: "open",
 			state: verdict.state,
 			unknownWhy: null,
-			online
+			online,
+			controllable: verdict.controllable
 		};
 		case "skip": return opening?.kind === "reading" ? {
 			deviceId,
 			reading: "closed",
 			state: opening.state,
 			unknownWhy: null,
-			online
+			online,
+			controllable
 		} : {
 			deviceId,
 			reading: "not-opening",
 			state: null,
 			unknownWhy: null,
-			online
+			online,
+			controllable: false
 		};
 	}
 }
@@ -13755,7 +13900,7 @@ var NcPruneRecordSchema = require_clip_model_registry.object({
 	source: require_clip_model_registry._enum(["event", "reconcile"])
 });
 /** Rules × deleted subjects — small; a generous ceiling. */
-var LOAD_LIMIT$4 = 1e4;
+var LOAD_LIMIT$5 = 1e4;
 function keyOf$1(row) {
 	return `${row.kind}:${row.ruleId}:${row.field}:${row.subject}`;
 }
@@ -13774,7 +13919,7 @@ var NC_DEVICE_PRUNES_SPEC = {
 		return parsed.success ? parsed.data : null;
 	},
 	deviceIdOf: (row) => row.subjectKind === "device" ? Number(row.subject) : void 0,
-	loadLimit: LOAD_LIMIT$4
+	loadLimit: LOAD_LIMIT$5
 };
 /** The outcomes that mean "this last reference was already dealt with". */
 var KEPT_OUTCOMES = new Set(["kept-disabled", "kept"]);
@@ -13809,7 +13954,7 @@ var NcPruneLedger = class {
 		try {
 			const records = await this.store.query.query({
 				collection: NC_DEVICE_PRUNES_COLLECTION,
-				filter: { limit: LOAD_LIMIT$4 }
+				filter: { limit: LOAD_LIMIT$5 }
 			});
 			const next = /* @__PURE__ */ new Map();
 			for (const record of records) {
@@ -17134,12 +17279,12 @@ var NcSummaryTemplateSchema = require_clip_model_registry.object({
 	title: require_clip_model_registry.string().max(500).optional(),
 	body: require_clip_model_registry.string().max(2e3).optional()
 });
-var NameField = require_clip_model_registry.string().min(1).max(200);
+var NameField$1 = require_clip_model_registry.string().min(1).max(200);
 /** MULTI-CAMERA is the point of the feature — a one-camera digest is a
 *  timelapse with extra steps, but it is allowed and it is cheap. */
 var DeviceIdsField = require_clip_model_registry.array(require_clip_model_registry.number()).min(1).max(64);
-var TargetsField = require_clip_model_registry.array(require_clip_model_registry.NcRuleTargetSchema).min(1);
-var PriorityField = require_clip_model_registry.number().int().min(1).max(5);
+var TargetsField$1 = require_clip_model_registry.array(require_clip_model_registry.NcRuleTargetSchema).min(1);
+var PriorityField$1 = require_clip_model_registry.number().int().min(1).max(5);
 /**
 * The mosaic's tile ceiling. 9 (a 3×3 grid) is the shipped default: it is the
 * most a phone lock-screen thumbnail can carry and still be read, and it is the
@@ -17304,7 +17449,7 @@ var NcSummaryAiSchema = require_clip_model_registry.object({
 	onFailure: require_clip_model_registry._enum(["deliver-without-text", "skip"]).optional()
 });
 var NcSummaryRuleInputSchema = require_clip_model_registry.object({
-	name: NameField,
+	name: NameField$1,
 	enabled: require_clip_model_registry.boolean().default(true),
 	deviceIds: DeviceIdsField,
 	window: NcSummaryWindowSchema,
@@ -17313,7 +17458,7 @@ var NcSummaryRuleInputSchema = require_clip_model_registry.object({
 	maxAiImages: MaxAiImagesField.default(NC_SUMMARY_DEFAULT_AI_IMAGES),
 	rank: NcSummaryRankSchema.default("importance"),
 	barrierSeconds: BarrierSecondsField.default(120),
-	targets: TargetsField,
+	targets: TargetsField$1,
 	template: NcSummaryTemplateSchema.optional(),
 	/** Burned onto the mosaic's title band — and ONLY when `captions` is `all`. */
 	captions: NcSummaryCaptionsSchema.default(NC_SUMMARY_DEFAULT_CAPTIONS),
@@ -17323,7 +17468,7 @@ var NcSummaryRuleInputSchema = require_clip_model_registry.object({
 	/** Deliver a window that matched NOTHING? Default no: a nightly "0 events"
 	*  is a line nobody reads, and it costs the lines beside it their reader. */
 	deliverEmpty: require_clip_model_registry.boolean().default(false),
-	priority: PriorityField.default(3),
+	priority: PriorityField$1.default(3),
 	ai: NcSummaryAiSchema.optional()
 });
 /**
@@ -17335,7 +17480,7 @@ var NcSummaryRuleInputSchema = require_clip_model_registry.object({
 * plain `.optional()`.
 */
 var NcSummaryRulePatchSchema = require_clip_model_registry.object({
-	name: NameField.optional(),
+	name: NameField$1.optional(),
 	enabled: require_clip_model_registry.boolean().optional(),
 	deviceIds: DeviceIdsField.optional(),
 	window: NcSummaryWindowSchema.optional(),
@@ -17344,12 +17489,12 @@ var NcSummaryRulePatchSchema = require_clip_model_registry.object({
 	maxAiImages: MaxAiImagesField.optional(),
 	rank: NcSummaryRankSchema.optional(),
 	barrierSeconds: BarrierSecondsField.optional(),
-	targets: TargetsField.optional(),
+	targets: TargetsField$1.optional(),
 	template: NcSummaryTemplateSchema.nullable().optional(),
 	captions: NcSummaryCaptionsSchema.optional(),
 	captionText: require_clip_model_registry.string().max(200).optional(),
 	deliverEmpty: require_clip_model_registry.boolean().optional(),
-	priority: PriorityField.optional(),
+	priority: PriorityField$1.optional(),
 	ai: NcSummaryAiSchema.nullable().optional()
 });
 /**
@@ -17382,6 +17527,89 @@ function assertSummaryBudget(rule) {
 	if (rule.maxAiImages > rule.maxTiles) throw new Error(`maxAiImages (${rule.maxAiImages}) cannot exceed maxTiles (${rule.maxTiles}) — the model cannot judge frames the mosaic does not contain`);
 }
 //#endregion
+//#region src/notification-center/calendar-events/calendar-events-window.ts
+/** One day in milliseconds. */
+var CALENDAR_EVENTS_DAY_MS = 1440 * 60 * 1e3;
+/**
+* Floor / ceiling on the horizon days a rule may declare.
+* 1 day is the minimum useful digest; 30 keeps a single notification bounded.
+*/
+var CALENDAR_EVENTS_MIN_HORIZON_DAYS = 1;
+var CALENDAR_EVENTS_MAX_HORIZON_DAYS = 30;
+var CALENDAR_EVENTS_DEFAULT_HORIZON_DAYS = 7;
+/**
+* Build the producer window for one fire.
+*
+* `horizonDays` is clamped into the legal range rather than refused — a
+* stored rule that predates a tighter bound must still fire.
+*/
+function calendarEventsWindow(nowMs, horizonDays) {
+	const days = Math.min(CALENDAR_EVENTS_MAX_HORIZON_DAYS, Math.max(CALENDAR_EVENTS_MIN_HORIZON_DAYS, Math.floor(horizonDays)));
+	return {
+		startMs: nowMs,
+		endMs: nowMs + days * CALENDAR_EVENTS_DAY_MS,
+		horizonDays: days
+	};
+}
+//#endregion
+//#region src/notification-center/calendar-events/calendar-events-rule.ts
+/**
+* NcCalendarEventsRule — scheduled "upcoming calendar events" digest.
+*
+* Same ownership model as Summaries/Timelapses: lives in the addon (not
+* `@camstack/types`) so a field is live on the next post-analysis deploy.
+* Rides no `NcDelivery` member; reaches the outside world through
+* `nc.*CalendarEvents*` bridge actions.
+*
+* Calendar selection mirrors detection classes: `calendars` = Only,
+* `calendarsExclude` = Except, both empty = All.
+*/
+var NcCalendarEventsTemplateSchema = require_clip_model_registry.object({
+	title: require_clip_model_registry.string().max(500).optional(),
+	body: require_clip_model_registry.string().max(4e3).optional()
+});
+var NameField = require_clip_model_registry.string().min(1).max(200);
+var TargetsField = require_clip_model_registry.array(require_clip_model_registry.NcRuleTargetSchema).min(1);
+var PriorityField = require_clip_model_registry.number().int().min(1).max(5);
+var HorizonDaysField = require_clip_model_registry.number().int().min(CALENDAR_EVENTS_MIN_HORIZON_DAYS).max(CALENDAR_EVENTS_MAX_HORIZON_DAYS);
+var CalendarIdsField = require_clip_model_registry.array(require_clip_model_registry.string().min(1).max(200)).max(64);
+var NcCalendarEventsRuleInputSchema = require_clip_model_registry.object({
+	name: NameField,
+	enabled: require_clip_model_registry.boolean().default(true),
+	schedule: require_clip_model_registry.NcScheduleSchema,
+	/** Only these calendars. Empty/absent with no exclude = All. */
+	calendars: CalendarIdsField.optional(),
+	/** All except these. Ignored when `calendars` is non-empty. */
+	calendarsExclude: CalendarIdsField.optional(),
+	horizonDays: HorizonDaysField.default(CALENDAR_EVENTS_DEFAULT_HORIZON_DAYS),
+	/** Deliver when the horizon holds no events? Default no. */
+	deliverEmpty: require_clip_model_registry.boolean().default(false),
+	targets: TargetsField,
+	template: NcCalendarEventsTemplateSchema.optional(),
+	priority: PriorityField.default(3)
+});
+var NcCalendarEventsRulePatchSchema = require_clip_model_registry.object({
+	name: NameField.optional(),
+	enabled: require_clip_model_registry.boolean().optional(),
+	schedule: require_clip_model_registry.NcScheduleSchema.optional(),
+	calendars: CalendarIdsField.nullable().optional(),
+	calendarsExclude: CalendarIdsField.nullable().optional(),
+	horizonDays: HorizonDaysField.optional(),
+	deliverEmpty: require_clip_model_registry.boolean().optional(),
+	targets: TargetsField.optional(),
+	template: NcCalendarEventsTemplateSchema.nullable().optional(),
+	priority: PriorityField.optional()
+});
+var NcCalendarEventsRuleSchema = NcCalendarEventsRuleInputSchema.extend({
+	id: require_clip_model_registry.string(),
+	ownerUserId: require_clip_model_registry.string().optional(),
+	/** Epoch-ms of the schedule window end that was last delivered. */
+	generatedAt: require_clip_model_registry.number().optional(),
+	createdBy: require_clip_model_registry.string(),
+	createdAt: require_clip_model_registry.number(),
+	updatedAt: require_clip_model_registry.number()
+});
+//#endregion
 //#region src/notification-center/unstored-media-id.ts
 /**
 * An id for media bytes that were NEVER STORED.
@@ -18542,6 +18770,22 @@ var ncActions = require_clip_model_registry.defineCustomActions({
 		kind: "mutation",
 		caller: "required"
 	}),
+	"nc.listCalendarEventsRules": require_clip_model_registry.customAction(require_clip_model_registry.object({}), require_clip_model_registry.object({
+		rules: require_clip_model_registry.array(NcCalendarEventsRuleSchema.extend({ readOnly: require_clip_model_registry.boolean() })),
+		canAuthor: require_clip_model_registry.boolean()
+	}), { caller: "required" }),
+	"nc.upsertCalendarEventsRule": require_clip_model_registry.customAction(require_clip_model_registry.object({
+		ruleId: require_clip_model_registry.string().optional(),
+		rule: NcCalendarEventsRuleInputSchema.optional(),
+		patch: NcCalendarEventsRulePatchSchema.optional()
+	}), require_clip_model_registry.object({ rule: NcCalendarEventsRuleSchema }), {
+		kind: "mutation",
+		caller: "required"
+	}),
+	"nc.deleteCalendarEventsRule": require_clip_model_registry.customAction(require_clip_model_registry.object({ ruleId: require_clip_model_registry.string() }), require_clip_model_registry.object({ success: require_clip_model_registry.literal(true) }), {
+		kind: "mutation",
+		caller: "required"
+	}),
 	/**
 	* Produce one digest window RIGHT NOW — the operator's Test button.
 	*
@@ -18828,6 +19072,11 @@ function makeNcActionHandlers(deps) {
 		if (sum === void 0) throw new Error("this node does not host the summary producer — use the hub");
 		return sum;
 	};
+	const requireCalendarEvents = () => {
+		const ce = deps.calendarEvents;
+		if (ce === void 0) throw new Error("this node does not host calendar-events rules — use the hub");
+		return ce;
+	};
 	/** The artefact index, or an honest refusal. */
 	const requireArtifacts = () => {
 		const index = deps.artifacts;
@@ -18856,6 +19105,13 @@ function makeNcActionHandlers(deps) {
 		if (rule.ownerUserId !== caller.userId) throw new Error(`forbidden: summary rule not owned: ${ruleId}`);
 		return rule;
 	};
+	const assertCalendarEventsEditable = (ruleId, caller, ce) => {
+		const rule = ce.store.get(ruleId);
+		if (rule === null) throw new Error(`forbidden: calendar-events rule not found: ${ruleId}`);
+		if (caller.isAdmin) return rule;
+		if (rule.ownerUserId !== caller.userId) throw new Error(`forbidden: calendar-events rule not owned: ${ruleId}`);
+		return rule;
+	};
 	/** A timelapse rule the caller may EDIT. Same admin bypass as `NcRule`. */
 	const assertTimelapseEditable = (ruleId, caller, tl) => {
 		const rule = tl.store.get(ruleId);
@@ -19397,6 +19653,53 @@ function makeNcActionHandlers(deps) {
 				...out.skippedByAi === true ? { skippedByAi: true } : {}
 			};
 		},
+		"nc.listCalendarEventsRules": async (_input, caller) => {
+			const c = requireCaller$1(caller);
+			const ce = requireCalendarEvents();
+			return {
+				rules: (c.isAdmin ? ce.store.list() : ce.store.listForOwner(c.userId)).map((r) => ({
+					...r,
+					readOnly: !c.isAdmin && r.ownerUserId !== c.userId
+				})),
+				canAuthor: true
+			};
+		},
+		"nc.upsertCalendarEventsRule": async (input, caller) => {
+			const c = requireCaller$1(caller);
+			const ce = requireCalendarEvents();
+			if (input.ruleId === void 0) {
+				if (input.rule === void 0) throw new Error("upsertCalendarEventsRule: rule or ruleId required");
+				const parsed = NcCalendarEventsRuleInputSchema.parse(input.rule);
+				await assertTargetsOwned(parsed.targets.map((t) => t.targetId), c);
+				const rule = await ce.store.create(parsed, c.userId, c.isAdmin ? void 0 : c.userId);
+				deps.logger.info("calendar-events rule created", { meta: {
+					ruleId: rule.id,
+					owner: c.userId
+				} });
+				return { rule };
+			}
+			assertCalendarEventsEditable(input.ruleId, c, ce);
+			if (input.patch === void 0) throw new Error("upsertCalendarEventsRule: patch required");
+			const patch = NcCalendarEventsRulePatchSchema.parse(input.patch);
+			if (patch.targets !== void 0) await assertTargetsOwned(patch.targets.map((t) => t.targetId), c);
+			const rule = await ce.store.update(input.ruleId, patch);
+			deps.logger.info("calendar-events rule updated", { meta: {
+				ruleId: rule.id,
+				owner: c.userId
+			} });
+			return { rule };
+		},
+		"nc.deleteCalendarEventsRule": async (input, caller) => {
+			const c = requireCaller$1(caller);
+			const ce = requireCalendarEvents();
+			assertCalendarEventsEditable(input.ruleId, c, ce);
+			await ce.store.delete(input.ruleId);
+			deps.logger.info("calendar-events rule deleted", { meta: {
+				ruleId: input.ruleId,
+				owner: c.userId
+			} });
+			return { success: true };
+		},
 		"nc.getTexts": async (input) => {
 			const texts = requireTexts();
 			return input.language === void 0 ? texts.view() : texts.view(input.language);
@@ -20009,19 +20312,39 @@ function planSummaryDevices(rule, isDead, guard) {
 		notes: notes.notes
 	};
 }
+function stripDeadFromLists(lists, isDead) {
+	const dead = lists.flatMap((list) => list.deviceIds.filter(isDead));
+	if (dead.length === 0) return {
+		next: lists,
+		dead
+	};
+	return {
+		dead,
+		next: lists.map((list) => ({
+			...list,
+			deviceIds: list.deviceIds.filter((id) => !isDead(id))
+		}))
+	};
+}
 function planAlarmDevices(alarm, isDead) {
 	if (alarm === null) return null;
-	const nonBlockingDead = alarm.nonBlocking.flatMap((list) => list.deviceIds.filter(isDead));
-	const touched = nonBlockingDead.length > 0;
+	const nonBlocking = stripDeadFromLists(alarm.nonBlocking, isDead);
+	const blocking = stripDeadFromLists(alarm.blocking, isDead);
+	const secureOnArmOff = stripDeadFromLists(alarm.secureOnArmOff, isDead);
 	const forgetExcluded = alarm.excluded.filter(isDead);
-	if (!touched && forgetExcluded.length === 0) return null;
+	const deadIds = [
+		...nonBlocking.dead,
+		...blocking.dead,
+		...secureOnArmOff.dead,
+		...forgetExcluded
+	];
+	if (deadIds.length === 0) return null;
 	return {
-		dropped: deviceSubjects([...new Set([...nonBlockingDead, ...forgetExcluded])]),
+		dropped: deviceSubjects([...new Set(deadIds)]),
 		droppedKind: "device",
-		...touched ? { nonBlocking: alarm.nonBlocking.map((list) => ({
-			...list,
-			deviceIds: list.deviceIds.filter((id) => !isDead(id))
-		})) } : {},
+		...nonBlocking.dead.length > 0 ? { nonBlocking: nonBlocking.next } : {},
+		...blocking.dead.length > 0 ? { blocking: blocking.next } : {},
+		...secureOnArmOff.dead.length > 0 ? { secureOnArmOff: secureOnArmOff.next } : {},
 		forgetExcluded
 	};
 }
@@ -20063,6 +20386,8 @@ function referencedDeviceIds(snapshot) {
 	for (const rule of snapshot.timelapse) add(rule.deviceIds);
 	for (const rule of snapshot.summary) add(rule.deviceIds);
 	for (const list of snapshot.alarm?.nonBlocking ?? []) add(list.deviceIds);
+	for (const list of snapshot.alarm?.blocking ?? []) add(list.deviceIds);
+	for (const list of snapshot.alarm?.secureOnArmOff ?? []) add(list.deviceIds);
 	add(snapshot.alarm?.excluded);
 	add(snapshot.mutedDeviceIds);
 	return ids;
@@ -20407,6 +20732,8 @@ var NcDeletedSubjectPruner = class {
 			summary: this.writable("summary", this.deps.summary.list()),
 			alarm: panel !== null && settings !== void 0 ? {
 				nonBlocking: settings.nonBlocking,
+				blocking: settings.blocking,
+				secureOnArmOff: settings.secureOnArmOff,
 				announceTargets: settings.announceTargets,
 				excluded: panel.excludedDevices()
 			} : null,
@@ -20563,6 +20890,8 @@ var NcDeletedSubjectPruner = class {
 			...NO_SNAPSHOT,
 			alarm: {
 				nonBlocking: settings.nonBlocking,
+				blocking: settings.blocking,
+				secureOnArmOff: settings.secureOnArmOff,
 				announceTargets: settings.announceTargets,
 				excluded: panel.excludedDevices()
 			}
@@ -20571,6 +20900,8 @@ var NcDeletedSubjectPruner = class {
 		try {
 			const patch = {
 				...edit.nonBlocking !== void 0 ? { nonBlocking: edit.nonBlocking } : {},
+				...edit.blocking !== void 0 ? { blocking: edit.blocking } : {},
+				...edit.secureOnArmOff !== void 0 ? { secureOnArmOff: edit.secureOnArmOff } : {},
 				...edit.announceTargets !== void 0 ? { announceTargets: [...edit.announceTargets] } : {}
 			};
 			if (Object.keys(patch).length > 0) await panel.applySettings(patch);
@@ -28232,7 +28563,8 @@ var OUTBOX_RECORD_KINDS = new Set([
 	"audio-window",
 	"system-event",
 	"timelapse",
-	"ai-summary"
+	"ai-summary",
+	"calendar-events"
 ]);
 function isOutboxRecordKind(x) {
 	return typeof x === "string" && OUTBOX_RECORD_KINDS.has(x);
@@ -28585,7 +28917,7 @@ function buildRuleAiSystemPrompt(shape, language, maxWords, grouped = false) {
 	].join("");
 }
 /** `HH:MM` in the host timezone. */
-function clockOf$4(atMs) {
+function clockOf$5(atMs) {
 	const d = new Date(atMs);
 	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 }
@@ -28623,7 +28955,7 @@ function buildRuleAiPrompt(input) {
 	if (shape === "detection-track") {
 		lines.push(`Camera: ${camera}.${located} Subject: ${subject}. The stills, in order:`);
 		for (const [i, frame] of input.frames.entries()) {
-			const when = frame.atMs !== void 0 ? ` · ${clockOf$4(frame.atMs)}` : "";
+			const when = frame.atMs !== void 0 ? ` · ${clockOf$5(frame.atMs)}` : "";
 			lines.push(`${String(i + 1)}.${when}`);
 		}
 		return lines.join("\n");
@@ -28920,7 +29252,7 @@ var NcRuleAiRowSchema = require_clip_model_registry.object({
 	updatedAt: require_clip_model_registry.number()
 });
 /** Operator-authored and tiny; a generous ceiling. */
-var LOAD_LIMIT$3 = 1e4;
+var LOAD_LIMIT$4 = 1e4;
 var NC_RULE_AI_SPEC = {
 	collection: NC_RULE_AI_COLLECTION,
 	columns: [...NC_RULE_AI_COLUMNS],
@@ -28936,7 +29268,7 @@ var NC_RULE_AI_SPEC = {
 		const parsed = NcRuleAiRowSchema.safeParse(data["row"]);
 		return parsed.success ? parsed.data : null;
 	},
-	loadLimit: LOAD_LIMIT$3
+	loadLimit: LOAD_LIMIT$4
 };
 var NcRuleAiStore = class {
 	ledger;
@@ -29273,7 +29605,7 @@ var NC_RULES_INDEXES = [{
 	columns: ["enabled"]
 }];
 /** Query cap — the rule set is operator-authored and tiny; a generous ceiling. */
-var LOAD_LIMIT$2 = 1e4;
+var LOAD_LIMIT$3 = 1e4;
 function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -29322,7 +29654,7 @@ function makeRulesSpec(onProjection) {
 			if (projection.kind === "projected") onProjection?.(key, projection);
 			return parsed.data;
 		},
-		loadLimit: LOAD_LIMIT$2
+		loadLimit: LOAD_LIMIT$3
 	};
 }
 /** The spec `declare` needs — no sink: declaring a collection projects nothing. */
@@ -30394,7 +30726,7 @@ var DEFAULT_PROMPT_EN = "What happened during this period? Summarise it for a ho
 */
 var SummaryAnswerSchema = require_clip_model_registry.object({ summary: require_clip_model_registry.string() });
 /** `HH:MM` in the host timezone — the two numbers a frame label needs. */
-function clockOf$3(atMs) {
+function clockOf$4(atMs) {
 	const d = new Date(atMs);
 	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 }
@@ -30417,7 +30749,7 @@ function buildSummaryAiPrompt(input, frames) {
 	const roster = frames.map((f, i) => {
 		const location = plainLabel(f.location ?? "");
 		const where = location.length > 0 ? ` (${location})` : "";
-		return `${String(i + 1)}. ${plainLabel(f.deviceName)}${where} · ${clockOf$3(f.atMs)} · ${plainVocabulary(f.className) || "subject"}`;
+		return `${String(i + 1)}. ${plainLabel(f.deviceName)}${where} · ${clockOf$4(f.atMs)} · ${plainVocabulary(f.className) || "subject"}`;
 	}).join("\n");
 	const described = /* @__PURE__ */ new Map();
 	for (const f of frames) {
@@ -31020,7 +31352,7 @@ var NO_DETECTIONS$1 = {
 *  has to check is a key somebody can get wrong. */
 var BODY_SEPARATOR$1 = " · ";
 /** `HH:MM` in the host timezone. */
-function clockOf$2(atMs) {
+function clockOf$3(atMs) {
 	const d = new Date(atMs);
 	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 }
@@ -31034,8 +31366,8 @@ function clockOf$2(atMs) {
 function summaryTemplateVars(input) {
 	return {
 		rule: input.ruleName,
-		from: clockOf$2(input.window.startMs),
-		to: clockOf$2(input.window.endMs),
+		from: clockOf$3(input.window.startMs),
+		to: clockOf$3(input.window.endMs),
 		time: ncClockText(input.texts.language, input.generatedAt),
 		events: String(input.tileCount),
 		cameras: String(input.cameraCount),
@@ -31079,7 +31411,7 @@ function composeSummaryBody(input) {
 * string, for the reason the timelapse learned: a hand-rolled `n === 1` shipped
 * "1 intervalli ripresi" to a live phone.
 */
-function derivedBody$1(input, vars) {
+function derivedBody$2(input, vars) {
 	const texts = input.texts;
 	const parts = [texts.text({
 		key: "summary.body.window",
@@ -31114,7 +31446,7 @@ function derivedBody$1(input, vars) {
 }
 /** Per-target params with the derived `clickUrl` filled in where absent. A
 *  value the operator set on the target WINS — he chose it. */
-function paramsFor$1(target, clickUrl) {
+function paramsFor$2(target, clickUrl) {
 	if (clickUrl === void 0) return target.params;
 	if (target.params === void 0) return { clickUrl };
 	if (typeof target.params["clickUrl"] === "string") return target.params;
@@ -31130,11 +31462,11 @@ function summaryRecordId(ruleId, windowEndMs) {
 /** The caption burned onto the mosaic's title band, with the same `{{var}}`
 *  vocabulary the title and body use. `''` is a real answer ("no caption"). */
 function summaryCaptionText(input) {
-	if (input.captionText === void 0) return `${input.ruleName} — ${clockOf$2(input.window.startMs)}→${clockOf$2(input.window.endMs)}`;
+	if (input.captionText === void 0) return `${input.ruleName} — ${clockOf$3(input.window.startMs)}→${clockOf$3(input.window.endMs)}`;
 	return renderTemplate(input.captionText, {
 		rule: input.ruleName,
-		from: clockOf$2(input.window.startMs),
-		to: clockOf$2(input.window.endMs)
+		from: clockOf$3(input.window.startMs),
+		to: clockOf$3(input.window.endMs)
 	}) ?? "";
 }
 /**
@@ -31152,7 +31484,7 @@ function buildSummaryOutboxInputs(input) {
 	const body = composeSummaryBody({
 		aiText: aiSentence(input),
 		renderedTemplateBody: renderTemplate(input.template?.body, vars),
-		derivedBody: derivedBody$1(input, vars),
+		derivedBody: derivedBody$2(input, vars),
 		templateNamesAi: templatePlaceholders(input.template?.body ?? "").includes("ai")
 	});
 	const recordId = summaryRecordId(input.ruleId, input.window.endMs);
@@ -31171,7 +31503,7 @@ function buildSummaryOutboxInputs(input) {
 			},
 			media: "none",
 			...artifacts.length > 0 ? { artifacts } : {},
-			...paramsFor$1(target, input.clickUrl) !== void 0 ? { params: paramsFor$1(target, input.clickUrl) } : {},
+			...paramsFor$2(target, input.clickUrl) !== void 0 ? { params: paramsFor$2(target, input.clickUrl) } : {},
 			subject: {
 				deviceId: input.primaryDeviceId,
 				className: "summary",
@@ -32066,7 +32398,7 @@ var NcSummaryProducer = class {
 				purpose: "summary",
 				tiles: tiles.map(({ candidate, jpeg }) => ({
 					jpeg,
-					...plan.tileLabels ? { label: `${names.get(candidate.deviceId) ?? candidate.deviceId} · ${clockOf$1(candidate.firstSeen)} · ${candidate.className}` } : {},
+					...plan.tileLabels ? { label: `${names.get(candidate.deviceId) ?? candidate.deviceId} · ${clockOf$2(candidate.firstSeen)} · ${candidate.className}` } : {},
 					deviceId: candidate.deviceId,
 					sourceId: candidate.trackId
 				})),
@@ -32289,7 +32621,7 @@ var NcSummaryProducer = class {
 	}
 };
 /** `HH:MM` in the host timezone — the two numbers a tile label needs. */
-function clockOf$1(atMs) {
+function clockOf$2(atMs) {
 	const d = new Date(atMs);
 	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 }
@@ -32365,7 +32697,7 @@ var NC_SUMMARY_RULES_INDEXES = [{
 	columns: ["enabled"]
 }];
 /** The rule set is operator-authored and tiny; a generous ceiling. */
-var LOAD_LIMIT$1 = 1e4;
+var LOAD_LIMIT$2 = 1e4;
 /**
 * The ledger contract for the digest rule set.
 *
@@ -32395,7 +32727,7 @@ var NC_SUMMARY_RULES_SPEC = {
 		const parsed = NcSummaryRuleSchema.safeParse(data["rule"]);
 		return parsed.success ? parsed.data : null;
 	},
-	loadLimit: LOAD_LIMIT$1
+	loadLimit: LOAD_LIMIT$2
 };
 /**
 * The three-way CLEARABLE patch signal, one function per field: `undefined`
@@ -32406,7 +32738,7 @@ var NC_SUMMARY_RULES_SPEC = {
 * cast here would be a cast on the exact path that decides whether a persisted
 * rule keeps a field. Three literal destructurings are three provable ones.
 */
-function applyTemplatePatch$1(merged, template) {
+function applyTemplatePatch$2(merged, template) {
 	if (template === void 0) return merged;
 	if (template !== null) return {
 		...merged,
@@ -32552,7 +32884,7 @@ var NcSummaryStore = class {
 			createdAt: existing.createdAt,
 			updatedAt: this.now()
 		};
-		return this.write(applyAiPatch(applyFiltersPatch(applyTemplatePatch$1(merged, template), filters), ai));
+		return this.write(applyAiPatch(applyFiltersPatch(applyTemplatePatch$2(merged, template), filters), ai));
 	}
 	async setEnabled(ruleId, enabled) {
 		return this.update(ruleId, { enabled });
@@ -32604,6 +32936,408 @@ var NcSummaryStore = class {
 	}
 };
 //#endregion
+//#region src/notification-center/calendar-events/calendar-events-store.ts
+/**
+* Durable calendar-events rule set — same DurableLedger mechanics as
+* Summaries, with a per-rule `generatedAt` stamp (one fire per schedule window).
+*/
+/**
+* @durable class=config owner=notification-center
+*   write="an operator creates or edits a calendar-events rule, or the producer stamps a delivered window via markGenerated"
+*   retention="none — a row goes only when the operator deletes the rule."
+*/
+var NC_CALENDAR_EVENTS_RULES_COLLECTION = "notification-center:calendar-events-rules";
+var NC_CALENDAR_EVENTS_RULES_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "name",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "enabled",
+		type: "BOOLEAN",
+		notNull: true
+	},
+	{
+		name: "updatedAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "rule",
+		type: "JSON",
+		notNull: true
+	}
+];
+var NC_CALENDAR_EVENTS_RULES_INDEXES = [{
+	name: "idx_nc_calendar_events_rules_enabled",
+	columns: ["enabled"]
+}];
+var LOAD_LIMIT$1 = 1e4;
+var NC_CALENDAR_EVENTS_RULES_SPEC = {
+	collection: NC_CALENDAR_EVENTS_RULES_COLLECTION,
+	columns: [...NC_CALENDAR_EVENTS_RULES_COLUMNS],
+	indexes: [...NC_CALENDAR_EVENTS_RULES_INDEXES],
+	writeMode: "write-through",
+	keyOf: (rule) => rule.id,
+	toValue: (rule) => ({
+		name: rule.name,
+		enabled: rule.enabled,
+		updatedAt: rule.updatedAt,
+		rule
+	}),
+	fromRecord: (_key, data) => {
+		const parsed = NcCalendarEventsRuleSchema.safeParse(data["rule"]);
+		return parsed.success ? parsed.data : null;
+	},
+	loadLimit: LOAD_LIMIT$1
+};
+function applyTemplatePatch$1(merged, template) {
+	if (template === void 0) return merged;
+	if (template !== null) return {
+		...merged,
+		template
+	};
+	const { template: _cleared, ...rest } = merged;
+	return rest;
+}
+function applyOptionalStringList(merged, key, value) {
+	if (value === void 0) return merged;
+	if (value !== null) return {
+		...merged,
+		[key]: [...value]
+	};
+	const { [key]: _cleared, ...rest } = merged;
+	return rest;
+}
+var NcCalendarEventsStore = class {
+	ledger;
+	store;
+	logger;
+	now;
+	newId;
+	constructor(deps) {
+		this.store = deps.store;
+		this.ledger = new DurableLedger({
+			spec: NC_CALENDAR_EVENTS_RULES_SPEC,
+			store: deps.store,
+			logger: deps.logger
+		});
+		this.logger = deps.logger;
+		this.now = deps.now ?? (() => Date.now());
+		this.newId = deps.newId ?? (() => (0, node_crypto.randomUUID)());
+	}
+	static async declare(store) {
+		await DurableLedger.declare(store, NC_CALENDAR_EVENTS_RULES_SPEC);
+	}
+	async load() {
+		await this.ledger.load();
+		this.logger.debug("calendar-events rules loaded", { meta: { rules: this.ledger.size } });
+	}
+	list() {
+		return this.ledger.snapshot().toSorted((a, b) => b.updatedAt - a.updatedAt);
+	}
+	listEnabled() {
+		return this.list().filter((r) => r.enabled);
+	}
+	get(ruleId) {
+		return this.ledger.get(ruleId) ?? null;
+	}
+	listForOwner(userId) {
+		return this.list().filter((r) => r.ownerUserId === void 0 || r.ownerUserId === userId);
+	}
+	async create(input, createdBy, ownerUserId) {
+		const now = this.now();
+		const rule = NcCalendarEventsRuleSchema.parse({
+			...NcCalendarEventsRuleInputSchema.parse(input),
+			id: this.newId(),
+			...ownerUserId !== void 0 ? { ownerUserId } : {},
+			createdBy,
+			createdAt: now,
+			updatedAt: now
+		});
+		await this.ledger.put(rule);
+		return rule;
+	}
+	async update(ruleId, patch) {
+		const existing = this.ledger.get(ruleId);
+		if (!existing) throw new Error(`calendar-events rule not found: ${ruleId}`);
+		const { template, calendars, calendarsExclude, ...rest } = patch;
+		const merged = {
+			...existing,
+			...rest,
+			id: existing.id,
+			...existing.ownerUserId !== void 0 ? { ownerUserId: existing.ownerUserId } : {},
+			...existing.generatedAt !== void 0 ? { generatedAt: existing.generatedAt } : {},
+			createdBy: existing.createdBy,
+			createdAt: existing.createdAt,
+			updatedAt: this.now()
+		};
+		return this.write(applyOptionalStringList(applyOptionalStringList(applyTemplatePatch$1(merged, template), "calendars", calendars), "calendarsExclude", calendarsExclude));
+	}
+	async setEnabled(ruleId, enabled) {
+		return this.update(ruleId, { enabled });
+	}
+	async markGenerated(ruleId, windowEndMs) {
+		const existing = this.ledger.get(ruleId);
+		if (!existing) throw new Error(`calendar-events rule not found: ${ruleId}`);
+		return this.write({
+			...existing,
+			generatedAt: Math.max(existing.generatedAt ?? 0, windowEndMs)
+		});
+	}
+	/**
+	* Idempotent delete — unknown ids are a no-op in RAM, still attempted on disk.
+	*
+	* Deliberately NOT {@link DurableLedger.forget}: that swallows a failed
+	* durable delete. Mirror eviction first; durable half re-throws on failure
+	* (same shape as Summaries).
+	*/
+	async delete(ruleId) {
+		this.ledger.evict(ruleId);
+		try {
+			await this.store.delete.mutate({
+				collection: NC_CALENDAR_EVENTS_RULES_COLLECTION,
+				key: ruleId
+			});
+		} catch (err) {
+			this.logger.warn("calendar-events rule durable delete failed", { meta: {
+				ruleId,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+			throw err instanceof Error ? err : new Error(String(err));
+		}
+	}
+	async write(rule) {
+		const validated = NcCalendarEventsRuleSchema.parse(rule);
+		await this.ledger.put(validated);
+		return validated;
+	}
+};
+//#endregion
+//#region src/notification-center/calendar-events/calendar-events-delivery.ts
+function calendarEventsRecordId(ruleId, windowEndMs) {
+	return `calendar-events:${ruleId}:${windowEndMs}`;
+}
+/** `YYYY-MM-DD HH:MM` in the host timezone. */
+function clockOf$1(atMs) {
+	const d = new Date(atMs);
+	return `${`${String(d.getFullYear())}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`} ${`${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`}`;
+}
+function formatEventLine(event) {
+	const when = event.allDay ? clockOf$1(event.startMs).slice(0, 10) : `${clockOf$1(event.startMs)}–${clockOf$1(event.endMs)}`;
+	const where = event.location !== void 0 && event.location.length > 0 ? ` @ ${event.location}` : "";
+	return `• ${when} ${event.title}${where}`;
+}
+function derivedBody$1(input) {
+	if (input.events.length === 0) return `No events in the next ${String(input.horizonDays)} day(s).`;
+	const lines = input.events.slice(0, 40).map(formatEventLine);
+	const extra = input.events.length > 40 ? `\n…and ${String(input.events.length - 40)} more` : "";
+	return lines.join("\n") + extra;
+}
+function templateVars(input) {
+	return {
+		rule: input.ruleName,
+		count: String(input.events.length),
+		horizonDays: String(input.horizonDays),
+		from: clockOf$1(input.eventWindow.startMs),
+		to: clockOf$1(input.eventWindow.endMs),
+		events: derivedBody$1(input),
+		calendars: String(input.calendarIds.length)
+	};
+}
+function paramsFor$1(target) {
+	const params = target.params;
+	if (params === void 0) return void 0;
+	const out = {};
+	for (const [k, v] of Object.entries(params)) if (typeof v === "string") out[k] = v;
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+/**
+* One outbox row per enabled target. Ready for `NcOutbox.enqueue`.
+*/
+function buildCalendarEventsOutboxInputs(input) {
+	const vars = templateVars(input);
+	const optedOut = new Set(input.disabledTargetIds ?? []);
+	const title = renderTemplate(input.template?.title, vars) ?? `${input.ruleName}: ${String(input.events.length)} upcoming`;
+	const body = renderTemplate(input.template?.body, vars) ?? derivedBody$1(input);
+	const recordId = calendarEventsRecordId(input.ruleId, input.scheduleWindow.endMs);
+	return input.targets.filter((t) => !optedOut.has(t.targetId)).map((target) => {
+		const payload = {
+			ruleName: input.ruleName,
+			delivery: "calendar-events",
+			priority: input.priority,
+			template: {
+				title,
+				body
+			},
+			media: "none",
+			...paramsFor$1(target) !== void 0 ? { params: paramsFor$1(target) } : {},
+			subject: {
+				deviceId: NC_SYSTEM_DEVICE_ID$1,
+				className: "calendar-events",
+				zones: [],
+				timestamp: input.scheduleWindow.endMs
+			}
+		};
+		return {
+			ruleId: input.ruleId,
+			targetId: target.targetId,
+			deviceId: NC_SYSTEM_DEVICE_ID$1,
+			recordKind: "calendar-events",
+			recordId,
+			payload
+		};
+	});
+}
+//#endregion
+//#region src/notification-center/calendar-events/calendar-events-selection.ts
+/**
+* Expand a rule's calendar scope against the known calendar ids.
+*
+* - All (both lists empty/absent) → every known id
+* - Only → the include list, intersected with known (unknown ids dropped)
+* - Except → known minus the exclude list
+*
+* An empty known set always yields empty — there is nothing to notify about.
+*/
+function expandCalendarScope(scope, knownIds) {
+	const known = [...knownIds];
+	if (known.length === 0) return [];
+	const include = scope?.calendars ?? [];
+	const exclude = scope?.calendarsExclude ?? [];
+	if (include.length > 0) {
+		const wanted = new Set(include);
+		return known.filter((id) => wanted.has(id));
+	}
+	if (exclude.length > 0) {
+		const banned = new Set(exclude);
+		return known.filter((id) => !banned.has(id));
+	}
+	return known;
+}
+//#endregion
+//#region src/notification-center/calendar-events/calendar-events-producer.ts
+/** How far back a closed schedule window may still be owed. */
+var CALENDAR_EVENTS_LOOKBACK_MS = 2160 * 60 * 1e3;
+var NcCalendarEventsProducer = class {
+	deps;
+	inFlight = false;
+	now;
+	constructor(deps) {
+		this.deps = deps;
+		this.now = deps.now ?? (() => Date.now());
+	}
+	async tick() {
+		if (this.inFlight) return {
+			examined: 0,
+			sent: 0,
+			empty: 0,
+			skipped: 0,
+			failed: 0
+		};
+		this.inFlight = true;
+		const report = {
+			examined: 0,
+			sent: 0,
+			empty: 0,
+			skipped: 0,
+			failed: 0
+		};
+		try {
+			const rules = this.deps.store.listEnabled();
+			for (const rule of rules) {
+				report.examined += 1;
+				try {
+					const outcome = await this.runRule(rule);
+					if (outcome === "sent") report.sent += 1;
+					else if (outcome === "empty") report.empty += 1;
+					else report.skipped += 1;
+				} catch (err) {
+					report.failed += 1;
+					this.deps.logger.warn("calendar-events rule failed", { meta: {
+						ruleId: rule.id,
+						error: err instanceof Error ? err.message : String(err)
+					} });
+				}
+			}
+			return report;
+		} finally {
+			this.inFlight = false;
+		}
+	}
+	async runRule(rule) {
+		const nowMs = this.now();
+		const scheduleWindow = findLastClosedWindow({
+			schedule: rule.schedule,
+			nowMs,
+			lookbackMs: CALENDAR_EVENTS_LOOKBACK_MS
+		});
+		if (scheduleWindow === null) return "skipped";
+		if ((rule.generatedAt ?? 0) >= scheduleWindow.endMs) return "skipped";
+		const known = await this.deps.calendars.listCalendars();
+		const calendarIds = expandCalendarScope({
+			calendars: rule.calendars,
+			calendarsExclude: rule.calendarsExclude
+		}, known.map((c) => c.id));
+		if (calendarIds.length === 0) {
+			this.deps.logger.info("calendar-events: no calendars in scope", { meta: { ruleId: rule.id } });
+			if (!rule.deliverEmpty) {
+				await this.deps.store.markGenerated(rule.id, scheduleWindow.endMs);
+				return "empty";
+			}
+		}
+		const eventWindow = calendarEventsWindow(nowMs, rule.horizonDays);
+		const events = calendarIds.length === 0 ? [] : await this.deps.calendars.listEvents({
+			calendarIds,
+			startMs: eventWindow.startMs,
+			endMs: eventWindow.endMs
+		});
+		if (events.length === 0 && !rule.deliverEmpty) {
+			this.deps.logger.info("calendar-events: empty horizon, not delivering", { meta: {
+				ruleId: rule.id,
+				horizonDays: eventWindow.horizonDays
+			} });
+			await this.deps.store.markGenerated(rule.id, scheduleWindow.endMs);
+			return "empty";
+		}
+		const sorted = [...events].toSorted((a, b) => a.startMs - b.startMs);
+		await this.enqueue(rule, scheduleWindow, eventWindow, calendarIds, sorted);
+		await this.deps.store.markGenerated(rule.id, scheduleWindow.endMs);
+		return "sent";
+	}
+	async enqueue(rule, scheduleWindow, eventWindow, calendarIds, events) {
+		const inputs = buildCalendarEventsOutboxInputs({
+			ruleId: rule.id,
+			ruleName: rule.name,
+			scheduleWindow,
+			eventWindow: {
+				startMs: eventWindow.startMs,
+				endMs: eventWindow.endMs
+			},
+			horizonDays: eventWindow.horizonDays,
+			events,
+			calendarIds,
+			targets: rule.targets,
+			priority: rule.priority,
+			...rule.template !== void 0 ? { template: rule.template } : {}
+		});
+		for (const input of inputs) await this.deps.outbox.enqueue(input);
+		this.deps.logger.info("calendar-events delivered", { meta: {
+			ruleId: rule.id,
+			events: events.length,
+			targets: inputs.length,
+			windowEndMs: scheduleWindow.endMs
+		} });
+	}
+};
+//#endregion
 //#region src/notification-center/text-catalog-editor.ts
 var NcTextCatalogEditor = class {
 	store;
@@ -35573,6 +36307,8 @@ var NC_ALARM_SETTINGS_FALLBACK = {
 	...DEFAULT_DELAYS,
 	announceTargets: [],
 	nonBlocking: [],
+	blocking: [],
+	secureOnArmOff: [],
 	modeDelays: []
 };
 /**
@@ -35685,7 +36421,7 @@ function packagePhaseOf(ev) {
 */
 function historyRecordKind(kind) {
 	if (kind === "audio-event" || kind === "audio-window") return "object-event";
-	if (kind === "timelapse" || kind === "ai-summary") return "system-event";
+	if (kind === "timelapse" || kind === "ai-summary" || kind === "calendar-events") return "system-event";
 	return kind;
 }
 /**
@@ -35700,7 +36436,8 @@ function historyRecordKind(kind) {
 function cooldownSubjectKind(kind) {
 	switch (kind) {
 		case "timelapse":
-		case "ai-summary": return "device-event";
+		case "ai-summary":
+		case "calendar-events": return "device-event";
 		default: return kind;
 	}
 }
@@ -35800,7 +36537,7 @@ function outboxEntryToHistory(texts, entry) {
 		id: entry.id,
 		ruleId: entry.ruleId,
 		ruleName: entry.payload.ruleName,
-		delivery: entry.payload.delivery === "timelapse" || entry.payload.delivery === "ai-summary" ? "system-event" : entry.payload.delivery,
+		delivery: entry.payload.delivery === "timelapse" || entry.payload.delivery === "ai-summary" || entry.payload.delivery === "calendar-events" ? "system-event" : entry.payload.delivery,
 		targetId: entry.targetId,
 		deviceId: entry.deviceId,
 		recordKind: historyRecordKind(entry.recordKind),
@@ -36010,6 +36747,9 @@ var NotificationCenter = class {
 	*/
 	summaryRules;
 	summaryProducer = null;
+	/** Calendar-events digest rules + producer (hub-only producer). */
+	calendarEventsRules;
+	calendarEventsProducer = null;
 	/**
 	* What the deleted-device / deleted-target prune did, and why — its
 	* disable-once guard and the source of both UIs' banner. Loaded on EVERY
@@ -37000,6 +37740,11 @@ var NotificationCenter = class {
 			logger: this.logger.child("summary"),
 			...deps.now !== void 0 ? { now: deps.now } : {}
 		});
+		this.calendarEventsRules = new NcCalendarEventsStore({
+			store: deps.store,
+			logger: this.logger.child("calendar-events"),
+			...deps.now !== void 0 ? { now: deps.now } : {}
+		});
 		this.pruneLedger = new NcPruneLedger({
 			store: deps.store,
 			logger: this.logger.child("device-prune")
@@ -37046,6 +37791,14 @@ var NotificationCenter = class {
 				zoneOwner: this.zoneOwners.lookup()
 			});
 		}
+		const calendarsPort = deps.calendars;
+		if (calendarsPort !== void 0) this.calendarEventsProducer = new NcCalendarEventsProducer({
+			store: this.calendarEventsRules,
+			outbox: this.outbox,
+			calendars: calendarsPort,
+			logger: this.logger.child("calendar-events"),
+			now: this.now
+		});
 	}
 	/**
 	* The durable timelapse rule set — exposed for the `nc.*Timelapse*` bridge
@@ -37059,6 +37812,10 @@ var NotificationCenter = class {
 	get summaryStore() {
 		return this.summaryRules;
 	}
+	/** The durable calendar-events rule set — exposed for the `nc.*CalendarEvents*` bridge. */
+	get calendarEventsStore() {
+		return this.calendarEventsRules;
+	}
 	/**
 	* Produce one digest window for one rule, right now.
 	*
@@ -37132,6 +37889,7 @@ var NotificationCenter = class {
 		await NcDeviceMuteStore.declare(store);
 		await TimelapseStore.declare(store);
 		await NcSummaryStore.declare(store);
+		await NcCalendarEventsStore.declare(store);
 		await NcRuleAiStore.declare(store);
 		await NcTextCatalogStore.declare(store);
 		await NcArtifactIndex.declare(store);
@@ -38577,6 +39335,9 @@ var NotificationCenter = class {
 	alarmArmGuard() {
 		return {
 			openings: (mode) => this.alarmOpenings(mode),
+			secureOnArm: (devices) => {
+				this.secureDevicesOnArm(devices);
+			},
 			announceRefusal: (input) => this.announceArmRefused(input),
 			announceCheckFailed: (input) => this.announceArmCheckFailed(input)
 		};
@@ -38643,7 +39404,9 @@ var NotificationCenter = class {
 			if (verdict.kind === "open") open.push({
 				deviceId,
 				name: name(deviceId),
-				state: verdict.state
+				state: verdict.state,
+				controllable: verdict.controllable,
+				cap: verdict.cap
 			});
 		}
 		this.logger.info("alarm arm check", {
@@ -38662,6 +39425,47 @@ var NotificationCenter = class {
 		};
 	}
 	/**
+	* Fire-and-forget secure actuation for controllable openings on arm.
+	* Failures are WARN per device — they never refuse the arm.
+	*/
+	async secureDevicesOnArm(devices) {
+		for (const device of devices) {
+			const actuation = device.cap !== void 0 ? require_clip_model_registry.secureActuationFor(device.cap) : null;
+			if (actuation === null) continue;
+			try {
+				await this.actuateWithAttribution({
+					deviceId: device.deviceId,
+					cap: actuation.cap,
+					method: actuation.method,
+					args: {
+						deviceId: device.deviceId,
+						...actuation.args
+					}
+				});
+				this.logger.info("alarm secure-on-arm actuated", {
+					tags: { deviceId: device.deviceId },
+					meta: {
+						name: device.name,
+						state: device.state,
+						cap: actuation.cap,
+						method: actuation.method
+					}
+				});
+			} catch (err) {
+				this.logger.warn("alarm secure-on-arm actuation failed — arm continues", {
+					tags: { deviceId: device.deviceId },
+					meta: {
+						name: device.name,
+						state: device.state,
+						cap: actuation.cap,
+						method: actuation.method,
+						error: String(err)
+					}
+				});
+			}
+		}
+	}
+	/**
 	* The refusal, as an ordinary notification.
 	*
 	* Same path every alarm announcement takes (D126: the alarm speaks through
@@ -40708,11 +41512,17 @@ var NotificationCenter = class {
 		await this.rules.load();
 		this.noteInertGroupedRules();
 		if (this.evaluationActive) this.deviceAlerts.tick();
-		if (this.evaluationActive) this.stateSummary.tick().catch((err) => {
-			this.logger.warn("state summary tick failed", { meta: { error: String(err) } });
-		});
+		if (this.evaluationActive) {
+			this.stateSummary.tick().catch((err) => {
+				this.logger.warn("state summary tick failed", { meta: { error: String(err) } });
+			});
+			this.calendarEventsProducer?.tick().catch((err) => {
+				this.logger.warn("calendar-events tick failed", { meta: { error: String(err) } });
+			});
+		}
 		await this.timelapseRules.load();
 		await this.summaryRules.load();
+		await this.calendarEventsRules.load();
 		await this.ruleAi.load();
 		await this.reloadTexts();
 		this.refreshOccupancyWatch();
@@ -104595,6 +105405,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				store: center.summaryStore,
 				runNow: (input) => center.runSummaryNow(input)
 			},
+			calendarEvents: { store: center.calendarEventsStore },
 			texts: center.textCatalogEditor,
 			previewTexts: center.textCatalog,
 			...this.ncArtifactIndex !== null ? { artifacts: this.ncArtifactIndex } : {},
@@ -105782,7 +106593,17 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				})).tracks;
 			},
 			...this.isPostProcessingNode ? { timelapse: this.buildTimelapsePorts(api, stores) } : {},
-			...this.isPostProcessingNode ? { summary: this.buildSummaryPorts(api, stores) } : {}
+			...this.isPostProcessingNode ? { summary: this.buildSummaryPorts(api, stores) } : {},
+			...this.isPostProcessingNode ? { calendars: {
+				listCalendars: async () => {
+					return (await api.calendars.listCalendars.query()).map((c) => ({ id: c.id }));
+				},
+				listEvents: async (input) => api.calendars.listEvents.query({
+					calendarIds: [...input.calendarIds],
+					startMs: input.startMs,
+					endMs: input.endMs
+				})
+			} } : {}
 		});
 		this.wireAlarmPanel(this.notificationCenter);
 		await this.serveNcActionPlane(this.notificationCenter);