@switchbot/openapi-cli 3.6.1 → 3.6.2

package/dist/index.js

@@ -989,8 +989,8 @@ var require_command = __commonJS({
     init_cjs_shim();
     var EventEmitter = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
-    var path29 = __require("node:path");
-    var fs33 = __require("node:fs");
+    var path31 = __require("node:path");
+    var fs36 = __require("node:fs");
     var process4 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1922,11 +1922,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path29.resolve(baseDir, baseName);
-          if (fs33.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path29.extname(baseName))) return void 0;
+          const localBin = path31.resolve(baseDir, baseName);
+          if (fs36.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path31.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs33.existsSync(`${localBin}${ext}`)
+            (ext) => fs36.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1938,21 +1938,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs33.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs36.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path29.resolve(
-            path29.dirname(resolvedScriptPath),
+          executableDir = path31.resolve(
+            path31.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path29.basename(
+            const legacyName = path31.basename(
               this._scriptPath,
-              path29.extname(this._scriptPath)
+              path31.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1963,7 +1963,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path29.extname(executableFile));
+        launchWithNode = sourceExt.includes(path31.extname(executableFile));
         let proc;
         if (process4.platform !== "win32") {
           if (launchWithNode) {
@@ -2803,7 +2803,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path29.basename(filename, path29.extname(filename));
+        this._name = path31.basename(filename, path31.extname(filename));
         return this;
       }
       /**
@@ -2817,9 +2817,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path30) {
-        if (path30 === void 0) return this._executableDir;
-        this._executableDir = path30;
+      executableDir(path32) {
+        if (path32 === void 0) return this._executableDir;
+        this._executableDir = path32;
         return this;
       }
       /**
@@ -4340,7 +4340,7 @@ var require_supports_colors = __commonJS({
   "node_modules/@colors/colors/lib/system/supports-colors.js"(exports, module) {
     "use strict";
     init_cjs_shim();
-    var os26 = __require("os");
+    var os27 = __require("os");
     var hasFlag2 = require_has_flag();
     var env2 = process.env;
     var forceColor = void 0;
@@ -4378,7 +4378,7 @@ var require_supports_colors = __commonJS({
       }
       var min = forceColor ? 1 : 0;
       if (process.platform === "win32") {
-        var osRelease = os26.release().split(".");
+        var osRelease = os27.release().split(".");
         if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -7853,9 +7853,9 @@ var init_catalog = __esm({
       {
         type: "Smart Lock",
         category: "physical",
-        description: "Bluetooth/Wi-Fi electronic deadbolt that locks and unlocks a door via cloud API.",
+        description: 'Bluetooth/Wi-Fi electronic deadbolt that locks and unlocks a door via cloud API. Pro models support the Matter protocol when configured via the SwitchBot app (deviceType "Smart Lock Pro Wifi").',
         role: "security",
-        aliases: ["Lock", "Smart Lock Pro", "Lock Pro"],
+        aliases: ["Lock", "Smart Lock Pro", "Lock Pro", "Smart Lock Pro Wifi"],
         commands: [
           { command: "lock", parameter: "\u2014", description: "Lock the door", idempotent: true },
           { command: "unlock", parameter: "\u2014", description: "Unlock the door", idempotent: true, safetyTier: "destructive", safetyReason: "Physically unlocks the door \u2014 anyone nearby can open it." },
@@ -7888,6 +7888,29 @@ var init_catalog = __esm({
         ],
         statusFields: ["battery", "version", "lockState", "doorState", "calibrate"]
       },
+      {
+        type: "Lock Vision",
+        category: "physical",
+        description: "Video smart lock with built-in camera; supports lock and unlock control plus status reporting.",
+        role: "security",
+        commands: [
+          { command: "lock", parameter: "\u2014", description: "Lock the door", idempotent: true },
+          { command: "unlock", parameter: "\u2014", description: "Unlock the door", idempotent: true, safetyTier: "destructive", safetyReason: "Physically unlocks the door \u2014 anyone nearby can open it." }
+        ],
+        statusFields: ["lockState", "doorState", "battery", "keyList", "version"]
+      },
+      {
+        type: "Lock Vision Pro",
+        category: "physical",
+        description: "Pro-tier video smart lock with camera; supports lock, unlock, and deadbolt control.",
+        role: "security",
+        commands: [
+          { command: "lock", parameter: "\u2014", description: "Lock the door", idempotent: true },
+          { command: "unlock", parameter: "\u2014", description: "Unlock the door", idempotent: true, safetyTier: "destructive", safetyReason: "Physically unlocks the door \u2014 anyone nearby can open it." },
+          { command: "deadbolt", parameter: "\u2014", description: "Engage deadbolt", idempotent: true }
+        ],
+        statusFields: ["lockState", "doorState", "battery", "keyList", "version"]
+      },
       {
         type: "Plug",
         category: "physical",
@@ -8195,11 +8218,12 @@ var init_catalog = __esm({
       {
         type: "AI Art Frame",
         category: "physical",
-        description: "Digital art frame that can switch to the next or previous image.",
+        description: "Digital art frame that can switch images and accept new artwork uploads.",
         role: "other",
         commands: [
           { command: "next", parameter: "\u2014", description: "Switch to the next image", idempotent: false },
-          { command: "previous", parameter: "\u2014", description: "Switch to the previous image", idempotent: false }
+          { command: "previous", parameter: "\u2014", description: "Switch to the previous image", idempotent: false },
+          { command: "uploadImage", parameter: "<imageUrl>", description: "Upload a new image from an https:// URL to display on the frame", idempotent: true, exampleParams: ["https://example.com/art.jpg"] }
         ],
         statusFields: ["version"]
       },
@@ -8225,6 +8249,16 @@ var init_catalog = __esm({
         commands: [],
         statusFields: ["temperature", "humidity", "battery", "version"]
       },
+      {
+        type: "WeatherStation",
+        category: "physical",
+        description: "Outdoor weather station reporting temperature, humidity, and atmospheric pressure; read-only.",
+        role: "sensor",
+        readOnly: true,
+        aliases: ["Weather Station"],
+        commands: [],
+        statusFields: ["temperature", "humidity", "atmosphericPressure", "battery", "version"]
+      },
       {
         type: "Motion Sensor",
         category: "physical",
@@ -9521,6 +9555,161 @@ var init_credential = __esm({
   }
 });
 
+// src/devices/history-query.ts
+import fs10 from "node:fs";
+import path10 from "node:path";
+import os11 from "node:os";
+import readline2 from "node:readline";
+function historyDir2() {
+  return path10.join(os11.homedir(), ".switchbot", "device-history");
+}
+function parseDurationToMs2(spec) {
+  const m2 = spec.trim().match(/^(\d+)(ms|s|m|h|d)$/i);
+  if (!m2) return null;
+  const n = Number(m2[1]);
+  const unit = m2[2].toLowerCase();
+  const factor = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return n * factor;
+}
+function parseInstantToMs(spec) {
+  const ms = Date.parse(spec);
+  return Number.isFinite(ms) ? ms : null;
+}
+function resolveRange(opts) {
+  let fromMs = Number.NEGATIVE_INFINITY;
+  let toMs = Number.POSITIVE_INFINITY;
+  if (opts.since && (opts.from || opts.to)) {
+    throw new Error("--since is mutually exclusive with --from/--to.");
+  }
+  if (opts.since) {
+    const durMs = parseDurationToMs2(opts.since);
+    if (durMs === null) {
+      throw new Error(`Invalid --since value "${opts.since}". Expected e.g. "30s", "15m", "1h", "7d".`);
+    }
+    fromMs = Date.now() - durMs;
+  } else {
+    if (opts.from) {
+      const parsed = parseInstantToMs(opts.from);
+      if (parsed === null) throw new Error(`Invalid --from value "${opts.from}". Expected ISO-8601 timestamp.`);
+      fromMs = parsed;
+    }
+    if (opts.to) {
+      const parsed = parseInstantToMs(opts.to);
+      if (parsed === null) throw new Error(`Invalid --to value "${opts.to}". Expected ISO-8601 timestamp.`);
+      toMs = parsed;
+    }
+    if (fromMs > toMs) throw new Error("--from must be <= --to.");
+  }
+  return { fromMs, toMs };
+}
+function jsonlFilesForDevice(deviceId, baseDir = historyDir2()) {
+  const out = [];
+  if (!fs10.existsSync(baseDir)) return out;
+  for (let i = 3; i >= 1; i--) {
+    const p2 = path10.join(baseDir, `${deviceId}.jsonl.${i}`);
+    if (fs10.existsSync(p2)) out.push(p2);
+  }
+  const current = path10.join(baseDir, `${deviceId}.jsonl`);
+  if (fs10.existsSync(current)) out.push(current);
+  return out;
+}
+function projectFields(record2, fields) {
+  if (fields.length === 0) return record2;
+  const projected = {};
+  const payload = record2.payload ?? {};
+  for (const f2 of fields) {
+    if (f2 in payload) projected[f2] = payload[f2];
+  }
+  return { t: record2.t, topic: record2.topic, deviceType: record2.deviceType, payload: projected };
+}
+async function queryDeviceHistory(deviceId, opts = {}) {
+  const { fromMs, toMs } = resolveRange(opts);
+  const limit = Math.max(0, opts.limit ?? DEFAULT_LIMIT);
+  const fields = opts.fields ?? [];
+  const files = jsonlFilesForDevice(deviceId);
+  const out = [];
+  for (const file2 of files) {
+    try {
+      const stat = fs10.statSync(file2);
+      if (stat.mtimeMs < fromMs) continue;
+    } catch {
+      continue;
+    }
+    const stream = fs10.createReadStream(file2, { encoding: "utf-8" });
+    const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (!line) continue;
+      let rec;
+      try {
+        rec = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const tMs = Date.parse(rec.t);
+      if (!Number.isFinite(tMs)) continue;
+      if (tMs < fromMs || tMs > toMs) continue;
+      out.push(projectFields(rec, fields));
+      if (out.length >= limit) {
+        rl.close();
+        stream.destroy();
+        return out;
+      }
+    }
+  }
+  return out;
+}
+function queryDeviceHistoryStats(deviceId) {
+  const dir = historyDir2();
+  const files = jsonlFilesForDevice(deviceId);
+  let totalBytes = 0;
+  let oldest = null;
+  let newest = null;
+  let count = 0;
+  for (const file2 of files) {
+    try {
+      totalBytes += fs10.statSync(file2).size;
+    } catch {
+    }
+  }
+  for (const file2 of files) {
+    try {
+      const lines = fs10.readFileSync(file2, "utf-8").split("\n");
+      for (const line of lines) {
+        if (!line) continue;
+        count += 1;
+        try {
+          const rec = JSON.parse(line);
+          const tMs = Date.parse(rec.t);
+          if (Number.isFinite(tMs)) {
+            if (oldest === null || tMs < oldest) oldest = tMs;
+            if (newest === null || tMs > newest) newest = tMs;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    deviceId,
+    fileCount: files.length,
+    totalBytes,
+    recordCount: count,
+    oldest: oldest !== null ? new Date(oldest).toISOString() : void 0,
+    newest: newest !== null ? new Date(newest).toISOString() : void 0,
+    jsonlFiles: files.map((f2) => path10.basename(f2)),
+    historyDir: dir
+  };
+}
+var DEFAULT_LIMIT;
+var init_history_query = __esm({
+  "src/devices/history-query.ts"() {
+    "use strict";
+    init_cjs_shim();
+    DEFAULT_LIMIT = 1e3;
+  }
+});
+
 // node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS({
   "node_modules/yaml/dist/nodes/identity.js"(exports) {
@@ -9600,17 +9789,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path29) {
-      const ctrl = callVisitor(key, node, visitor, path29);
+    function visit_(key, node, visitor, path31) {
+      const ctrl = callVisitor(key, node, visitor, path31);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path29, ctrl);
-        return visit_(key, ctrl, visitor, path29);
+        replaceNode(key, path31, ctrl);
+        return visit_(key, ctrl, visitor, path31);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path29 = Object.freeze(path29.concat(node));
+          path31 = Object.freeze(path31.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path29);
+            const ci = visit_(i, node.items[i], visitor, path31);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -9621,13 +9810,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path29 = Object.freeze(path29.concat(node));
-          const ck = visit_("key", node.key, visitor, path29);
+          path31 = Object.freeze(path31.concat(node));
+          const ck = visit_("key", node.key, visitor, path31);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path29);
+          const cv = visit_("value", node.value, visitor, path31);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -9648,17 +9837,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path29) {
-      const ctrl = await callVisitor(key, node, visitor, path29);
+    async function visitAsync_(key, node, visitor, path31) {
+      const ctrl = await callVisitor(key, node, visitor, path31);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path29, ctrl);
-        return visitAsync_(key, ctrl, visitor, path29);
+        replaceNode(key, path31, ctrl);
+        return visitAsync_(key, ctrl, visitor, path31);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path29 = Object.freeze(path29.concat(node));
+          path31 = Object.freeze(path31.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path29);
+            const ci = await visitAsync_(i, node.items[i], visitor, path31);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -9669,13 +9858,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path29 = Object.freeze(path29.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path29);
+          path31 = Object.freeze(path31.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path31);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path29);
+          const cv = await visitAsync_("value", node.value, visitor, path31);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -9702,23 +9891,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path29) {
+    function callVisitor(key, node, visitor, path31) {
       if (typeof visitor === "function")
-        return visitor(key, node, path29);
+        return visitor(key, node, path31);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path29);
+        return visitor.Map?.(key, node, path31);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path29);
+        return visitor.Seq?.(key, node, path31);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path29);
+        return visitor.Pair?.(key, node, path31);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path29);
+        return visitor.Scalar?.(key, node, path31);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path29);
+        return visitor.Alias?.(key, node, path31);
       return void 0;
     }
-    function replaceNode(key, path29, node) {
-      const parent = path29[path29.length - 1];
+    function replaceNode(key, path31, node) {
+      const parent = path31[path31.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -10335,10 +10524,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema2, path29, value) {
+    function collectionFromPath(schema2, path31, value) {
       let v2 = value;
-      for (let i = path29.length - 1; i >= 0; --i) {
-        const k2 = path29[i];
+      for (let i = path31.length - 1; i >= 0; --i) {
+        const k2 = path31[i];
         if (typeof k2 === "number" && Number.isInteger(k2) && k2 >= 0) {
           const a = [];
           a[k2] = v2;
@@ -10357,7 +10546,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path29) => path29 == null || typeof path29 === "object" && !!path29[Symbol.iterator]().next().done;
+    var isEmptyPath = (path31) => path31 == null || typeof path31 === "object" && !!path31[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type2, schema2) {
         super(type2);
@@ -10387,11 +10576,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path29, value) {
-        if (isEmptyPath(path29))
+      addIn(path31, value) {
+        if (isEmptyPath(path31))
           this.add(value);
         else {
-          const [key, ...rest] = path29;
+          const [key, ...rest] = path31;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -10405,8 +10594,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path29) {
-        const [key, ...rest] = path29;
+      deleteIn(path31) {
+        const [key, ...rest] = path31;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -10420,8 +10609,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path29, keepScalar) {
-        const [key, ...rest] = path29;
+      getIn(path31, keepScalar) {
+        const [key, ...rest] = path31;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -10439,8 +10628,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path29) {
-        const [key, ...rest] = path29;
+      hasIn(path31) {
+        const [key, ...rest] = path31;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -10450,8 +10639,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path29, value) {
-        const [key, ...rest] = path29;
+      setIn(path31, value) {
+        const [key, ...rest] = path31;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -12998,9 +13187,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path29, value) {
+      addIn(path31, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path29, value);
+          this.contents.addIn(path31, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -13075,14 +13264,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path29) {
-        if (Collection.isEmptyPath(path29)) {
+      deleteIn(path31) {
+        if (Collection.isEmptyPath(path31)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path29) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path31) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -13097,10 +13286,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path29, keepScalar) {
-        if (Collection.isEmptyPath(path29))
+      getIn(path31, keepScalar) {
+        if (Collection.isEmptyPath(path31))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path29, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path31, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -13111,10 +13300,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path29) {
-        if (Collection.isEmptyPath(path29))
+      hasIn(path31) {
+        if (Collection.isEmptyPath(path31))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path29) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path31) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -13131,13 +13320,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path29, value) {
-        if (Collection.isEmptyPath(path29)) {
+      setIn(path31, value) {
+        if (Collection.isEmptyPath(path31)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path29), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path31), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path29, value);
+          this.contents.setIn(path31, value);
         }
       }
       /**
@@ -15114,9 +15303,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path29) => {
+    visit.itemAtPath = (cst, path31) => {
       let item = cst;
-      for (const [field, index] of path29) {
+      for (const [field, index] of path31) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -15125,23 +15314,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path29) => {
-      const parent = visit.itemAtPath(cst, path29.slice(0, -1));
-      const field = path29[path29.length - 1][0];
+    visit.parentCollection = (cst, path31) => {
+      const parent = visit.itemAtPath(cst, path31.slice(0, -1));
+      const field = path31[path31.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path29, item, visitor) {
-      let ctrl = visitor(item, path29);
+    function _visit(path31, item, visitor) {
+      let ctrl = visitor(item, path31);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path29.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path31.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -15152,10 +15341,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path29);
+            ctrl = ctrl(item, path31);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path29) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path31) : ctrl;
     }
     exports.visit = visit;
   }
@@ -16444,14 +16633,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs33 = this.flowScalar(this.type);
+              const fs36 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map3.items.push({ start, key: fs33, sep: [] });
+                map3.items.push({ start, key: fs36, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs33);
+                this.stack.push(fs36);
               } else {
-                Object.assign(it, { key: fs33, sep: [] });
+                Object.assign(it, { key: fs36, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -16579,13 +16768,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs33 = this.flowScalar(this.type);
+              const fs36 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs33, sep: [] });
+                fc.items.push({ start: [], key: fs36, sep: [] });
               else if (it.sep)
-                this.stack.push(fs33);
+                this.stack.push(fs36);
               else
-                Object.assign(it, { key: fs33, sep: [] });
+                Object.assign(it, { key: fs36, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -20184,8 +20373,8 @@ var require_utils2 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path29) {
-      let input = path29;
+    function removeDotSegments(path31) {
+      let input = path31;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -20385,8 +20574,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path29, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path29 && path29 !== "/" ? path29 : void 0;
+        const [path31, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path31 && path31 !== "/" ? path31 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -20445,7 +20634,7 @@ var require_schemes = __commonJS({
       urnComponent.nss = (uuidComponent.uuid || "").toLowerCase();
       return urnComponent;
     }
-    var http6 = (
+    var http8 = (
       /** @type {SchemeHandler} */
       {
         scheme: "http",
@@ -20454,11 +20643,11 @@ var require_schemes = __commonJS({
         serialize: httpSerialize
       }
     );
-    var https5 = (
+    var https7 = (
       /** @type {SchemeHandler} */
       {
         scheme: "https",
-        domainHost: http6.domainHost,
+        domainHost: http8.domainHost,
         parse: httpParse,
         serialize: httpSerialize
       }
@@ -20502,8 +20691,8 @@ var require_schemes = __commonJS({
     var SCHEMES = (
       /** @type {Record<SchemeName, SchemeHandler>} */
       {
-        http: http6,
-        https: https5,
+        http: http8,
+        https: https7,
         ws,
         wss,
         urn,
@@ -24193,6 +24382,10 @@ function isNotCondition(c) {
 function isLlmCondition(c) {
   return c.llm !== void 0 && typeof c.llm === "object";
 }
+function isEventCountCondition(c) {
+  const ec = c.event_count;
+  return ec !== void 0 && typeof ec === "object" && typeof ec.device === "string";
+}
 var init_types = __esm({
   "src/rules/types.ts"() {
     "use strict";
@@ -24476,7 +24669,7 @@ function locateError(doc, lineCounter, err) {
   return { line: pos.line, col: pos.col };
 }
 function humanMessage(err) {
-  const path29 = err.instancePath || "(root)";
+  const path31 = err.instancePath || "(root)";
   switch (err.keyword) {
     case "required":
       return `missing required property "${err.params.missingProperty}"`;
@@ -24484,21 +24677,21 @@ function humanMessage(err) {
       return `unknown property "${err.params.additionalProperty}"`;
     case "dependentRequired": {
       const { property, missingProperty } = err.params;
-      const parent = path29 === "(root)" ? "" : `${path29}: `;
+      const parent = path31 === "(root)" ? "" : `${path31}: `;
       return `${parent}when "${property}" is set, "${missingProperty}" is also required`;
     }
     case "pattern":
-      return `${path29} does not match pattern ${err.params.pattern}`;
+      return `${path31} does not match pattern ${err.params.pattern}`;
     case "const":
-      return `${path29} must be exactly ${JSON.stringify(err.params.allowedValue)}`;
+      return `${path31} must be exactly ${JSON.stringify(err.params.allowedValue)}`;
     case "enum":
-      return `${path29} must be one of ${JSON.stringify(err.params.allowedValues)}`;
+      return `${path31} must be one of ${JSON.stringify(err.params.allowedValues)}`;
     case "type":
-      return `${path29} must be ${err.params.type}`;
+      return `${path31} must be ${err.params.type}`;
     case "not":
-      return `${path29} is not allowed here`;
+      return `${path31} is not allowed here`;
     default:
-      return `${path29} ${err.message ?? "is invalid"}`;
+      return `${path31} ${err.message ?? "is invalid"}`;
   }
 }
 function hintFor(err) {
@@ -24554,8 +24747,8 @@ function escapeJsonPointerSegment(segment) {
 function isPlausibleDeviceId(value) {
   return HEX_MAC_DEVICE_ID_RE.test(value) || HYPHENATED_DEVICE_ID_RE.test(value);
 }
-function hasErrorAtPath(errors, path29) {
-  return errors.some((err) => err.path === path29);
+function hasErrorAtPath(errors, path31) {
+  return errors.some((err) => err.path === path31);
 }
 function resolvePolicyDeviceRef(raw, aliases) {
   if (!raw) return { ok: false, reason: "missing-device" };
@@ -24578,25 +24771,25 @@ function isDeviceStateConditionLike(value) {
   const candidate = value;
   return typeof candidate.device === "string" && typeof candidate.field === "string" && typeof candidate.op === "string";
 }
-function collectConditionDeviceRefs(condition, path29) {
+function collectConditionDeviceRefs(condition, path31) {
   if (!condition || typeof condition !== "object" || Array.isArray(condition)) return [];
   const out = [];
   if (isDeviceStateConditionLike(condition)) {
-    out.push({ path: `${path29}/device`, ref: condition.device });
+    out.push({ path: `${path31}/device`, ref: condition.device });
   }
   const candidate = condition;
   if (Array.isArray(candidate.all)) {
     for (let i = 0; i < candidate.all.length; i++) {
-      out.push(...collectConditionDeviceRefs(candidate.all[i], `${path29}/all/${i}`));
+      out.push(...collectConditionDeviceRefs(candidate.all[i], `${path31}/all/${i}`));
     }
   }
   if (Array.isArray(candidate.any)) {
     for (let i = 0; i < candidate.any.length; i++) {
-      out.push(...collectConditionDeviceRefs(candidate.any[i], `${path29}/any/${i}`));
+      out.push(...collectConditionDeviceRefs(candidate.any[i], `${path31}/any/${i}`));
     }
   }
   if (candidate.not !== void 0) {
-    out.push(...collectConditionDeviceRefs(candidate.not, `${path29}/not`));
+    out.push(...collectConditionDeviceRefs(candidate.not, `${path31}/not`));
   }
   return out;
 }
@@ -24643,12 +24836,12 @@ function collectOfflineSemanticErrors(loaded, existingErrors) {
   const out = [];
   const aliases = collectAliasMap(data);
   for (const [aliasName, deviceId] of Object.entries(aliases)) {
-    const path29 = `/aliases/${escapeJsonPointerSegment(aliasName)}`;
-    if (hasErrorAtPath(existingErrors, path29)) continue;
+    const path31 = `/aliases/${escapeJsonPointerSegment(aliasName)}`;
+    if (hasErrorAtPath(existingErrors, path31)) continue;
     if (isPlausibleDeviceId(deviceId)) continue;
-    const { line, col } = locateInstancePath(loaded.doc, loaded.lineCounter, path29);
+    const { line, col } = locateInstancePath(loaded.doc, loaded.lineCounter, path31);
     out.push({
-      path: path29,
+      path: path31,
       line,
       col,
       keyword: "alias-device-id",
@@ -24782,12 +24975,12 @@ function validateLoadedPolicyAgainstInventory(loaded, inventory) {
     inventoryById.set(remote.deviceId, { typeName: remote.remoteType });
   }
   for (const [aliasName, deviceId] of Object.entries(aliases)) {
-    const path29 = `/aliases/${escapeJsonPointerSegment(aliasName)}`;
-    if (hasErrorAtPath(errors, path29)) continue;
+    const path31 = `/aliases/${escapeJsonPointerSegment(aliasName)}`;
+    if (hasErrorAtPath(errors, path31)) continue;
     if (!inventoryById.has(deviceId)) {
-      const { line, col } = locateInstancePath(loaded.doc, loaded.lineCounter, path29);
+      const { line, col } = locateInstancePath(loaded.doc, loaded.lineCounter, path31);
       errors.push({
-        path: path29,
+        path: path31,
         line,
         col,
         keyword: "alias-live-device-not-found",
@@ -24851,10 +25044,10 @@ function validateLoadedPolicyAgainstInventory(loaded, inventory) {
         if (!effectiveDeviceId) continue;
         const target = inventoryById.get(effectiveDeviceId);
         if (!target) {
-          const path29 = typeof action?.device === "string" ? devicePath : commandPath;
-          const { line: line2, col: col2 } = locateInstancePath(loaded.doc, loaded.lineCounter, path29);
+          const path31 = typeof action?.device === "string" ? devicePath : commandPath;
+          const { line: line2, col: col2 } = locateInstancePath(loaded.doc, loaded.lineCounter, path31);
           errors.push({
-            path: path29,
+            path: path31,
             line: line2,
             col: col2,
             keyword: "rule-live-device-not-found",
@@ -24960,6 +25153,32 @@ var init_validate = __esm({
   }
 });
 
+// src/llm/pricing.ts
+function calculateCostUsd(model, tokensIn, tokensOut) {
+  const pricing = PRICING[model];
+  if (!pricing) return void 0;
+  const inputCost = tokensIn / 1e6 * pricing.inUsdPer1M;
+  const outputCost = tokensOut / 1e6 * pricing.outUsdPer1M;
+  return inputCost + outputCost;
+}
+var PRICING;
+var init_pricing = __esm({
+  "src/llm/pricing.ts"() {
+    "use strict";
+    init_cjs_shim();
+    PRICING = {
+      // OpenAI — https://openai.com/api/pricing/
+      "gpt-4o-mini": { inUsdPer1M: 0.15, outUsdPer1M: 0.6 },
+      "gpt-4o": { inUsdPer1M: 2.5, outUsdPer1M: 10 },
+      "gpt-4-turbo": { inUsdPer1M: 10, outUsdPer1M: 30 },
+      // Anthropic — https://www.anthropic.com/pricing
+      "claude-haiku-4-5-20251001": { inUsdPer1M: 1, outUsdPer1M: 5 },
+      "claude-sonnet-4-6": { inUsdPer1M: 3, outUsdPer1M: 15 },
+      "claude-opus-4-7": { inUsdPer1M: 15, outUsdPer1M: 75 }
+    };
+  }
+});
+
 // src/llm/providers/openai.ts
 import https from "node:https";
 import http from "node:http";
@@ -24968,9 +25187,11 @@ var init_openai = __esm({
   "src/llm/providers/openai.ts"() {
     "use strict";
     init_cjs_shim();
+    init_pricing();
     OpenAIProvider = class {
       name = "openai";
       model;
+      capabilities = { toolUse: true };
       apiKey;
       baseUrl;
       timeoutMs;
@@ -25095,7 +25316,10 @@ var init_openai = __esm({
         if (!toolCall) throw new Error("OpenAI decide: no tool call in response");
         const args = JSON.parse(toolCall.function.arguments);
         if (typeof args.pass !== "boolean") throw new Error("OpenAI decide: malformed function-call response");
-        return { pass: args.pass, reason: String(args.reason ?? "").slice(0, 200) };
+        const tokensIn = json3.usage?.prompt_tokens ?? 0;
+        const tokensOut = json3.usage?.completion_tokens ?? 0;
+        const usage = json3.usage ? { tokensIn, tokensOut, costUsd: calculateCostUsd(this.model, tokensIn, tokensOut) } : void 0;
+        return { pass: args.pass, reason: String(args.reason ?? "").slice(0, 200), usage };
       }
     };
   }
@@ -25108,9 +25332,11 @@ var init_anthropic = __esm({
   "src/llm/providers/anthropic.ts"() {
     "use strict";
     init_cjs_shim();
+    init_pricing();
     AnthropicProvider = class {
       name = "anthropic";
       model;
+      capabilities = { toolUse: true };
       apiKey;
       timeoutMs;
       maxTokens;
@@ -25225,7 +25451,352 @@ var init_anthropic = __esm({
         if (!toolUse?.input || typeof toolUse.input.pass !== "boolean") {
           throw new Error("Anthropic decide: malformed tool-use response");
         }
-        return { pass: toolUse.input.pass, reason: String(toolUse.input.reason ?? "").slice(0, 200) };
+        const tokensIn = json3.usage?.input_tokens ?? 0;
+        const tokensOut = json3.usage?.output_tokens ?? 0;
+        const usage = json3.usage ? { tokensIn, tokensOut, costUsd: calculateCostUsd(this.model, tokensIn, tokensOut) } : void 0;
+        return { pass: toolUse.input.pass, reason: String(toolUse.input.reason ?? "").slice(0, 200), usage };
+      }
+    };
+  }
+});
+
+// src/llm/providers/structured-output-fallback.ts
+import https3 from "node:https";
+import http2 from "node:http";
+async function decideViaStructuredOutput(opts) {
+  const messages = [
+    { role: "system", content: `${SYSTEM_INSTRUCTION} ${FEW_SHOT_EXAMPLE}` },
+    { role: "user", content: opts.prompt }
+  ];
+  const first = await chatCompletion(opts, messages);
+  const parsed = tryParseDecision(first.text);
+  if (parsed) {
+    return finalize3(parsed, first.usage, opts);
+  }
+  messages.push({ role: "assistant", content: first.text });
+  messages.push({ role: "user", content: REPAIR_INSTRUCTION });
+  const second = await chatCompletion(opts, messages);
+  const repaired = tryParseDecision(second.text);
+  if (repaired) {
+    const merged = mergeUsage(first.usage, second.usage);
+    return finalize3(repaired, merged, opts);
+  }
+  throw new Error(`Structured output fallback could not parse a JSON decision after repair retry. Last response: ${second.text.slice(0, 200)}`);
+}
+async function chatCompletion(opts, messages) {
+  const body = JSON.stringify({
+    model: opts.model,
+    max_tokens: opts.maxTokens ?? 256,
+    temperature: 0,
+    messages
+  });
+  const url2 = new URL(`${opts.baseUrl.replace(/\/+$/, "")}/v1/chat/completions`);
+  const isHttps = url2.protocol === "https:";
+  const responseBody = await new Promise((resolve2, reject) => {
+    const req = (isHttps ? https3 : http2).request(
+      {
+        hostname: url2.hostname,
+        port: url2.port || (isHttps ? 443 : 80),
+        path: url2.pathname,
+        method: "POST",
+        headers: {
+          ...opts.apiKey ? { "Authorization": `Bearer ${opts.apiKey}` } : {},
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body)
+        },
+        timeout: opts.timeoutMs
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          const text2 = Buffer.concat(chunks).toString("utf-8");
+          if (res.statusCode !== void 0 && res.statusCode >= 400) {
+            reject(new Error(`Local LLM API error ${res.statusCode}: ${text2.slice(0, 200)}`));
+          } else {
+            resolve2(text2);
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => req.destroy(new Error("LLM request timeout")));
+    req.write(body);
+    req.end();
+  });
+  const json3 = JSON.parse(responseBody);
+  const text = json3.choices?.[0]?.message?.content ?? "";
+  if (!text) throw new Error("Local LLM returned empty content");
+  const usage = json3.usage ? { input_tokens: json3.usage.prompt_tokens ?? 0, output_tokens: json3.usage.completion_tokens ?? 0 } : void 0;
+  return { text, usage };
+}
+function tryParseDecision(text) {
+  const stripped = text.replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/i, "").trim();
+  const candidates = [stripped, ...extractAllJsonObjects(stripped)];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    try {
+      const obj = JSON.parse(candidate);
+      if (typeof obj.pass !== "boolean") continue;
+      const reason = typeof obj.reason === "string" ? obj.reason : "";
+      return { pass: obj.pass, reason: reason.slice(0, 200) };
+    } catch {
+    }
+  }
+  return null;
+}
+function extractAllJsonObjects(text) {
+  const out = [];
+  let i = 0;
+  while (i < text.length) {
+    const start = text.indexOf("{", i);
+    if (start === -1) break;
+    const block = readBalancedBraces(text, start);
+    if (!block) {
+      i = start + 1;
+      continue;
+    }
+    out.push(block);
+    i = start + block.length;
+  }
+  return out;
+}
+function readBalancedBraces(text, start) {
+  let depth = 0;
+  let inString = false;
+  let escape2 = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (escape2) {
+      escape2 = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escape2 = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return null;
+}
+function mergeUsage(a, b2) {
+  if (!a && !b2) return void 0;
+  return {
+    input_tokens: (a?.input_tokens ?? 0) + (b2?.input_tokens ?? 0),
+    output_tokens: (a?.output_tokens ?? 0) + (b2?.output_tokens ?? 0)
+  };
+}
+function finalize3(decision, rawUsage, opts) {
+  let usage;
+  if (rawUsage) {
+    const tokensIn = rawUsage.input_tokens;
+    const tokensOut = rawUsage.output_tokens;
+    const costUsd = opts.computeCostUsd ? opts.computeCostUsd(opts.model, tokensIn, tokensOut) : void 0;
+    usage = { tokensIn, tokensOut, costUsd };
+  }
+  return { pass: decision.pass, reason: decision.reason, usage };
+}
+var SYSTEM_INSTRUCTION, FEW_SHOT_EXAMPLE, REPAIR_INSTRUCTION;
+var init_structured_output_fallback = __esm({
+  "src/llm/providers/structured-output-fallback.ts"() {
+    "use strict";
+    init_cjs_shim();
+    SYSTEM_INSTRUCTION = [
+      "You are a yes/no decision endpoint for a smart-home rule engine.",
+      "Read the user prompt and reply with ONLY a JSON object in this exact shape:",
+      '{"pass": <true|false>, "reason": "<brief explanation, \u2264200 chars>"}',
+      "No prose, no markdown fences, no extra fields. The JSON must be valid and parseable."
+    ].join(" ");
+    FEW_SHOT_EXAMPLE = [
+      'Example input: "Is the front door locked? Status: lockState=lock"',
+      'Example output: {"pass": true, "reason": "lockState reports lock"}'
+    ].join(" ");
+    REPAIR_INSTRUCTION = [
+      "Your previous response was not valid JSON.",
+      'Reply with ONLY the JSON object: {"pass": <true|false>, "reason": "<short>"}.',
+      "No prose, no markdown."
+    ].join(" ");
+  }
+});
+
+// src/llm/providers/local.ts
+import https4 from "node:https";
+import http3 from "node:http";
+function stripTrailingV1(url2) {
+  return url2.replace(/\/v1\/?$/, "").replace(/\/+$/, "");
+}
+function parseBoolEnv(v2) {
+  if (!v2) return void 0;
+  const lower = v2.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(lower)) return true;
+  if (["0", "false", "no", "off"].includes(lower)) return false;
+  return void 0;
+}
+var DEFAULT_LOCAL_BASE_URL, LocalProvider;
+var init_local = __esm({
+  "src/llm/providers/local.ts"() {
+    "use strict";
+    init_cjs_shim();
+    init_pricing();
+    init_structured_output_fallback();
+    DEFAULT_LOCAL_BASE_URL = "http://localhost:11434/v1";
+    LocalProvider = class {
+      name = "local";
+      model;
+      capabilities;
+      apiKey;
+      baseUrl;
+      timeoutMs;
+      maxTokens;
+      constructor(opts = {}) {
+        this.apiKey = process.env.SWITCHBOT_LOCAL_LLM_API_KEY ?? process.env.LOCAL_LLM_API_KEY ?? "";
+        this.model = opts.model ?? process.env.SWITCHBOT_LOCAL_LLM_MODEL ?? "llama3.2";
+        this.baseUrl = stripTrailingV1(opts.baseUrl ?? process.env.SWITCHBOT_LOCAL_LLM_URL ?? DEFAULT_LOCAL_BASE_URL);
+        this.timeoutMs = opts.timeoutMs ?? 6e4;
+        this.maxTokens = opts.maxTokens ?? 1024;
+        const envToolUse = parseBoolEnv(process.env.SWITCHBOT_LOCAL_LLM_TOOL_USE);
+        const toolUse = opts.toolUse ?? envToolUse ?? false;
+        this.capabilities = { toolUse };
+      }
+      async generateYaml(systemPrompt, userIntent) {
+        const body = JSON.stringify({
+          model: this.model,
+          messages: [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: userIntent }
+          ],
+          max_tokens: this.maxTokens,
+          temperature: 0
+        });
+        const url2 = new URL(`${this.baseUrl}/v1/chat/completions`);
+        const isHttps = url2.protocol === "https:";
+        const responseBody = await new Promise((resolve2, reject) => {
+          const req = (isHttps ? https4 : http3).request(
+            {
+              hostname: url2.hostname,
+              port: url2.port || (isHttps ? 443 : 80),
+              path: url2.pathname,
+              method: "POST",
+              headers: {
+                ...this.apiKey ? { "Authorization": `Bearer ${this.apiKey}` } : {},
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(body)
+              },
+              timeout: this.timeoutMs
+            },
+            (res) => {
+              const chunks = [];
+              res.on("data", (c) => chunks.push(c));
+              res.on("end", () => {
+                const text = Buffer.concat(chunks).toString("utf-8");
+                if (res.statusCode !== void 0 && res.statusCode >= 400) {
+                  reject(new Error(`Local LLM API error ${res.statusCode}: ${text.slice(0, 200)}`));
+                } else {
+                  resolve2(text);
+                }
+              });
+            }
+          );
+          req.on("error", reject);
+          req.on("timeout", () => req.destroy(new Error("LLM request timeout")));
+          req.write(body);
+          req.end();
+        });
+        const json3 = JSON.parse(responseBody);
+        const content = json3.choices?.[0]?.message?.content;
+        if (!content) throw new Error("Local LLM returned empty content");
+        return content.replace(/^```ya?ml\n?/i, "").replace(/\n?```\s*$/i, "").trim();
+      }
+      async decide(prompt2, opts = {}) {
+        const timeoutMs = opts.timeoutMs ?? this.timeoutMs;
+        if (!this.capabilities.toolUse) {
+          return decideViaStructuredOutput({
+            prompt: prompt2,
+            apiKey: this.apiKey,
+            baseUrl: this.baseUrl,
+            model: this.model,
+            timeoutMs,
+            maxTokens: 256,
+            computeCostUsd: calculateCostUsd
+          });
+        }
+        const body = JSON.stringify({
+          model: this.model,
+          max_tokens: 256,
+          tools: [{
+            type: "function",
+            function: {
+              name: "decide",
+              description: "Return a boolean pass/fail decision with a brief reason.",
+              parameters: {
+                type: "object",
+                properties: {
+                  pass: { type: "boolean" },
+                  reason: { type: "string" }
+                },
+                required: ["pass", "reason"]
+              }
+            }
+          }],
+          tool_choice: { type: "function", function: { name: "decide" } },
+          messages: [{ role: "user", content: prompt2 }]
+        });
+        const url2 = new URL(`${this.baseUrl}/v1/chat/completions`);
+        const isHttps = url2.protocol === "https:";
+        const responseBody = await new Promise((resolve2, reject) => {
+          const req = (isHttps ? https4 : http3).request(
+            {
+              hostname: url2.hostname,
+              port: url2.port || (isHttps ? 443 : 80),
+              path: url2.pathname,
+              method: "POST",
+              headers: {
+                ...this.apiKey ? { "Authorization": `Bearer ${this.apiKey}` } : {},
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(body)
+              },
+              timeout: timeoutMs
+            },
+            (res) => {
+              const chunks = [];
+              res.on("data", (c) => chunks.push(c));
+              res.on("end", () => {
+                const text = Buffer.concat(chunks).toString("utf-8");
+                if (res.statusCode !== void 0 && res.statusCode >= 400) {
+                  reject(new Error(`Local LLM API error ${res.statusCode}: ${text.slice(0, 200)}`));
+                } else {
+                  resolve2(text);
+                }
+              });
+            }
+          );
+          req.on("error", reject);
+          req.on("timeout", () => req.destroy(new Error("LLM request timeout")));
+          req.write(body);
+          req.end();
+        });
+        const json3 = JSON.parse(responseBody);
+        const toolCall = json3.choices?.[0]?.message?.tool_calls?.find((tc) => tc.function.name === "decide");
+        if (!toolCall) throw new Error("Local LLM decide: no tool call in response");
+        const args = JSON.parse(toolCall.function.arguments);
+        if (typeof args.pass !== "boolean") throw new Error("Local LLM decide: malformed function-call response");
+        const tokensIn = json3.usage?.prompt_tokens ?? 0;
+        const tokensOut = json3.usage?.completion_tokens ?? 0;
+        const usage = json3.usage ? { tokensIn, tokensOut, costUsd: calculateCostUsd(this.model, tokensIn, tokensOut) } : void 0;
+        return { pass: args.pass, reason: String(args.reason ?? "").slice(0, 200), usage };
+      }
+      /** Exposed for doctor `local-llm-reachable` check. */
+      getEndpoint() {
+        return this.baseUrl;
       }
     };
   }
@@ -25267,8 +25838,9 @@ __export(llm_exports, {
   scoreIntentComplexity: () => scoreIntentComplexity
 });
 function createLLMProvider(backend, opts = {}) {
-  if (backend === "openai" || backend === "local") return new OpenAIProvider(opts);
+  if (backend === "openai") return new OpenAIProvider(opts);
   if (backend === "anthropic") return new AnthropicProvider(opts);
+  if (backend === "local") return new LocalProvider(opts);
   throw new Error(`Unknown LLM backend: ${backend}`);
 }
 var LLM_AUTO_THRESHOLD;
@@ -25278,6 +25850,7 @@ var init_llm = __esm({
     init_cjs_shim();
     init_openai();
     init_anthropic();
+    init_local();
     init_complexity();
     LLM_AUTO_THRESHOLD = 4;
   }
@@ -25482,9 +26055,10 @@ async function evaluateSingle(c, now, ctx) {
       };
     }
     try {
+      const recent = await fetchRecentEvents(c.llm.recent_events, ctx);
       const res = await ctx.llmEvaluator.evaluate(
         c.llm,
-        { event: ctx.event },
+        { event: ctx.event, recentEvents: recent },
         ctx.ruleVersion ?? "unknown",
         ctx.globalLlmMaxCallsPerHour
       );
@@ -25496,6 +26070,44 @@ async function evaluateSingle(c, now, ctx) {
       return fail(`llm condition error: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
+  if (isEventCountCondition(c)) {
+    if (!ctx.eventWindowFetcher) {
+      return {
+        matched: false,
+        failures: [],
+        unsupported: [{ keyword: "event_count", hint: "event_count evaluation requires a history fetcher; this call site did not provide one." }]
+      };
+    }
+    const ec = c.event_count;
+    const resolved = resolveDeviceRef(ec.device, ctx.aliases);
+    if (!resolved) return fail(`event_count: could not resolve device "${ec.device}" to an id (no matching alias).`);
+    const windowMs = parseDurationOrNull(ec.window);
+    if (windowMs === null || windowMs <= 0) {
+      return fail(`event_count: invalid window "${ec.window}" \u2014 expected e.g. "30s", "5m", "1h".`);
+    }
+    const untilMs = now.getTime();
+    const sinceMs = untilMs - windowMs;
+    try {
+      const events = await ctx.eventWindowFetcher(resolved, {
+        sinceMs,
+        untilMs,
+        limit: Math.max(ec.min, ec.max ?? ec.min) + 1,
+        eventName: ec.event
+      });
+      const count = events.length;
+      const min = ec.min;
+      const max = ec.max;
+      const ceilingViolated = max !== void 0 && count > max;
+      const floorViolated = count < min;
+      if (floorViolated || ceilingViolated) {
+        const range = max !== void 0 ? `${min}\u2013${max}` : `\u2265 ${min}`;
+        return fail(`event_count ${ec.device}${ec.event ? ` ${ec.event}` : ""} in ${ec.window}: ${count} (expected ${range})`);
+      }
+      return ok;
+    } catch (err) {
+      return fail(`event_count ${ec.device}: fetch failed \u2014 ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   return {
     matched: false,
     failures: [],
@@ -25562,12 +26174,14 @@ function conditionKind(c) {
   if (isTimeBetween(c)) return "time_between";
   if (isDeviceState(c)) return "device_state";
   if (isLlmCondition(c)) return "llm";
+  if (isEventCountCondition(c)) return "event_count";
   return "unknown";
 }
 function conditionConfig(c) {
   if (isTimeBetween(c)) return c.time_between;
   if (isDeviceState(c)) return { device: c.device, field: c.field, op: c.op, value: c.value };
   if (isLlmCondition(c)) return { prompt: c.llm.prompt.slice(0, 80) };
+  if (isEventCountCondition(c)) return c.event_count;
   return void 0;
 }
 function pushConditionTrace(trace, c, sub) {
@@ -25577,6 +26191,31 @@ function pushConditionTrace(trace, c, sub) {
     passed: sub.unsupported.length > 0 ? false : sub.matched
   });
 }
+function parseDurationOrNull(spec) {
+  const m2 = String(spec ?? "").trim().match(/^(\d+)(ms|s|m|h|d)$/i);
+  if (!m2) return null;
+  const n = Number(m2[1]);
+  const unit = m2[2].toLowerCase();
+  const factor = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return n * factor;
+}
+async function fetchRecentEvents(count, ctx) {
+  if (!count || count <= 0) return void 0;
+  if (!ctx.eventWindowFetcher || !ctx.event?.deviceId) return void 0;
+  const untilMs = ctx.event.t.getTime();
+  const sinceMs = untilMs - 24 * 60 * 60 * 1e3;
+  try {
+    const events = await ctx.eventWindowFetcher(ctx.event.deviceId, {
+      sinceMs,
+      untilMs,
+      limit: count,
+      eventName: ctx.event.event
+    });
+    return events.slice(-count);
+  } catch {
+    return void 0;
+  }
+}
 var EVENT_CLASSIFIERS;
 var init_matcher = __esm({
   "src/rules/matcher.ts"() {
@@ -26502,7 +27141,7 @@ var init_cron_scheduler = __esm({
 });
 
 // src/rules/webhook-listener.ts
-import http2 from "node:http";
+import http4 from "node:http";
 import { timingSafeEqual } from "node:crypto";
 function normalisePath(p2) {
   if (!p2) return "/";
@@ -26558,7 +27197,7 @@ var init_webhook_listener = __esm({
       /** Start listening. Resolves once the server has bound a port. */
       async start() {
         if (this.server) return;
-        const server = http2.createServer((req, res) => {
+        const server = http4.createServer((req, res) => {
           this.handle(req, res).catch((err) => {
             if (!res.headersSent) {
               res.writeHead(500);
@@ -26698,8 +27337,8 @@ var init_webhook_listener = __esm({
 // src/rules/notify.ts
 import fs14 from "node:fs";
 import path12 from "node:path";
-import http3 from "node:http";
-import https3 from "node:https";
+import http5 from "node:http";
+import https5 from "node:https";
 function renderNotifyTemplate(template, vars) {
   return template.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (_2, key) => {
     const val = vars[key];
@@ -26782,7 +27421,7 @@ async function sendWebhook(url2, body) {
         "User-Agent": "switchbot-cli/notify"
       }
     };
-    const req = (isHttps ? https3 : http3).request(options, (res) => {
+    const req = (isHttps ? https5 : http5).request(options, (res) => {
       res.resume();
       const status = res.statusCode ?? 0;
       if (status >= 200 && status < 300) {
@@ -26969,10 +27608,250 @@ var init_trace = __esm({
   }
 });
 
+// src/rules/llm-condition.ts
+import { createHash as createHash4 } from "node:crypto";
+function buildCacheKey(ruleVersion2, promptTemplate, context) {
+  const contextSnapshot = {
+    event: { source: context.event.source, event: context.event.event, deviceId: context.event.deviceId },
+    recentEvents: (context.recentEvents ?? []).map((e) => ({
+      source: e.source,
+      event: e.event,
+      deviceId: e.deviceId
+    }))
+  };
+  const serialized = JSON.stringify([ruleVersion2, promptTemplate, deepSortedJson(contextSnapshot)]);
+  return createHash4("sha256").update(serialized).digest("hex");
+}
+function buildPrompt(template, context) {
+  const eventDesc = `Event: ${context.event.source} ${context.event.event}${context.event.deviceId ? ` on ${context.event.deviceId}` : ""}`;
+  return `${template}
+
+${eventDesc}`;
+}
+function parseCacheTtl(ttl) {
+  if (ttl === "none") return 0;
+  const match = /^(\d+)(s|m|h)$/.exec(ttl);
+  if (!match) return 5 * 60 * 1e3;
+  const n = parseInt(match[1], 10);
+  if (match[2] === "s") return n * 1e3;
+  if (match[2] === "m") return n * 60 * 1e3;
+  return n * 60 * 60 * 1e3;
+}
+function resolveProvider(provider) {
+  if (provider === "auto") {
+    if (process.env.ANTHROPIC_API_KEY) return "anthropic";
+    if (process.env.OPENAI_API_KEY || process.env.LLM_API_KEY) return "openai";
+    throw new Error("No LLM API key found for llm condition. Set ANTHROPIC_API_KEY or OPENAI_API_KEY.");
+  }
+  return provider;
+}
+function onErrorResult(onError, reason) {
+  const pass = onError === "pass";
+  return {
+    pass,
+    traceFields: {
+      provider: "error",
+      model: "error",
+      latencyMs: 0,
+      cacheHit: false,
+      reason: reason.slice(0, 200),
+      promptDigest: ""
+    }
+  };
+}
+var HOUR_MS, DAY_MS, LlmConditionEvaluator;
+var init_llm_condition = __esm({
+  "src/rules/llm-condition.ts"() {
+    "use strict";
+    init_cjs_shim();
+    init_trace();
+    init_audit();
+    HOUR_MS = 60 * 60 * 1e3;
+    DAY_MS = 24 * HOUR_MS;
+    LlmConditionEvaluator = class {
+      cache = /* @__PURE__ */ new Map();
+      budgetCounters = /* @__PURE__ */ new Map();
+      async evaluate(condition, context, ruleVersion2, budgetCaps) {
+        const caps = typeof budgetCaps === "number" ? { maxCallsPerHour: budgetCaps } : { ...budgetCaps ?? {} };
+        if (condition.budget?.max_calls_per_hour !== void 0) caps.maxCallsPerHour = condition.budget.max_calls_per_hour;
+        if (condition.budget?.max_tokens_per_hour !== void 0) caps.maxTokensPerHour = condition.budget.max_tokens_per_hour;
+        if (condition.budget?.max_cost_per_day_usd !== void 0) caps.maxCostPerDayUsd = condition.budget.max_cost_per_day_usd;
+        const cacheKey2 = buildCacheKey(ruleVersion2, condition.prompt, context);
+        const ttlMs = parseCacheTtl(condition.cache_ttl ?? "5m");
+        if (ttlMs > 0) {
+          const cached2 = this.cache.get(cacheKey2);
+          if (cached2 && Date.now() < cached2.expiresAt) {
+            return {
+              pass: cached2.result,
+              traceFields: {
+                provider: "cached",
+                model: "cached",
+                latencyMs: 0,
+                cacheHit: true,
+                reason: cached2.reason,
+                promptDigest: cacheKey2.slice(0, 8)
+              }
+            };
+          }
+        }
+        const budgetKey = `${ruleVersion2}:${condition.prompt.slice(0, 32)}`;
+        const counter = this.rollCounter(budgetKey);
+        const callViolation = this.checkPreCallBudget(counter, caps);
+        if (callViolation) {
+          this.emitBudgetExceeded(callViolation, context, condition);
+          return onErrorResult(condition.on_error ?? "fail", `Budget exceeded (${callViolation.dimension})`);
+        }
+        const backend = resolveProvider(condition.provider ?? "auto");
+        const { createLLMProvider: createLLMProvider2 } = await Promise.resolve().then(() => (init_llm(), llm_exports));
+        const provider = createLLMProvider2(backend, {
+          timeoutMs: condition.timeout_ms ?? 5e3
+        });
+        const prompt2 = buildPrompt(condition.prompt, context);
+        const start = Date.now();
+        try {
+          const result = await provider.decide(prompt2, { timeoutMs: condition.timeout_ms ?? 5e3 });
+          const latencyMs = Date.now() - start;
+          counter.calls += 1;
+          if (result.usage) {
+            counter.tokens += result.usage.tokensIn + result.usage.tokensOut;
+            if (result.usage.costUsd !== void 0) {
+              counter.costUsd += result.usage.costUsd;
+            }
+          }
+          if (ttlMs > 0) {
+            this.cache.set(cacheKey2, {
+              result: result.pass,
+              reason: result.reason,
+              expiresAt: Date.now() + ttlMs,
+              usage: result.usage
+            });
+          }
+          return {
+            pass: result.pass,
+            traceFields: {
+              provider: provider.name,
+              model: provider.model,
+              latencyMs,
+              cacheHit: false,
+              reason: String(result.reason ?? "").slice(0, 200),
+              promptDigest: cacheKey2.slice(0, 8),
+              usage: result.usage
+            }
+          };
+        } catch (err) {
+          return onErrorResult(condition.on_error ?? "fail", String(err));
+        }
+      }
+      rollCounter(key) {
+        const now = Date.now();
+        const existing = this.budgetCounters.get(key);
+        if (!existing) {
+          const fresh = { hourlyStart: now, calls: 0, tokens: 0, dailyStart: now, costUsd: 0 };
+          this.budgetCounters.set(key, fresh);
+          return fresh;
+        }
+        if (now - existing.hourlyStart >= HOUR_MS) {
+          existing.hourlyStart = now;
+          existing.calls = 0;
+          existing.tokens = 0;
+        }
+        if (now - existing.dailyStart >= DAY_MS) {
+          existing.dailyStart = now;
+          existing.costUsd = 0;
+        }
+        return existing;
+      }
+      checkPreCallBudget(counter, caps) {
+        if (caps.maxCallsPerHour !== void 0 && caps.maxCallsPerHour >= 0 && counter.calls >= caps.maxCallsPerHour) {
+          return { dimension: "calls", limit: caps.maxCallsPerHour, observed: counter.calls };
+        }
+        if (caps.maxTokensPerHour !== void 0 && caps.maxTokensPerHour >= 0 && counter.tokens >= caps.maxTokensPerHour) {
+          return { dimension: "tokens", limit: caps.maxTokensPerHour, observed: counter.tokens };
+        }
+        if (caps.maxCostPerDayUsd !== void 0 && caps.maxCostPerDayUsd >= 0 && counter.costUsd >= caps.maxCostPerDayUsd) {
+          return { dimension: "cost", limit: caps.maxCostPerDayUsd, observed: counter.costUsd };
+        }
+        return null;
+      }
+      emitBudgetExceeded(violation, context, _condition) {
+        writeAudit({
+          auditVersion: 2,
+          t: (/* @__PURE__ */ new Date()).toISOString(),
+          kind: "llm-budget-exceeded",
+          deviceId: context.event.deviceId ?? "",
+          command: "llm-condition",
+          parameter: null,
+          commandType: "command",
+          dryRun: false,
+          budgetDimension: violation.dimension,
+          budgetLimit: violation.limit,
+          budgetObserved: violation.observed
+        });
+      }
+    };
+  }
+});
+
+// src/devices/history-window.ts
+import fs15 from "node:fs";
+import readline5 from "node:readline";
+async function queryEventWindow(deviceId, opts) {
+  const { sinceMs, untilMs } = opts;
+  if (!Number.isFinite(sinceMs) || !Number.isFinite(untilMs)) return [];
+  if (sinceMs > untilMs) return [];
+  const limit = Math.max(0, opts.limit ?? Number.POSITIVE_INFINITY);
+  if (limit === 0) return [];
+  const files = jsonlFilesForDevice(deviceId).slice().reverse();
+  const out = [];
+  for (const file2 of files) {
+    let mtimeMs;
+    try {
+      mtimeMs = fs15.statSync(file2).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (mtimeMs < sinceMs) break;
+    const records = await readWindowFromFile(file2, sinceMs, untilMs, opts.eventFilter);
+    out.push(...records);
+    if (out.length >= limit) {
+      return out.slice(0, limit);
+    }
+  }
+  return out;
+}
+async function readWindowFromFile(file2, sinceMs, untilMs, eventFilter) {
+  const stream = fs15.createReadStream(file2, { encoding: "utf-8" });
+  const rl = readline5.createInterface({ input: stream, crlfDelay: Infinity });
+  const out = [];
+  for await (const line of rl) {
+    if (!line) continue;
+    let rec;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const tMs = Date.parse(rec.t);
+    if (!Number.isFinite(tMs)) continue;
+    if (tMs < sinceMs || tMs > untilMs) continue;
+    if (eventFilter && !eventFilter(rec)) continue;
+    out.push(rec);
+  }
+  return out;
+}
+var init_history_window = __esm({
+  "src/devices/history-window.ts"() {
+    "use strict";
+    init_cjs_shim();
+    init_history_query();
+  }
+});
+
 // src/rules/engine.ts
 var engine_exports = {};
 __export(engine_exports, {
   RulesEngine: () => RulesEngine,
+  defaultEventWindowFetcher: () => defaultEventWindowFetcher,
   lintRules: () => lintRules
 });
 import { randomUUID as randomUUID4 } from "node:crypto";
@@ -27190,6 +28069,25 @@ function lintRules(automation) {
           message: "llm condition budget.max_calls_per_hour is 0 \u2014 condition will always take the on_error path."
         });
       }
+      if (llm.budget?.max_tokens_per_hour === 0) {
+        issues.push({
+          rule: r.name,
+          severity: "warning",
+          code: "condition-llm-tokens-budget-zero",
+          message: "llm condition budget.max_tokens_per_hour is 0 \u2014 condition will always take the on_error path."
+        });
+      }
+      if (llm.budget?.max_cost_per_day_usd !== void 0 && llm.budget.max_cost_per_day_usd > 0) {
+        const provider = llm.provider ?? "auto";
+        if (provider === "auto") {
+          issues.push({
+            rule: r.name,
+            severity: "warning",
+            code: "condition-llm-cost-without-known-model",
+            message: 'llm condition sets max_cost_per_day_usd but provider is "auto" \u2014 cost dimension is skipped for any model not in the pricing table.'
+          });
+        }
+      }
       if (llm.on_error === "pass") {
         issues.push({
           rule: r.name,
@@ -27199,6 +28097,26 @@ function lintRules(automation) {
         });
       }
     }
+    for (const c of r.conditions ?? []) {
+      if (!isEventCountCondition(c)) continue;
+      const ec = c.event_count;
+      if (!/^\d+(ms|s|m|h|d)$/.test(String(ec.window ?? ""))) {
+        issues.push({
+          rule: r.name,
+          severity: "error",
+          code: "condition-event-count-bad-window",
+          message: `event_count.window "${ec.window}" must match \`<digits>(ms|s|m|h|d)\` \u2014 e.g. "5m", "1h".`
+        });
+      }
+      if (ec.max !== void 0 && ec.max < ec.min) {
+        issues.push({
+          rule: r.name,
+          severity: "error",
+          code: "condition-event-count-max-below-min",
+          message: `event_count.max (${ec.max}) must be \u2265 min (${ec.min}).`
+        });
+      }
+    }
     const enabled = r.enabled !== false;
     const hasError = issues.some((i) => i.severity === "error");
     const hasUnsupported = issues.some((i) => i.code === "trigger-unsupported");
@@ -27211,6 +28129,21 @@ function lintRules(automation) {
     unsupportedCount
   };
 }
+async function defaultEventWindowFetcher(deviceId, opts) {
+  const records = await queryEventWindow(deviceId, {
+    sinceMs: opts.sinceMs,
+    untilMs: opts.untilMs,
+    limit: opts.limit,
+    eventFilter: opts.eventName ? (rec) => classifyMqttPayload(rec.payload).event === opts.eventName : void 0
+  });
+  return records.map((rec) => ({
+    source: "mqtt",
+    event: classifyMqttPayload(rec.payload).event,
+    t: new Date(rec.t),
+    deviceId,
+    payload: rec.payload
+  }));
+}
 var RulesEngine;
 var init_engine = __esm({
   "src/rules/engine.ts"() {
@@ -27228,6 +28161,8 @@ var init_engine = __esm({
     init_croner();
     init_audit();
     init_trace();
+    init_llm_condition();
+    init_history_window();
     RulesEngine = class {
       opts;
       rules;
@@ -27248,6 +28183,8 @@ var init_engine = __esm({
        * keeps the semantics of `max_per` honest.
        */
       pendingChain = Promise.resolve();
+      llmEvaluator = new LlmConditionEvaluator();
+      eventWindowFetcher = defaultEventWindowFetcher;
       stats = {
         started: false,
         rulesLoaded: 0,
@@ -27577,7 +28514,12 @@ var init_engine = __esm({
         const cond = await evaluateConditions(rule.conditions, event.t, {
           aliases: this.aliases,
           fetchStatus,
-          trace
+          trace,
+          event,
+          llmEvaluator: this.llmEvaluator,
+          ruleVersion: ruleVersion(rule),
+          globalLlmMaxCallsPerHour: this.opts.automation?.llm_budget?.max_calls_per_hour,
+          eventWindowFetcher: this.opts.eventWindowFetcher ?? this.eventWindowFetcher
         });
         if (!cond.matched) {
           const hasHysteresis = rule.hysteresis ?? rule.requires_stable_for;
@@ -27778,6 +28720,162 @@ var init_engine = __esm({
   }
 });
 
+// src/daemon/socket-path.ts
+import os17 from "node:os";
+import fs23 from "node:fs";
+import path18 from "node:path";
+import { execSync } from "node:child_process";
+function getDaemonSocketPath() {
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\switchbot-daemon-${getCurrentUserKey()}`;
+  }
+  return path18.join(os17.homedir(), ".switchbot", "daemon.sock");
+}
+function getCurrentUserKey() {
+  if (cachedUserKey) return cachedUserKey;
+  const fromEnv = process.env.USERNAME ?? process.env.USER;
+  if (fromEnv) {
+    cachedUserKey = sanitize(fromEnv);
+    return cachedUserKey;
+  }
+  try {
+    const userInfo = os17.userInfo();
+    cachedUserKey = sanitize(userInfo.username);
+    return cachedUserKey;
+  } catch {
+  }
+  try {
+    const out = execSync("whoami", { encoding: "utf-8", timeout: 2e3 }).trim();
+    cachedUserKey = sanitize(out.split(/[\\\/]/).pop() ?? "unknown");
+    return cachedUserKey;
+  } catch {
+    cachedUserKey = "unknown";
+    return cachedUserKey;
+  }
+}
+function sanitize(name) {
+  return name.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 64) || "unknown";
+}
+var cachedUserKey;
+var init_socket_path = __esm({
+  "src/daemon/socket-path.ts"() {
+    "use strict";
+    init_cjs_shim();
+    cachedUserKey = null;
+  }
+});
+
+// src/daemon/client.ts
+var client_exports2 = {};
+__export(client_exports2, {
+  IpcDaemonClient: () => IpcDaemonClient,
+  IpcDaemonClientError: () => IpcDaemonClientError
+});
+import net from "node:net";
+import { randomUUID as randomUUID6 } from "node:crypto";
+var IpcDaemonClientError, IpcDaemonClient;
+var init_client3 = __esm({
+  "src/daemon/client.ts"() {
+    "use strict";
+    init_cjs_shim();
+    init_socket_path();
+    IpcDaemonClientError = class extends Error {
+      constructor(message, code, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "IpcDaemonClientError";
+      }
+      code;
+      data;
+    };
+    IpcDaemonClient = class {
+      socketPath;
+      timeoutMs;
+      connectTimeoutMs;
+      constructor(opts = {}) {
+        this.socketPath = opts.socketPath ?? getDaemonSocketPath();
+        this.timeoutMs = opts.timeoutMs ?? 5e3;
+        this.connectTimeoutMs = opts.connectTimeoutMs ?? 2e3;
+      }
+      getSocketPath() {
+        return this.socketPath;
+      }
+      /**
+       * Sends a JSON-RPC request and resolves with the `result` field. Throws
+       * IpcDaemonClientError on transport failure, parse failure, timeout, or
+       * server-side error.
+       */
+      async call(method, params) {
+        const id = randomUUID6();
+        const request = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+        return new Promise((resolve2, reject) => {
+          const socket = net.createConnection(this.socketPath);
+          let buffer = "";
+          let settled = false;
+          const finish = (err, value) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(callTimer);
+            clearTimeout(connectTimer);
+            socket.destroy();
+            if (err) reject(err);
+            else resolve2(value);
+          };
+          const callTimer = setTimeout(() => {
+            finish(new IpcDaemonClientError(`IPC call to ${method} timed out after ${this.timeoutMs}ms`));
+          }, this.timeoutMs);
+          const connectTimer = setTimeout(() => {
+            finish(new IpcDaemonClientError(`IPC connect timed out after ${this.connectTimeoutMs}ms`));
+          }, this.connectTimeoutMs);
+          socket.setEncoding("utf-8");
+          socket.on("connect", () => {
+            clearTimeout(connectTimer);
+            socket.write(request);
+          });
+          socket.on("data", (chunk) => {
+            buffer += chunk;
+            const newlineIdx = buffer.indexOf("\n");
+            if (newlineIdx === -1) return;
+            const line = buffer.slice(0, newlineIdx).trim();
+            if (!line) return;
+            try {
+              const response = JSON.parse(line);
+              if ("error" in response) {
+                finish(new IpcDaemonClientError(
+                  response.error.message,
+                  response.error.code,
+                  response.error.data
+                ));
+                return;
+              }
+              finish(null, response.result);
+            } catch (err) {
+              finish(new IpcDaemonClientError(`Malformed JSON-RPC response: ${err instanceof Error ? err.message : String(err)}`));
+            }
+          });
+          socket.on("error", (err) => {
+            const code = err.code === "ENOENT" || err.code === "ECONNREFUSED" ? `IPC daemon not listening at ${this.socketPath} (${err.code})` : `IPC socket error: ${err.message}`;
+            finish(new IpcDaemonClientError(code));
+          });
+          socket.on("end", () => {
+            if (!settled) finish(new IpcDaemonClientError("IPC server closed connection before responding"));
+          });
+        });
+      }
+      /**
+       * Quick reachability probe. Resolves with the latency in milliseconds when
+       * the daemon responds to `daemon.status`; rejects otherwise.
+       */
+      async ping() {
+        const start = Date.now();
+        const status = await this.call("daemon.status");
+        return { latencyMs: Date.now() - start, status };
+      }
+    };
+  }
+});
+
 // src/devices/resources.ts
 var COMMON_WEBHOOK_FIELDS, RESOURCE_CATALOG;
 var init_resources = __esm({
@@ -28411,6 +29509,128 @@ var init_capabilities = __esm({
   }
 });
 
+// src/daemon/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startIpcServer: () => startIpcServer
+});
+import net2 from "node:net";
+import fs26 from "node:fs";
+import path22 from "node:path";
+async function startIpcServer(opts) {
+  const socketPath = opts.socketPath ?? getDaemonSocketPath();
+  if (process.platform !== "win32") {
+    await ensureParentDir(socketPath);
+    await removeStaleSocket(socketPath);
+  }
+  const server = net2.createServer((socket) => {
+    let buffer = "";
+    socket.setEncoding("utf-8");
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      let newlineIdx = buffer.indexOf("\n");
+      while (newlineIdx !== -1) {
+        const line = buffer.slice(0, newlineIdx).trim();
+        buffer = buffer.slice(newlineIdx + 1);
+        newlineIdx = buffer.indexOf("\n");
+        if (!line) continue;
+        void handleLine(line, socket, opts);
+      }
+    });
+    socket.on("error", (err) => opts.onClientError?.(err));
+  });
+  await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(socketPath, () => {
+      server.removeListener("error", reject);
+      resolve2();
+    });
+  });
+  if (process.platform !== "win32") {
+    try {
+      fs26.chmodSync(socketPath, 384);
+    } catch {
+    }
+  }
+  return {
+    socketPath,
+    isListening: () => server.listening,
+    close: () => new Promise((resolve2) => {
+      server.close(() => {
+        if (process.platform !== "win32") {
+          try {
+            fs26.unlinkSync(socketPath);
+          } catch {
+          }
+        }
+        resolve2();
+      });
+    })
+  };
+}
+async function handleLine(line, socket, opts) {
+  let req;
+  let id = null;
+  try {
+    const parsed = JSON.parse(line);
+    req = parsed;
+    id = parsed.id ?? null;
+  } catch (err) {
+    send(socket, errorResponse(null, ERR_PARSE, "Parse error", String(err)));
+    return;
+  }
+  if (req.jsonrpc !== "2.0" || typeof req.method !== "string") {
+    send(socket, errorResponse(id, ERR_INVALID_REQUEST, 'Invalid Request: missing jsonrpc:"2.0" or method'));
+    return;
+  }
+  const handler = opts.handlers[req.method];
+  if (!handler) {
+    send(socket, errorResponse(id, ERR_METHOD_NOT_FOUND, `Method not found: ${req.method}`));
+    return;
+  }
+  try {
+    const result = await handler(req.params);
+    if (req.id !== void 0) {
+      send(socket, { jsonrpc: "2.0", id, result });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    send(socket, errorResponse(id, ERR_INTERNAL, message));
+  }
+}
+function send(socket, msg) {
+  if (!socket.writable) return;
+  socket.write(JSON.stringify(msg) + "\n");
+}
+function errorResponse(id, code, message, data) {
+  return { jsonrpc: "2.0", id, error: data === void 0 ? { code, message } : { code, message, data } };
+}
+async function ensureParentDir(socketPath) {
+  const parent = path22.dirname(socketPath);
+  await fs26.promises.mkdir(parent, { recursive: true });
+}
+async function removeStaleSocket(socketPath) {
+  try {
+    await fs26.promises.unlink(socketPath);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+}
+var ERR_PARSE, ERR_INVALID_REQUEST, ERR_METHOD_NOT_FOUND, ERR_INTERNAL;
+var init_server = __esm({
+  "src/daemon/server.ts"() {
+    "use strict";
+    init_cjs_shim();
+    init_socket_path();
+    ERR_PARSE = -32700;
+    ERR_INVALID_REQUEST = -32600;
+    ERR_METHOD_NOT_FOUND = -32601;
+    ERR_INTERNAL = -32603;
+  }
+});
+
 // src/index.ts
 init_cjs_shim();
 init_esm();
@@ -36466,10 +37686,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema2) {
   return mergeDefs(schema2._zod.def);
 }
-function getElementAtPath(obj, path29) {
-  if (!path29)
+function getElementAtPath(obj, path31) {
+  if (!path31)
     return obj;
-  return path29.reduce((acc, key) => acc?.[key], obj);
+  return path31.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -36852,11 +38072,11 @@ function aborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path29, issues) {
+function prefixIssues(path31, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path29);
+    iss.path.unshift(path31);
     return iss;
   });
 }
@@ -37039,7 +38259,7 @@ function formatError2(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path29 = []) => {
+  const processError = (error49, path31 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -37049,7 +38269,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path29, ...issue2.path];
+        const fullpath = [...path31, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -37081,8 +38301,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path29 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path29) {
+  const path31 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path31) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -49137,13 +50357,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path29 = ref.slice(1).split("/").filter(Boolean);
-  if (path29.length === 0) {
+  const path31 = ref.slice(1).split("/").filter(Boolean);
+  if (path31.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path29[0] === defsKey) {
-    const key = path29[1];
+  if (path31[0] === defsKey) {
+    const key = path31[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -49926,157 +51146,12 @@ function resolveToolProfile(name) {
   throw new Error(`Unknown tool profile "${name}". Valid profiles: ${valid}`);
 }
 
-// src/devices/history-query.ts
-init_cjs_shim();
-import fs10 from "node:fs";
-import path10 from "node:path";
-import os11 from "node:os";
-import readline2 from "node:readline";
-var DEFAULT_LIMIT = 1e3;
-function historyDir2() {
-  return path10.join(os11.homedir(), ".switchbot", "device-history");
-}
-function parseDurationToMs2(spec) {
-  const m2 = spec.trim().match(/^(\d+)(ms|s|m|h|d)$/i);
-  if (!m2) return null;
-  const n = Number(m2[1]);
-  const unit = m2[2].toLowerCase();
-  const factor = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
-  return n * factor;
-}
-function parseInstantToMs(spec) {
-  const ms = Date.parse(spec);
-  return Number.isFinite(ms) ? ms : null;
-}
-function resolveRange(opts) {
-  let fromMs = Number.NEGATIVE_INFINITY;
-  let toMs = Number.POSITIVE_INFINITY;
-  if (opts.since && (opts.from || opts.to)) {
-    throw new Error("--since is mutually exclusive with --from/--to.");
-  }
-  if (opts.since) {
-    const durMs = parseDurationToMs2(opts.since);
-    if (durMs === null) {
-      throw new Error(`Invalid --since value "${opts.since}". Expected e.g. "30s", "15m", "1h", "7d".`);
-    }
-    fromMs = Date.now() - durMs;
-  } else {
-    if (opts.from) {
-      const parsed = parseInstantToMs(opts.from);
-      if (parsed === null) throw new Error(`Invalid --from value "${opts.from}". Expected ISO-8601 timestamp.`);
-      fromMs = parsed;
-    }
-    if (opts.to) {
-      const parsed = parseInstantToMs(opts.to);
-      if (parsed === null) throw new Error(`Invalid --to value "${opts.to}". Expected ISO-8601 timestamp.`);
-      toMs = parsed;
-    }
-    if (fromMs > toMs) throw new Error("--from must be <= --to.");
-  }
-  return { fromMs, toMs };
-}
-function jsonlFilesForDevice(deviceId, baseDir = historyDir2()) {
-  const out = [];
-  if (!fs10.existsSync(baseDir)) return out;
-  for (let i = 3; i >= 1; i--) {
-    const p2 = path10.join(baseDir, `${deviceId}.jsonl.${i}`);
-    if (fs10.existsSync(p2)) out.push(p2);
-  }
-  const current = path10.join(baseDir, `${deviceId}.jsonl`);
-  if (fs10.existsSync(current)) out.push(current);
-  return out;
-}
-function projectFields(record2, fields) {
-  if (fields.length === 0) return record2;
-  const projected = {};
-  const payload = record2.payload ?? {};
-  for (const f2 of fields) {
-    if (f2 in payload) projected[f2] = payload[f2];
-  }
-  return { t: record2.t, topic: record2.topic, deviceType: record2.deviceType, payload: projected };
-}
-async function queryDeviceHistory(deviceId, opts = {}) {
-  const { fromMs, toMs } = resolveRange(opts);
-  const limit = Math.max(0, opts.limit ?? DEFAULT_LIMIT);
-  const fields = opts.fields ?? [];
-  const files = jsonlFilesForDevice(deviceId);
-  const out = [];
-  for (const file2 of files) {
-    try {
-      const stat = fs10.statSync(file2);
-      if (stat.mtimeMs < fromMs) continue;
-    } catch {
-      continue;
-    }
-    const stream = fs10.createReadStream(file2, { encoding: "utf-8" });
-    const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
-    for await (const line of rl) {
-      if (!line) continue;
-      let rec;
-      try {
-        rec = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      const tMs = Date.parse(rec.t);
-      if (!Number.isFinite(tMs)) continue;
-      if (tMs < fromMs || tMs > toMs) continue;
-      out.push(projectFields(rec, fields));
-      if (out.length >= limit) {
-        rl.close();
-        stream.destroy();
-        return out;
-      }
-    }
-  }
-  return out;
-}
-function queryDeviceHistoryStats(deviceId) {
-  const dir = historyDir2();
-  const files = jsonlFilesForDevice(deviceId);
-  let totalBytes = 0;
-  let oldest = null;
-  let newest = null;
-  let count = 0;
-  for (const file2 of files) {
-    try {
-      totalBytes += fs10.statSync(file2).size;
-    } catch {
-    }
-  }
-  for (const file2 of files) {
-    try {
-      const lines = fs10.readFileSync(file2, "utf-8").split("\n");
-      for (const line of lines) {
-        if (!line) continue;
-        count += 1;
-        try {
-          const rec = JSON.parse(line);
-          const tMs = Date.parse(rec.t);
-          if (Number.isFinite(tMs)) {
-            if (oldest === null || tMs < oldest) oldest = tMs;
-            if (newest === null || tMs > newest) newest = tMs;
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  return {
-    deviceId,
-    fileCount: files.length,
-    totalBytes,
-    recordCount: count,
-    oldest: oldest !== null ? new Date(oldest).toISOString() : void 0,
-    newest: newest !== null ? new Date(newest).toISOString() : void 0,
-    jsonlFiles: files.map((f2) => path10.basename(f2)),
-    historyDir: dir
-  };
-}
+// src/commands/mcp.ts
+init_history_query();
 
 // src/devices/history-agg.ts
 init_cjs_shim();
+init_history_query();
 import fs11 from "node:fs";
 import readline3 from "node:readline";
 var ALL_AGG_FNS = ["count", "min", "max", "avg", "sum", "p50", "p95"];
@@ -51200,7 +52275,7 @@ var import_yaml5 = __toESM(require_dist(), 1);
 var import_yaml6 = __toESM(require_dist(), 1);
 init_load();
 init_validate();
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 var AddRuleError = class extends Error {
   constructor(message, code) {
     super(message);
@@ -51316,7 +52391,7 @@ ${msgs}`,
 function addRuleToPolicyFile(opts) {
   const result = addRuleToPolicySource(opts);
   if (!opts.dryRun) {
-    fs15.writeFileSync(opts.policyPath, result.nextSource, "utf8");
+    fs16.writeFileSync(opts.policyPath, result.nextSource, "utf8");
     return { ...result, written: true };
   }
   return { ...result, written: false };
@@ -51325,15 +52400,15 @@ function addRuleToPolicyFile(opts) {
 // src/rules/explain.ts
 init_cjs_shim();
 init_trace();
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 function loadTraceRecords(auditFile, opts = {}) {
-  if (!fs16.existsSync(auditFile)) return [];
-  const lines = fs16.readFileSync(auditFile, "utf-8").split(/\r?\n/);
+  if (!fs17.existsSync(auditFile)) return [];
+  const lines = fs17.readFileSync(auditFile, "utf-8").split(/\r?\n/);
   return filterTraceRecords(lines, opts);
 }
 function loadRelatedAudit(auditFile, fireId) {
-  if (!fs16.existsSync(auditFile)) return [];
-  const raw = fs16.readFileSync(auditFile, "utf-8");
+  if (!fs17.existsSync(auditFile)) return [];
+  const raw = fs17.readFileSync(auditFile, "utf-8");
   const out = [];
   for (const line of raw.split(/\r?\n/)) {
     const trimmed = line.trim();
@@ -51417,17 +52492,18 @@ init_throttle();
 init_trace();
 init_trace();
 init_matcher();
-import fs17 from "node:fs";
+init_engine();
+import fs18 from "node:fs";
 import path14 from "node:path";
 import os13 from "node:os";
 import { randomUUID as randomUUID5 } from "node:crypto";
-var HOUR_MS = 60 * 60 * 1e3;
+var HOUR_MS2 = 60 * 60 * 1e3;
 var DEVICE_HISTORY_DIR = path14.join(os13.homedir(), ".switchbot", "device-history");
 async function simulateRule(opts) {
   const { rule, aliases = {}, liveLlm = false } = opts;
   const rv = ruleVersion(rule);
   const events = loadSourceEvents(opts);
-  const windowStart = events.length > 0 ? new Date(Math.min(...events.map((e) => e.t.getTime()))) : new Date(Date.now() - 24 * HOUR_MS);
+  const windowStart = events.length > 0 ? new Date(Math.min(...events.map((e) => e.t.getTime()))) : new Date(Date.now() - 24 * HOUR_MS2);
   const windowEnd = events.length > 0 ? new Date(Math.max(...events.map((e) => e.t.getTime()))) : /* @__PURE__ */ new Date();
   const counts = { wouldFire: 0, blocked: 0, throttled: 0, errored: 0, skippedLlm: 0 };
   const blockReasons = /* @__PURE__ */ new Map();
@@ -51477,7 +52553,8 @@ async function simulateRule(opts) {
         aliases,
         fetchStatus: statusFetcher,
         event,
-        ruleVersion: rv
+        ruleVersion: rv,
+        eventWindowFetcher: defaultEventWindowFetcher
       });
     } catch (err) {
       counts.errored++;
@@ -51526,8 +52603,8 @@ async function simulateRule(opts) {
 }
 function loadSourceEvents(opts) {
   if (opts.against) {
-    if (!fs17.existsSync(opts.against)) return [];
-    const lines2 = fs17.readFileSync(opts.against, "utf-8").split(/\r?\n/);
+    if (!fs18.existsSync(opts.against)) return [];
+    const lines2 = fs18.readFileSync(opts.against, "utf-8").split(/\r?\n/);
     const events = [];
     for (const line of lines2) {
       const trimmed = line.trim();
@@ -51547,10 +52624,10 @@ function loadSourceEvents(opts) {
     return events;
   }
   const auditLog = opts.auditLog;
-  if (!auditLog || !fs17.existsSync(auditLog)) return [];
-  const sinceMs = opts.since ? parseSince(opts.since) : Date.now() - 24 * HOUR_MS;
+  if (!auditLog || !fs18.existsSync(auditLog)) return [];
+  const sinceMs = opts.since ? parseSince(opts.since) : Date.now() - 24 * HOUR_MS2;
   const sinceIso = new Date(sinceMs).toISOString();
-  const lines = fs17.readFileSync(auditLog, "utf-8").split(/\r?\n/);
+  const lines = fs18.readFileSync(auditLog, "utf-8").split(/\r?\n/);
   const traceRecords = filterTraceRecords(lines, {
     ruleName: opts.rule.name,
     since: sinceIso
@@ -51574,13 +52651,13 @@ function parseSince(since) {
     const unitMs = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
     return Date.now() - n * unitMs;
   }
-  return Date.now() - 24 * HOUR_MS;
+  return Date.now() - 24 * HOUR_MS2;
 }
 function buildStatusFetcher(asOf) {
   return async (deviceId) => {
     const histFile = path14.join(DEVICE_HISTORY_DIR, `${deviceId}.jsonl`);
-    if (!fs17.existsSync(histFile)) return {};
-    const lines = fs17.readFileSync(histFile, "utf-8").split(/\r?\n/);
+    if (!fs18.existsSync(histFile)) return {};
+    const lines = fs18.readFileSync(histFile, "utf-8").split(/\r?\n/);
     const asOfMs = asOf.getTime();
     let best;
     for (const line of lines) {
@@ -51616,13 +52693,13 @@ function collectPolicyDiff(left, right, at, out, limit) {
     const maxLen = Math.max(left.length, right.length);
     for (let i = 0; i < maxLen; i++) {
       if (out.length >= limit) return;
-      const path29 = `${at}[${i}]`;
+      const path31 = `${at}[${i}]`;
       if (i >= left.length) {
-        out.push({ path: path29, kind: "added", after: right[i] });
+        out.push({ path: path31, kind: "added", after: right[i] });
       } else if (i >= right.length) {
-        out.push({ path: path29, kind: "removed", before: left[i] });
+        out.push({ path: path31, kind: "removed", before: left[i] });
       } else {
-        collectPolicyDiff(left[i], right[i], path29, out, limit);
+        collectPolicyDiff(left[i], right[i], path31, out, limit);
       }
     }
     return;
@@ -51631,15 +52708,15 @@ function collectPolicyDiff(left, right, at, out, limit) {
     const keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
     for (const key of [...keys].sort()) {
       if (out.length >= limit) return;
-      const path29 = at === "$" ? `$.${key}` : `${at}.${key}`;
+      const path31 = at === "$" ? `$.${key}` : `${at}.${key}`;
       const leftHas = Object.prototype.hasOwnProperty.call(left, key);
       const rightHas = Object.prototype.hasOwnProperty.call(right, key);
       if (!leftHas && rightHas) {
-        out.push({ path: path29, kind: "added", after: right[key] });
+        out.push({ path: path31, kind: "added", after: right[key] });
       } else if (leftHas && !rightHas) {
-        out.push({ path: path29, kind: "removed", before: left[key] });
+        out.push({ path: path31, kind: "removed", before: left[key] });
       } else {
-        collectPolicyDiff(left[key], right[key], path29, out, limit);
+        collectPolicyDiff(left[key], right[key], path31, out, limit);
       }
     }
     return;
@@ -51693,7 +52770,7 @@ function diffPolicyValues(leftDoc, rightDoc, leftSource, rightSource, maxChanges
 init_embedded_assets();
 import { dirname as pathDirname, join as pathJoin } from "node:path";
 import os14 from "node:os";
-import fs18 from "node:fs";
+import fs19 from "node:fs";
 var LATEST_SUPPORTED_VERSION = SUPPORTED_POLICY_SCHEMA_VERSIONS[SUPPORTED_POLICY_SCHEMA_VERSIONS.length - 1];
 function mcpError(kind, code, message, options) {
   const obj = { code, kind, message };
@@ -52669,15 +53746,15 @@ Tool profile: ${profileName} (${allowedTools.size} tools loaded).${profileName !
       async ({ path: pathArg, force }) => {
         const policyPath = resolvePolicyPath({ flag: pathArg });
         const doForce = force === true;
-        if (fs18.existsSync(policyPath) && !doForce) {
+        if (fs19.existsSync(policyPath) && !doForce) {
           return mcpError("guard", 5, `refusing to overwrite existing policy at ${policyPath}`, {
             hint: "pass force=true to overwrite, or choose a different path",
             context: { policyPath }
           });
         }
         const template = readPolicyExampleYaml();
-        fs18.mkdirSync(pathDirname(policyPath), { recursive: true });
-        fs18.writeFileSync(policyPath, template, { encoding: "utf-8" });
+        fs19.mkdirSync(pathDirname(policyPath), { recursive: true });
+        fs19.writeFileSync(policyPath, template, { encoding: "utf-8" });
         const structured = {
           policyPath,
           schemaVersion: CURRENT_POLICY_SCHEMA_VERSION,
@@ -52866,7 +53943,7 @@ Tool profile: ${profileName} (${allowedTools.size} tools loaded).${profileName !
         let leftSource = "";
         let rightSource = "";
         try {
-          leftSource = fs18.readFileSync(left_path, "utf-8");
+          leftSource = fs19.readFileSync(left_path, "utf-8");
         } catch (err) {
           if (err?.code === "ENOENT") {
             return mcpError("usage", 2, `policy file not found: ${left_path}`, {
@@ -52876,7 +53953,7 @@ Tool profile: ${profileName} (${allowedTools.size} tools loaded).${profileName !
           return mcpError("runtime", 1, `failed to read ${left_path}: ${String(err)}`);
         }
         try {
-          rightSource = fs18.readFileSync(right_path, "utf-8");
+          rightSource = fs19.readFileSync(right_path, "utf-8");
         } catch (err) {
           if (err?.code === "ENOENT") {
             return mcpError("usage", 2, `policy file not found: ${right_path}`, {
@@ -53751,7 +54828,7 @@ process_uptime_seconds ${Math.floor(process.uptime())}
           }
           if (profile) {
             const envCredsPresent = !!(process.env.SWITCHBOT_TOKEN && process.env.SWITCHBOT_SECRET);
-            if (!envCredsPresent && !fs18.existsSync(profileFilePath(profile))) {
+            if (!envCredsPresent && !fs19.existsSync(profileFilePath(profile))) {
               res.writeHead(401, { "Content-Type": "application/json" });
               res.end(JSON.stringify({
                 jsonrpc: "2.0",
@@ -54357,7 +55434,7 @@ init_cjs_shim();
 init_output();
 init_arg_parsers();
 init_flags();
-import http4 from "node:http";
+import http6 from "node:http";
 import crypto4 from "node:crypto";
 init_client2();
 init_credential();
@@ -54388,18 +55465,18 @@ var StdoutSink = class {
 
 // src/sinks/file.ts
 init_cjs_shim();
-import fs19 from "node:fs";
+import fs20 from "node:fs";
 import path15 from "node:path";
 var FileSink = class {
   filePath;
   constructor(filePath) {
     this.filePath = path15.resolve(filePath);
     const dir = path15.dirname(this.filePath);
-    if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+    if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
   }
   async write(event) {
     try {
-      fs19.appendFileSync(this.filePath, JSON.stringify(event) + "\n", { encoding: "utf-8" });
+      fs20.appendFileSync(this.filePath, JSON.stringify(event) + "\n", { encoding: "utf-8" });
     } catch {
     }
   }
@@ -54653,7 +55730,7 @@ function parseFilter2(flag) {
   }
 }
 function startReceiver(port, pathMatch, filter, onEvent) {
-  const server = http4.createServer((req, res) => {
+  const server = http6.createServer((req, res) => {
     if (req.method !== "POST") {
       res.statusCode = 405;
       res.end("method not allowed");
@@ -55068,10 +56145,10 @@ init_catalog();
 init_config();
 init_cache();
 init_quota();
-import fs22 from "node:fs";
-import os17 from "node:os";
-import path18 from "node:path";
-import { execSync } from "node:child_process";
+import fs24 from "node:fs";
+import os18 from "node:os";
+import path19 from "node:path";
+import { execSync as execSync2 } from "node:child_process";
 
 // src/commands/agent-bootstrap.ts
 init_cjs_shim();
@@ -55306,7 +56383,7 @@ init_request_context();
 
 // src/lib/daemon-state.ts
 init_cjs_shim();
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 import os15 from "node:os";
 import path16 from "node:path";
 function getStateDir() {
@@ -55329,15 +56406,15 @@ var DAEMON_LOG_FILE = getDaemonLogFile();
 var DAEMON_STATE_FILE = getDaemonStateFile();
 var HEALTHZ_PID_FILE = getHealthzPidFile();
 function ensureStateDir() {
-  fs20.mkdirSync(getStateDir(), { recursive: true, mode: 448 });
+  fs21.mkdirSync(getStateDir(), { recursive: true, mode: 448 });
 }
 function writeDaemonState(state) {
   ensureStateDir();
-  fs20.writeFileSync(getDaemonStateFile(), JSON.stringify(state, null, 2), { mode: 384 });
+  fs21.writeFileSync(getDaemonStateFile(), JSON.stringify(state, null, 2), { mode: 384 });
 }
 function readDaemonState() {
   try {
-    const raw = fs20.readFileSync(getDaemonStateFile(), "utf-8");
+    const raw = fs21.readFileSync(getDaemonStateFile(), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -55346,7 +56423,7 @@ function readDaemonState() {
 
 // src/rules/pid-file.ts
 init_cjs_shim();
-import fs21 from "node:fs";
+import fs22 from "node:fs";
 import os16 from "node:os";
 import path17 from "node:path";
 var DEFAULT_DIR = path17.join(os16.homedir(), ".switchbot");
@@ -55359,13 +56436,13 @@ function getDefaultPidFilePaths() {
 }
 function writePidFile(pidFile, pid = process.pid) {
   const dir = path17.dirname(pidFile);
-  fs21.mkdirSync(dir, { recursive: true, mode: 448 });
-  fs21.writeFileSync(pidFile, `${pid}
+  fs22.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs22.writeFileSync(pidFile, `${pid}
 `, { mode: 384 });
 }
 function readPidFile(pidFile) {
   try {
-    const raw = fs21.readFileSync(pidFile, "utf-8").trim();
+    const raw = fs22.readFileSync(pidFile, "utf-8").trim();
     const n = Number(raw);
     return Number.isInteger(n) && n > 0 ? n : null;
   } catch {
@@ -55375,20 +56452,20 @@ function readPidFile(pidFile) {
 function clearPidFile(pidFile, pid = process.pid) {
   try {
     const existing = readPidFile(pidFile);
-    if (existing === pid) fs21.unlinkSync(pidFile);
+    if (existing === pid) fs22.unlinkSync(pidFile);
   } catch {
   }
 }
 function writeReloadSentinel(reloadFile) {
   const dir = path17.dirname(reloadFile);
-  fs21.mkdirSync(dir, { recursive: true, mode: 448 });
-  fs21.writeFileSync(reloadFile, `${Date.now()}
+  fs22.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs22.writeFileSync(reloadFile, `${Date.now()}
 `, { mode: 384 });
 }
 function consumeReloadSentinel(reloadFile) {
   try {
-    if (!fs21.existsSync(reloadFile)) return false;
-    fs21.unlinkSync(reloadFile);
+    if (!fs22.existsSync(reloadFile)) return false;
+    fs22.unlinkSync(reloadFile);
     return true;
   } catch {
     return false;
@@ -55459,7 +56536,7 @@ async function checkCredentials() {
     };
   }
   const file2 = configFilePath();
-  if (!fs22.existsSync(file2)) {
+  if (!fs24.existsSync(file2)) {
     return {
       name: "credentials",
       status: "fail",
@@ -55474,7 +56551,7 @@ async function checkCredentials() {
     };
   }
   try {
-    const raw = fs22.readFileSync(file2, "utf-8");
+    const raw = fs24.readFileSync(file2, "utf-8");
     const cfg = JSON.parse(raw);
     if (!cfg.token || !cfg.secret) {
       return {
@@ -55521,8 +56598,8 @@ async function checkCredentials() {
   }
 }
 function checkProfiles() {
-  const dir = path18.join(os17.homedir(), ".switchbot", "profiles");
-  if (!fs22.existsSync(dir)) {
+  const dir = path19.join(os18.homedir(), ".switchbot", "profiles");
+  if (!fs24.existsSync(dir)) {
     return { name: "profiles", status: "ok", detail: "no profile dir (default profile only)" };
   }
   const profiles = listProfiles();
@@ -55648,8 +56725,8 @@ function checkCache() {
   }
 }
 function checkQuotaFile() {
-  const p2 = path18.join(os17.homedir(), ".switchbot", "quota.json");
-  if (!fs22.existsSync(p2)) {
+  const p2 = path19.join(os18.homedir(), ".switchbot", "quota.json");
+  if (!fs24.existsSync(p2)) {
     return {
       name: "quota",
       status: "ok",
@@ -55662,7 +56739,7 @@ function checkQuotaFile() {
     };
   }
   try {
-    const raw = fs22.readFileSync(p2, "utf-8");
+    const raw = fs24.readFileSync(p2, "utf-8");
     JSON.parse(raw);
   } catch {
     return {
@@ -55743,8 +56820,8 @@ function checkInventoryConsistency() {
   };
 }
 function checkAudit() {
-  const p2 = path18.join(os17.homedir(), ".switchbot", "audit.log");
-  if (!fs22.existsSync(p2)) {
+  const p2 = path19.join(os18.homedir(), ".switchbot", "audit.log");
+  if (!fs24.existsSync(p2)) {
     return {
       name: "audit",
       status: "ok",
@@ -55756,7 +56833,7 @@ function checkAudit() {
     };
   }
   try {
-    const raw = fs22.readFileSync(p2, "utf-8");
+    const raw = fs24.readFileSync(p2, "utf-8");
     const since = Date.now() - 24 * 60 * 60 * 1e3;
     const recent = [];
     let total = 0;
@@ -55955,14 +57032,14 @@ function checkPathDiscoverability() {
   const binaryName = isWindows ? "switchbot.cmd" : "switchbot";
   let npmBinDir = null;
   try {
-    const prefix = execSync("npm prefix -g", { timeout: 4e3, encoding: "utf-8" }).trim();
-    npmBinDir = isWindows ? prefix : path18.join(prefix, "bin");
+    const prefix = execSync2("npm prefix -g", { timeout: 4e3, encoding: "utf-8" }).trim();
+    npmBinDir = isWindows ? prefix : path19.join(prefix, "bin");
   } catch {
   }
   let binaryOnPath = false;
   let resolvedPath = null;
   try {
-    const which = execSync(
+    const which = execSync2(
       isWindows ? `where ${binaryName}` : `which ${binaryName}`,
       { timeout: 3e3, encoding: "utf-8" }
     ).trim().split(/\r?\n/)[0];
@@ -55986,7 +57063,7 @@ function checkPathDiscoverability() {
     };
   }
   const currentPath = process.env.PATH ?? "";
-  const missingSegment = npmBinDir && !currentPath.split(path18.delimiter).includes(npmBinDir) ? npmBinDir : null;
+  const missingSegment = npmBinDir && !currentPath.split(path19.delimiter).includes(npmBinDir) ? npmBinDir : null;
   const currentShell = detectShellFlavor();
   const shellFix = buildPathFix(currentShell, missingSegment, npmBinDir);
   return {
@@ -56087,9 +57164,9 @@ function checkMqtt() {
     };
   }
   const file2 = configFilePath();
-  if (fs22.existsSync(file2)) {
+  if (fs24.existsSync(file2)) {
     try {
-      const cfg = JSON.parse(fs22.readFileSync(file2, "utf-8"));
+      const cfg = JSON.parse(fs24.readFileSync(file2, "utf-8"));
       if (cfg.token && cfg.secret) {
         return {
           name: "mqtt",
@@ -56116,9 +57193,9 @@ async function checkMqttProbe() {
     creds = { token, secret };
   } else {
     const file2 = configFilePath();
-    if (fs22.existsSync(file2)) {
+    if (fs24.existsSync(file2)) {
       try {
-        const cfg = JSON.parse(fs22.readFileSync(file2, "utf-8"));
+        const cfg = JSON.parse(fs24.readFileSync(file2, "utf-8"));
         if (cfg.token && cfg.secret) {
           creds = { token: cfg.token, secret: cfg.secret };
         }
@@ -56232,6 +57309,112 @@ function checkNotifyConnectivity() {
     detail: { webhookCount: webhookUrls.length, message: `${webhookUrls.length} webhook URL(s) configured (live probe not run \u2014 use --probe to test connectivity)` }
   };
 }
+async function checkLocalLlmReachable() {
+  const policyPath = resolvePolicyPath();
+  let loaded;
+  try {
+    loaded = loadPolicyFile(policyPath);
+  } catch {
+    return { name: "local-llm-reachable", status: "ok", detail: { present: false, message: "no policy or policy unreadable \u2014 check skipped" } };
+  }
+  const policy = loaded.data;
+  const automation = policy?.automation;
+  const ruleArr = Array.isArray(automation?.rules) ? automation.rules : [];
+  const usesLocal = ruleArr.some((rule) => {
+    const conds = Array.isArray(rule.conditions) ? rule.conditions : [];
+    return conds.some((c) => {
+      const llm = c.llm;
+      return llm && llm.provider === "local";
+    });
+  });
+  if (!usesLocal) {
+    return { name: "local-llm-reachable", status: "ok", detail: { applicable: false, message: "no policy reference to provider:local \u2014 check skipped" } };
+  }
+  const baseUrl = (process.env.SWITCHBOT_LOCAL_LLM_URL ?? "http://localhost:11434/v1").replace(/\/v1\/?$/, "").replace(/\/+$/, "");
+  const start = Date.now();
+  try {
+    const reachable = await probeLocalLlmEndpoint(baseUrl);
+    const latencyMs = Date.now() - start;
+    if (!reachable) {
+      return {
+        name: "local-llm-reachable",
+        status: "fail",
+        detail: { baseUrl, latencyMs, message: "endpoint did not respond \u2014 start your local LLM server (e.g. `ollama serve`)" }
+      };
+    }
+    return { name: "local-llm-reachable", status: "ok", detail: { baseUrl, latencyMs } };
+  } catch (err) {
+    return {
+      name: "local-llm-reachable",
+      status: "fail",
+      detail: { baseUrl, message: err instanceof Error ? err.message : String(err) }
+    };
+  }
+}
+async function probeLocalLlmEndpoint(baseUrl) {
+  const httpMod = await import("node:http");
+  const httpsMod = await import("node:https");
+  return new Promise((resolve2) => {
+    let url2;
+    try {
+      url2 = new URL(baseUrl);
+    } catch {
+      resolve2(false);
+      return;
+    }
+    const isHttps = url2.protocol === "https:";
+    const lib = isHttps ? httpsMod.default : httpMod.default;
+    const req = lib.request(
+      {
+        hostname: url2.hostname,
+        port: url2.port || (isHttps ? 443 : 80),
+        path: url2.pathname || "/",
+        method: "GET",
+        timeout: 3e3
+      },
+      (res) => {
+        res.on("data", () => {
+        });
+        res.on("end", () => resolve2(true));
+        res.resume();
+      }
+    );
+    req.on("error", () => resolve2(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve2(false);
+    });
+    req.end();
+  });
+}
+async function checkDaemonIpc() {
+  const daemonPid = readPidFile(DAEMON_PID_FILE);
+  if (!daemonPid || !isPidAlive(daemonPid)) {
+    return { name: "daemon-ipc", status: "ok", detail: { applicable: false, message: "daemon not running \u2014 check skipped" } };
+  }
+  try {
+    const { IpcDaemonClient: IpcDaemonClient2 } = await Promise.resolve().then(() => (init_client3(), client_exports2));
+    const client = new IpcDaemonClient2({ timeoutMs: 1500, connectTimeoutMs: 500 });
+    const start = Date.now();
+    const result = await client.ping();
+    const latencyMs = Date.now() - start;
+    return {
+      name: "daemon-ipc",
+      status: "ok",
+      detail: {
+        socketPath: client.getSocketPath(),
+        latencyMs,
+        ipcStatus: result.status
+      }
+    };
+  } catch (err) {
+    return {
+      name: "daemon-ipc",
+      status: "fail",
+      detail: { message: err instanceof Error ? err.message : String(err) }
+    };
+  }
+}
 var CHECK_REGISTRY = [
   { name: "node", description: "Node.js version compatibility", run: () => checkNodeVersion() },
   { name: "path", description: "switchbot binary reachable on PATH", run: () => checkPathDiscoverability() },
@@ -56256,7 +57439,9 @@ var CHECK_REGISTRY = [
   { name: "audit", description: "recent command errors (last 24h)", run: () => checkAudit() },
   { name: "daemon", description: "daemon state file + runtime status", run: () => checkDaemon() },
   { name: "health", description: "health endpoint availability (daemon --healthz-port)", run: () => checkHealthEndpoint() },
-  { name: "notify-connectivity", description: "webhook URLs from notify actions in policy.yaml", run: () => checkNotifyConnectivity() }
+  { name: "notify-connectivity", description: "webhook URLs from notify actions in policy.yaml", run: () => checkNotifyConnectivity() },
+  { name: "local-llm-reachable", description: "local LLM endpoint reachable (only when policy uses provider:local)", run: () => checkLocalLlmReachable() },
+  { name: "daemon-ipc", description: "daemon JSON-RPC IPC socket reachable (only when daemon is running)", run: () => checkDaemonIpc() }
 ];
 function applyFixes(checks, writeOk) {
   const results = [];
@@ -56594,9 +57779,10 @@ init_arg_parsers();
 init_output();
 init_audit();
 init_devices();
-import path19 from "node:path";
-import os18 from "node:os";
-var DEFAULT_AUDIT = path19.join(os18.homedir(), ".switchbot", "audit.log");
+init_history_query();
+import path20 from "node:path";
+import os19 from "node:os";
+var DEFAULT_AUDIT = path20.join(os19.homedir(), ".switchbot", "audit.log");
 function registerHistoryCommand(program3) {
   const history = program3.command("history").description("View and replay SwitchBot commands recorded via --audit-log").addHelpText("after", `
 Every 'devices command' run with --audit-log is appended as JSONL to the
@@ -57454,9 +58640,9 @@ init_load();
 init_validate();
 init_types();
 init_engine();
-import fs24 from "node:fs";
-import os20 from "node:os";
-import path21 from "node:path";
+import fs27 from "node:fs";
+import os21 from "node:os";
+import path23 from "node:path";
 
 // src/rules/conflict-analyzer.ts
 init_cjs_shim();
@@ -57619,9 +58805,9 @@ init_client2();
 
 // src/rules/webhook-token.ts
 init_cjs_shim();
-import fs23 from "node:fs";
-import os19 from "node:os";
-import path20 from "node:path";
+import fs25 from "node:fs";
+import os20 from "node:os";
+import path21 from "node:path";
 import { randomBytes } from "node:crypto";
 var ENV_TOKEN = "SWITCHBOT_WEBHOOK_TOKEN";
 var DEFAULT_FILE = ".switchbot/webhook-token";
@@ -57629,7 +58815,7 @@ var WebhookTokenStore = class {
   filePath;
   envLookup;
   constructor(opts = {}) {
-    this.filePath = opts.filePath ?? path20.join(os19.homedir(), DEFAULT_FILE);
+    this.filePath = opts.filePath ?? path21.join(os20.homedir(), DEFAULT_FILE);
     this.envLookup = opts.envLookup ?? (() => process.env[ENV_TOKEN]);
   }
   /**
@@ -57653,7 +58839,7 @@ var WebhookTokenStore = class {
    */
   readFromDisk() {
     try {
-      const raw = fs23.readFileSync(this.filePath, "utf-8").trim();
+      const raw = fs25.readFileSync(this.filePath, "utf-8").trim();
       return raw.length > 0 ? raw : null;
     } catch (err) {
       if (err.code === "ENOENT") return null;
@@ -57670,12 +58856,12 @@ var WebhookTokenStore = class {
     return this.filePath;
   }
   writeToDisk(token) {
-    const dir = path20.dirname(this.filePath);
-    fs23.mkdirSync(dir, { recursive: true });
-    fs23.writeFileSync(this.filePath, `${token}
+    const dir = path21.dirname(this.filePath);
+    fs25.mkdirSync(dir, { recursive: true });
+    fs25.writeFileSync(this.filePath, `${token}
 `, { mode: 384 });
     try {
-      fs23.chmodSync(this.filePath, 384);
+      fs25.chmodSync(this.filePath, 384);
     } catch {
     }
   }
@@ -57760,18 +58946,19 @@ function aggregateRuleAudits(entries) {
 }
 
 // src/commands/rules.ts
-var DEFAULT_AUDIT_PATH2 = path21.join(os20.homedir(), ".switchbot", "audit.log");
+init_history_query();
+var DEFAULT_AUDIT_PATH2 = path23.join(os21.homedir(), ".switchbot", "audit.log");
 function loadAutomation(policyPathFlag) {
-  const path29 = resolvePolicyPath({ flag: policyPathFlag });
+  const path31 = resolvePolicyPath({ flag: policyPathFlag });
   let loaded;
   try {
-    loaded = loadPolicyFile(path29);
+    loaded = loadPolicyFile(path31);
   } catch (err) {
     if (err instanceof PolicyFileNotFoundError) {
       exitWithError({
         code: 2,
         kind: "usage",
-        message: `policy file not found: ${path29}`,
+        message: `policy file not found: ${path31}`,
         extra: { subKind: "file-not-found" }
       });
     }
@@ -57779,7 +58966,7 @@ function loadAutomation(policyPathFlag) {
       exitWithError({
         code: 3,
         kind: "runtime",
-        message: `YAML parse error in ${path29}: ${err.message}`,
+        message: `YAML parse error in ${path31}: ${err.message}`,
         extra: { subKind: "yaml-parse", errors: err.yamlErrors }
       });
     }
@@ -57791,7 +58978,7 @@ function loadAutomation(policyPathFlag) {
       code: 4,
       kind: "runtime",
       message: "policy file failed schema validation. Run `switchbot policy validate` for details.",
-      extra: { subKind: "invalid-policy", path: path29 }
+      extra: { subKind: "invalid-policy", path: path31 }
     });
   }
   const data = loaded.data ?? {};
@@ -57805,7 +58992,7 @@ function loadAutomation(policyPathFlag) {
   }
   const rawQH = data.quiet_hours;
   const quietHours = rawQH && typeof rawQH.start === "string" && typeof rawQH.end === "string" ? { start: rawQH.start, end: rawQH.end } : null;
-  return { path: path29, automation, aliases, schemaVersion: result.schemaVersion, quietHours };
+  return { path: path31, automation, aliases, schemaVersion: result.schemaVersion, quietHours };
 }
 function describeTrigger(rule) {
   const t = rule.when;
@@ -57940,6 +59127,8 @@ function registerRun(rules) {
     let stopping = false;
     const pidPaths = getDefaultPidFilePaths();
     writePidFile(pidPaths.pidFile);
+    const ipcStartedAt = /* @__PURE__ */ new Date();
+    let ipcServerHandle = null;
     const cleanup = () => {
       clearPidFile(pidPaths.pidFile);
       consumeReloadSentinel(pidPaths.reloadFile);
@@ -57948,6 +59137,12 @@ function registerRun(rules) {
       if (stopping) return;
       stopping = true;
       try {
+        if (ipcServerHandle) {
+          try {
+            await ipcServerHandle.close();
+          } catch {
+          }
+        }
         await engine.stop();
         await client.disconnect();
       } finally {
@@ -58006,6 +59201,34 @@ function registerRun(rules) {
       }
     }, 2e3);
     reloadPoll.unref();
+    try {
+      const { startIpcServer: startIpcServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+      ipcServerHandle = await startIpcServer2({
+        handlers: {
+          "daemon.status": () => ({
+            status: "running",
+            pid: process.pid,
+            startedAt: ipcStartedAt.toISOString(),
+            rulesActive: engine.getStats().rulesActive,
+            globalDryRun: opts.dryRun === true
+          }),
+          "daemon.ping": () => ({ ok: true, t: (/* @__PURE__ */ new Date()).toISOString() }),
+          "daemon.reload": async () => {
+            await doReload("ipc");
+            return { ok: true, rulesActive: engine.getStats().rulesActive };
+          }
+        },
+        onClientError: () => {
+        }
+      });
+      if (!isJsonMode()) {
+        console.error(`IPC: listening on ${ipcServerHandle.socketPath}`);
+      }
+    } catch (err) {
+      if (!isJsonMode()) {
+        console.error(`IPC: failed to start (${err instanceof Error ? err.message : String(err)}) \u2014 daemon will run without IPC`);
+      }
+    }
     if (!isJsonMode()) {
       console.error(
         `Rules engine started \u2014 ${engine.getStats().rulesActive} active rule(s), ${opts.dryRun ? "global dry-run" : "live"}.`
@@ -58068,7 +59291,7 @@ function registerTail(rules) {
   rules.command("tail").description("Stream rule-* entries from the audit log.").option("--file <path>", `Audit log path (default ${DEFAULT_AUDIT_PATH2})`).option("--since <duration>", "Only entries newer than this window (e.g. 1h, 30m, 7d).").option("--rule <name>", "Filter to a single rule name.").option("-f, --follow", "Keep the process open and stream new lines as they arrive.").action(async (opts) => {
     const file2 = opts.file ?? DEFAULT_AUDIT_PATH2;
     const sinceMs = resolveSinceMs(opts.since);
-    const existing = fs24.existsSync(file2) ? readAudit(file2) : [];
+    const existing = fs27.existsSync(file2) ? readAudit(file2) : [];
     const filtered = filterRuleAudits(existing, { sinceMs, ruleName: opts.rule });
     if (isJsonMode()) {
       for (const e of filtered) console.log(JSON.stringify(e));
@@ -58080,7 +59303,7 @@ function registerTail(rules) {
       for (const e of filtered) console.log(formatAuditLine(e));
     }
     if (!opts.follow) return;
-    let offset = fs24.existsSync(file2) ? fs24.statSync(file2).size : 0;
+    let offset = fs27.existsSync(file2) ? fs27.statSync(file2).size : 0;
     let buffer = "";
     const emit = (line) => {
       const trimmed = line.trim();
@@ -58097,21 +59320,21 @@ function registerTail(rules) {
       else console.log(formatAuditLine(entry));
     };
     const poll = setInterval(() => {
-      if (!fs24.existsSync(file2)) return;
-      const size = fs24.statSync(file2).size;
+      if (!fs27.existsSync(file2)) return;
+      const size = fs27.statSync(file2).size;
       if (size < offset) {
         offset = 0;
         buffer = "";
       }
       if (size === offset) return;
-      const fd = fs24.openSync(file2, "r");
+      const fd = fs27.openSync(file2, "r");
       try {
         const chunk = Buffer.alloc(size - offset);
-        fs24.readSync(fd, chunk, 0, chunk.length, offset);
+        fs27.readSync(fd, chunk, 0, chunk.length, offset);
         offset = size;
         buffer += chunk.toString("utf-8");
       } finally {
-        fs24.closeSync(fd);
+        fs27.closeSync(fd);
       }
       let newline = buffer.indexOf("\n");
       while (newline !== -1) {
@@ -58151,7 +59374,7 @@ function formatReplayTable(report) {
 function registerReplay(rules) {
   rules.command("replay").description("Aggregate rule-* audit entries per rule (fire/throttle/error counts).").option("--file <path>", `Audit log path (default ${DEFAULT_AUDIT_PATH2})`).option("--since <duration>", "Only entries newer than this window (e.g. 1h, 7d).").option("--rule <name>", "Filter to a single rule name.").action((opts) => {
     const file2 = opts.file ?? DEFAULT_AUDIT_PATH2;
-    const entries = fs24.existsSync(file2) ? readAudit(file2) : [];
+    const entries = fs27.existsSync(file2) ? readAudit(file2) : [];
     const sinceMs = resolveSinceMs(opts.since);
     const filtered = filterRuleAudits(entries, {
       sinceMs,
@@ -58271,7 +59494,7 @@ function registerSuggest(rules) {
         for (const w2 of warnings) process.stderr.write(`warning: ${w2}
 `);
         if (opts.out) {
-          fs24.writeFileSync(opts.out, ruleYaml, "utf8");
+          fs27.writeFileSync(opts.out, ruleYaml, "utf8");
           if (!isJsonMode()) console.log(`\u2713 rule YAML written to ${opts.out}`);
         } else if (isJsonMode()) {
           printJson({ rule, rule_yaml: ruleYaml, warnings });
@@ -58346,7 +59569,7 @@ overall: ${overall ? "ok" : "issues found"}`);
 function registerSummary(rules) {
   rules.command("summary").description("Aggregate rule-* audit entries per rule over a time window (fires, throttled, errors).").option("--file <path>", `Audit log path (default ${DEFAULT_AUDIT_PATH2})`).option("--since <duration>", "Only entries newer than this window (default: 24h). E.g. 1h, 7d.").option("--rule <name>", "Filter to a single rule name.").action((opts) => {
     const file2 = opts.file ?? DEFAULT_AUDIT_PATH2;
-    const entries = fs24.existsSync(file2) ? readAudit(file2) : [];
+    const entries = fs27.existsSync(file2) ? readAudit(file2) : [];
     const sinceMs = resolveSinceMs(opts.since ?? "24h");
     const filtered = filterRuleAudits(entries, { sinceMs, ruleName: opts.rule });
     const report = aggregateRuleAudits(filtered);
@@ -58377,7 +59600,7 @@ function registerLastFired(rules) {
   rules.command("last-fired").description("Show the N most recently fired rule-fire entries from the audit log.").option("--file <path>", `Audit log path (default ${DEFAULT_AUDIT_PATH2})`).option("--rule <name>", "Filter to a single rule name.").option("-n <count>", "Number of entries to show (default: 10).", (v2) => Number.parseInt(v2, 10)).action((opts) => {
     const file2 = opts.file ?? DEFAULT_AUDIT_PATH2;
     const n = opts.n ?? 10;
-    const entries = fs24.existsSync(file2) ? readAudit(file2) : [];
+    const entries = fs27.existsSync(file2) ? readAudit(file2) : [];
     const fires = filterRuleAudits(entries, {
       ruleName: opts.rule,
       kinds: ["rule-fire", "rule-fire-dry"]
@@ -58419,7 +59642,7 @@ function registerExplain(rules) {
       return;
     }
     const auditFile = opts.file ?? DEFAULT_AUDIT_PATH2;
-    const entries = fs24.existsSync(auditFile) ? readAudit(auditFile) : [];
+    const entries = fs27.existsSync(auditFile) ? readAudit(auditFile) : [];
     const fires = filterRuleAudits(entries, { ruleName: name, kinds: ["rule-fire", "rule-fire-dry"] });
     const lastFired = fires.length > 0 ? fires[fires.length - 1].t : null;
     const detail = {
@@ -58460,7 +59683,7 @@ function registerTraceExplain(rules) {
   rules.command("trace-explain [fireId]").description("Show why a rule evaluation fired or was blocked (reads rule-evaluate trace records).").option("--rule <name>", "Filter to a specific rule name.").option("--last", "Show the most recent evaluation for the rule (requires --rule).").option("--since <duration>", "Show evaluations in this window (e.g. 1h, 7d).").option("--all", "Include evaluations that fired (default: show all evaluations).").option("--file <path>", `Audit log path (default ${DEFAULT_AUDIT_PATH2}).`).action(
     (fireIdArg, opts) => {
       const auditFile = opts.file ?? DEFAULT_AUDIT_PATH2;
-      if (!fs24.existsSync(auditFile)) {
+      if (!fs27.existsSync(auditFile)) {
         exitWithError({ code: 1, kind: "usage", message: `Audit log not found: ${auditFile}. Make sure trace recording is enabled (automation.audit.evaluate_trace: sampled or full).` });
         return;
       }
@@ -58495,14 +59718,14 @@ function registerSimulate(rules) {
     async (ruleOrPolicy, opts) => {
       let rule;
       const auditLog = opts.auditLog ?? DEFAULT_AUDIT_PATH2;
-      if (!fs24.existsSync(ruleOrPolicy)) {
+      if (!fs27.existsSync(ruleOrPolicy)) {
         exitWithError({ code: 2, kind: "usage", message: `File not found: ${ruleOrPolicy}` });
         return;
       }
       let parsed;
       try {
         const { parse: yamlParse5 } = await Promise.resolve().then(() => __toESM(require_dist(), 1));
-        parsed = yamlParse5(fs24.readFileSync(ruleOrPolicy, "utf-8"));
+        parsed = yamlParse5(fs27.readFileSync(ruleOrPolicy, "utf-8"));
       } catch {
         exitWithError({ code: 2, kind: "usage", message: `Could not parse YAML file: ${ruleOrPolicy}` });
         return;
@@ -58533,7 +59756,7 @@ function registerSimulate(rules) {
           liveLlm: opts.liveLlm ?? false
         });
         if (opts.reportOut) {
-          fs24.writeFileSync(opts.reportOut, JSON.stringify(report, null, 2));
+          fs27.writeFileSync(opts.reportOut, JSON.stringify(report, null, 2));
           console.log(`Report written to ${opts.reportOut}`);
         }
         if (isJsonMode()) {
@@ -58624,10 +59847,10 @@ init_output();
 init_arg_parsers();
 init_request_context();
 init_keychain();
-import fs25 from "node:fs";
-import path22 from "node:path";
-import os21 from "node:os";
-import readline5 from "node:readline";
+import fs28 from "node:fs";
+import path24 from "node:path";
+import os22 from "node:os";
+import readline6 from "node:readline";
 function activeProfile() {
   return getActiveProfile() ?? "default";
 }
@@ -58639,7 +59862,7 @@ function maskValue2(value) {
   return `${head}${"*".repeat(Math.max(4, value.length - 4))}${tail}`;
 }
 async function promptSecret2(question) {
-  const rl = readline5.createInterface({ input: process.stdin, output: process.stderr, terminal: true });
+  const rl = readline6.createInterface({ input: process.stdin, output: process.stderr, terminal: true });
   return new Promise((resolve2) => {
     process.stderr.write(question);
     const stdin = process.stdin;
@@ -58672,7 +59895,7 @@ async function promptSecret2(question) {
   });
 }
 function readStdinFile(filePath) {
-  if (!fs25.existsSync(filePath)) {
+  if (!fs28.existsSync(filePath)) {
     exitWithError({
       code: 2,
       kind: "usage",
@@ -58681,7 +59904,7 @@ function readStdinFile(filePath) {
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs25.readFileSync(filePath, "utf-8"));
+    parsed = JSON.parse(fs28.readFileSync(filePath, "utf-8"));
   } catch (err) {
     exitWithError({
       code: 2,
@@ -58711,10 +59934,10 @@ function cleanupMigratedSourceFile(sourceFile, parsed) {
   delete next.token;
   delete next.secret;
   if (Object.keys(next).length === 0) {
-    fs25.unlinkSync(sourceFile);
+    fs28.unlinkSync(sourceFile);
     return "deleted";
   }
-  fs25.writeFileSync(sourceFile, JSON.stringify(next, null, 2), { mode: 384 });
+  fs28.writeFileSync(sourceFile, JSON.stringify(next, null, 2), { mode: 384 });
   return "scrubbed";
 }
 function registerAuthCommand(program3) {
@@ -58845,8 +60068,8 @@ function registerAuthCommand(program3) {
         message: `backend "${store.name}" is not writable on this machine`
       });
     }
-    const sourceFile = profile === "default" ? path22.join(os21.homedir(), ".switchbot", "config.json") : path22.join(os21.homedir(), ".switchbot", "profiles", `${profile}.json`);
-    if (!fs25.existsSync(sourceFile)) {
+    const sourceFile = profile === "default" ? path24.join(os22.homedir(), ".switchbot", "config.json") : path24.join(os22.homedir(), ".switchbot", "profiles", `${profile}.json`);
+    if (!fs28.existsSync(sourceFile)) {
       exitWithError({
         code: 2,
         kind: "usage",
@@ -58856,7 +60079,7 @@ function registerAuthCommand(program3) {
     }
     let parsed;
     try {
-      const raw = JSON.parse(fs25.readFileSync(sourceFile, "utf-8"));
+      const raw = JSON.parse(fs28.readFileSync(sourceFile, "utf-8"));
       if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
         throw new Error("expected a JSON object");
       }
@@ -58918,8 +60141,8 @@ function registerAuthCommand(program3) {
 init_cjs_shim();
 init_esm();
 init_load();
-import fs28 from "node:fs";
-import path25 from "node:path";
+import fs31 from "node:fs";
+import path27 from "node:path";
 
 // src/install/steps.ts
 init_cjs_shim();
@@ -58971,9 +60194,9 @@ init_cjs_shim();
 init_load();
 init_validate();
 init_keychain();
-import fs26 from "node:fs";
-import path23 from "node:path";
-import os22 from "node:os";
+import fs29 from "node:fs";
+import path25 from "node:path";
+import os23 from "node:os";
 function parseMajor(version2) {
   const m2 = /^v?(\d+)\./.exec(version2);
   if (!m2) return null;
@@ -59063,10 +60286,10 @@ async function checkKeychain2() {
   }
 }
 function checkHomeDirWritable() {
-  const home = os22.homedir();
-  const switchbotDir = path23.join(home, ".switchbot");
+  const home = os23.homedir();
+  const switchbotDir = path25.join(home, ".switchbot");
   try {
-    const homeStat = fs26.statSync(home);
+    const homeStat = fs29.statSync(home);
     if (!homeStat.isDirectory()) {
       return {
         name: "home",
@@ -59075,8 +60298,8 @@ function checkHomeDirWritable() {
         hint: "check your HOME/USERPROFILE environment configuration"
       };
     }
-    if (fs26.existsSync(switchbotDir)) {
-      const sbStat = fs26.statSync(switchbotDir);
+    if (fs29.existsSync(switchbotDir)) {
+      const sbStat = fs29.statSync(switchbotDir);
       if (!sbStat.isDirectory()) {
         return {
           name: "home",
@@ -59085,10 +60308,10 @@ function checkHomeDirWritable() {
           hint: "move the file aside and re-run install"
         };
       }
-      fs26.accessSync(switchbotDir, fs26.constants.W_OK);
+      fs29.accessSync(switchbotDir, fs29.constants.W_OK);
       return { name: "home", status: "ok", message: `writable: ${switchbotDir}` };
     }
-    fs26.accessSync(home, fs26.constants.W_OK);
+    fs29.accessSync(home, fs29.constants.W_OK);
     return { name: "home", status: "ok", message: `writable: ${home}` };
   } catch (err) {
     return {
@@ -59102,8 +60325,8 @@ function checkHomeDirWritable() {
 function nearestExistingPath(target) {
   let cur = target;
   while (true) {
-    if (fs26.existsSync(cur)) return cur;
-    const parent = path23.dirname(cur);
+    if (fs29.existsSync(cur)) return cur;
+    const parent = path25.dirname(cur);
     if (parent === cur) return null;
     cur = parent;
   }
@@ -59111,8 +60334,8 @@ function nearestExistingPath(target) {
 function checkAgentSkillDirWritable(opts) {
   const shouldCheck = opts.agent === "claude-code" && (opts.expectSkillLink ?? true);
   if (!shouldCheck) return null;
-  const home = os22.homedir();
-  const target = path23.join(home, ".claude", "skills");
+  const home = os23.homedir();
+  const target = path25.join(home, ".claude", "skills");
   try {
     const existing = nearestExistingPath(target);
     if (!existing) {
@@ -59123,7 +60346,7 @@ function checkAgentSkillDirWritable(opts) {
         hint: "check your home directory path and permissions"
       };
     }
-    const stat = fs26.statSync(existing);
+    const stat = fs29.statSync(existing);
     if (!stat.isDirectory()) {
       return {
         name: "agent-skills-dir",
@@ -59132,7 +60355,7 @@ function checkAgentSkillDirWritable(opts) {
         hint: "move the blocking file aside and re-run install"
       };
     }
-    fs26.accessSync(existing, fs26.constants.W_OK);
+    fs29.accessSync(existing, fs29.constants.W_OK);
     return { name: "agent-skills-dir", status: "ok", message: `writable: ${target}` };
   } catch (err) {
     return {
@@ -59157,9 +60380,9 @@ async function runPreflight(options = {}) {
 
 // src/install/default-steps.ts
 init_cjs_shim();
-import fs27 from "node:fs";
-import path24 from "node:path";
-import os23 from "node:os";
+import fs30 from "node:fs";
+import path26 from "node:path";
+import os24 from "node:os";
 import { spawnSync } from "node:child_process";
 init_keychain();
 function stepPromptCredentials() {
@@ -59234,15 +60457,15 @@ function stepScaffoldPolicy() {
       const r = ctx.policyScaffoldResult;
       if (!r || r.skipped) return;
       try {
-        fs27.unlinkSync(r.policyPath);
+        fs30.unlinkSync(r.policyPath);
       } catch {
       }
     }
   };
 }
-function skillLinkPathFor(agent, home = os23.homedir()) {
+function skillLinkPathFor(agent, home = os24.homedir()) {
   if (agent === "claude-code") {
-    return path24.join(home, ".claude", "skills", "switchbot");
+    return path26.join(home, ".claude", "skills", "switchbot");
   }
   return null;
 }
@@ -59256,11 +60479,11 @@ function stepSymlinkSkill(opts = {}) {
         ctx.skillRecipePrinted = true;
         return;
       }
-      const target = path24.resolve(ctx.skillPath);
-      if (!fs27.existsSync(target)) {
+      const target = path26.resolve(ctx.skillPath);
+      if (!fs30.existsSync(target)) {
         throw new Error(`--skill-path does not exist: ${target}`);
       }
-      const stat = fs27.statSync(target);
+      const stat = fs30.statSync(target);
       if (!stat.isDirectory()) {
         throw new Error(`--skill-path is not a directory: ${target}`);
       }
@@ -59269,17 +60492,17 @@ function stepSymlinkSkill(opts = {}) {
         ctx.skillRecipePrinted = true;
         return;
       }
-      if (!opts.force && !fs27.existsSync(path24.join(target, "SKILL.md"))) {
+      if (!opts.force && !fs30.existsSync(path26.join(target, "SKILL.md"))) {
         throw new Error(
           `${target} does not look like a skill (no SKILL.md at the root). Pass --force if you really mean to link this directory.`
         );
       }
-      if (fs27.existsSync(linkPath)) {
-        const st = fs27.lstatSync(linkPath);
+      if (fs30.existsSync(linkPath)) {
+        const st = fs30.lstatSync(linkPath);
         if (st.isSymbolicLink()) {
           let existingTarget = null;
           try {
-            existingTarget = path24.resolve(path24.dirname(linkPath), fs27.readlinkSync(linkPath));
+            existingTarget = path26.resolve(path26.dirname(linkPath), fs30.readlinkSync(linkPath));
           } catch {
             existingTarget = null;
           }
@@ -59293,23 +60516,23 @@ function stepSymlinkSkill(opts = {}) {
               `${linkPath} already links to ${existingTarget ?? "(unreadable)"}; pass --force to replace it, or run \`switchbot uninstall\` first.`
             );
           }
-          fs27.unlinkSync(linkPath);
+          fs30.unlinkSync(linkPath);
         } else {
           throw new Error(
             `${linkPath} exists and is not a symlink; refusing to clobber (move it aside and re-run)`
           );
         }
       }
-      fs27.mkdirSync(path24.dirname(linkPath), { recursive: true });
+      fs30.mkdirSync(path26.dirname(linkPath), { recursive: true });
       const linkType = process.platform === "win32" ? "junction" : "dir";
-      fs27.symlinkSync(target, linkPath, linkType);
+      fs30.symlinkSync(target, linkPath, linkType);
       ctx.skillLinkPath = linkPath;
       ctx.skillLinkCreated = true;
     },
     undo(ctx) {
       if (!ctx.skillLinkCreated || !ctx.skillLinkPath) return;
       try {
-        fs27.unlinkSync(ctx.skillLinkPath);
+        fs30.unlinkSync(ctx.skillLinkPath);
       } catch {
       }
     }
@@ -59452,8 +60675,8 @@ Examples:
     const agent = parseAgent(opts.agent);
     const profile = getActiveProfile() ?? "default";
     const skip = parseSkipList(opts.skip);
-    const skillPath = opts.skillPath ? path25.resolve(opts.skillPath) : void 0;
-    const tokenFile = opts.tokenFile ? path25.resolve(opts.tokenFile) : void 0;
+    const skillPath = opts.skillPath ? path27.resolve(opts.skillPath) : void 0;
+    const tokenFile = opts.tokenFile ? path27.resolve(opts.tokenFile) : void 0;
     const force = Boolean(opts.force);
     const verify = Boolean(opts.verify);
     const globalOpts = command.parent?.opts() ?? {};
@@ -59497,7 +60720,7 @@ Examples:
     const report = await runInstall(steps, { context: ctx });
     if (report.ok && tokenFile) {
       try {
-        fs28.unlinkSync(tokenFile);
+        fs31.unlinkSync(tokenFile);
       } catch {
       }
     }
@@ -59556,8 +60779,8 @@ Examples:
 init_cjs_shim();
 init_esm();
 init_load();
-import fs29 from "node:fs";
-import readline6 from "node:readline";
+import fs32 from "node:fs";
+import readline7 from "node:readline";
 init_keychain();
 init_output();
 init_request_context();
@@ -59572,7 +60795,7 @@ function parseAgent2(value) {
 }
 async function prompt(question, defaultYes) {
   if (!process.stdin.isTTY) return defaultYes;
-  const rl = readline6.createInterface({ input: process.stdin, output: process.stderr });
+  const rl = readline7.createInterface({ input: process.stdin, output: process.stderr });
   return new Promise((resolve2) => {
     const suffix = defaultYes ? " [Y/n] " : " [y/N] ";
     rl.question(question + suffix, (ans) => {
@@ -59621,10 +60844,10 @@ Examples:
         action: "remove-skill-link",
         detail: skillLink,
         run: async () => {
-          if (!fs29.existsSync(skillLink)) {
+          if (!fs32.existsSync(skillLink)) {
             return { action: "remove-skill-link", status: "absent", detail: skillLink };
           }
-          const stat = fs29.lstatSync(skillLink);
+          const stat = fs32.lstatSync(skillLink);
           if (!stat.isSymbolicLink()) {
             return {
               action: "remove-skill-link",
@@ -59635,7 +60858,7 @@ Examples:
           const ok = yes ? true : await prompt(`Remove skill link ${skillLink}?`, true);
           if (!ok) return { action: "remove-skill-link", status: "skipped", detail: skillLink };
           try {
-            fs29.unlinkSync(skillLink);
+            fs32.unlinkSync(skillLink);
             return { action: "remove-skill-link", status: "removed", detail: skillLink };
           } catch (err) {
             return {
@@ -59690,13 +60913,13 @@ Examples:
             detail: "pass --remove-policy to delete policy.yaml"
           };
         }
-        if (!fs29.existsSync(policyPath)) {
+        if (!fs32.existsSync(policyPath)) {
           return { action: "remove-policy", status: "absent", detail: policyPath };
         }
         const ok = yes ? true : await prompt(`Delete policy file ${policyPath}?`, false);
         if (!ok) return { action: "remove-policy", status: "skipped", detail: policyPath };
         try {
-          fs29.unlinkSync(policyPath);
+          fs32.unlinkSync(policyPath);
           return { action: "remove-policy", status: "removed", detail: policyPath };
         } catch (err) {
           return {
@@ -59759,9 +60982,9 @@ init_request_context();
 init_output();
 init_flags();
 import { spawn as spawn4, spawnSync as spawnSync2 } from "node:child_process";
-import fs30 from "node:fs";
-import os24 from "node:os";
-import path26 from "node:path";
+import fs33 from "node:fs";
+import os25 from "node:os";
+import path28 from "node:path";
 var DEFAULT_OPENCLAW_URL = "http://localhost:18789";
 function resolveStatusSyncRuntime(options) {
   if (!tryLoadConfig()) {
@@ -59895,14 +61118,14 @@ async function probeStatusSyncStart(options = {}) {
   };
 }
 function resolveStatusSyncPaths(explicitStateDir) {
-  const stateDir = path26.resolve(
-    explicitStateDir ?? process.env.SWITCHBOT_STATUS_SYNC_HOME ?? path26.join(os24.homedir(), ".switchbot", "status-sync")
+  const stateDir = path28.resolve(
+    explicitStateDir ?? process.env.SWITCHBOT_STATUS_SYNC_HOME ?? path28.join(os25.homedir(), ".switchbot", "status-sync")
   );
   return {
     stateDir,
-    stateFile: path26.join(stateDir, "state.json"),
-    stdoutLog: path26.join(stateDir, "stdout.log"),
-    stderrLog: path26.join(stateDir, "stderr.log")
+    stateFile: path28.join(stateDir, "state.json"),
+    stdoutLog: path28.join(stateDir, "stdout.log"),
+    stderrLog: path28.join(stateDir, "stderr.log")
   };
 }
 function buildStatusSyncChildArgs(options) {
@@ -59910,11 +61133,11 @@ function buildStatusSyncChildArgs(options) {
   if (!scriptPath) {
     throw new Error("Cannot determine the current CLI entrypoint path.");
   }
-  const args = [path26.resolve(scriptPath)];
+  const args = [path28.resolve(scriptPath)];
   const configPath = getConfigPath();
   const profile = getActiveProfile();
   if (configPath) {
-    args.push("--config", path26.resolve(configPath));
+    args.push("--config", path28.resolve(configPath));
   } else if (profile) {
     args.push("--profile", profile);
   }
@@ -59935,7 +61158,7 @@ function buildStatusSyncChildArgs(options) {
 }
 function safeUnlink(filePath) {
   try {
-    fs30.unlinkSync(filePath);
+    fs33.unlinkSync(filePath);
   } catch {
   }
 }
@@ -59950,9 +61173,9 @@ function isProcessRunning(pid) {
   }
 }
 function readStateFile(paths) {
-  if (!fs30.existsSync(paths.stateFile)) return null;
+  if (!fs33.existsSync(paths.stateFile)) return null;
   try {
-    const raw = JSON.parse(fs30.readFileSync(paths.stateFile, "utf-8"));
+    const raw = JSON.parse(fs33.readFileSync(paths.stateFile, "utf-8"));
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
       safeUnlink(paths.stateFile);
       return null;
@@ -60071,14 +61294,14 @@ function startStatusSync(options = {}) {
     }
     stopStatusSync({ stateDir: paths.stateDir });
   }
-  fs30.mkdirSync(paths.stateDir, { recursive: true });
+  fs33.mkdirSync(paths.stateDir, { recursive: true });
   const configPath = getConfigPath();
   const command = buildStatusSyncChildArgs(runtime);
   let stdoutFd = null;
   let stderrFd = null;
   try {
-    stdoutFd = fs30.openSync(paths.stdoutLog, "a");
-    stderrFd = fs30.openSync(paths.stderrLog, "a");
+    stdoutFd = fs33.openSync(paths.stdoutLog, "a");
+    stderrFd = fs33.openSync(paths.stderrLog, "a");
     const child = spawn4(process.execPath, command, {
       detached: true,
       stdio: ["ignore", stdoutFd, stderrFd],
@@ -60096,16 +61319,16 @@ function startStatusSync(options = {}) {
       openclawUrl: runtime.openclawUrl,
       openclawModel: runtime.openclawModel,
       topic: runtime.topic ?? null,
-      configPath: configPath ? path26.resolve(configPath) : null,
+      configPath: configPath ? path28.resolve(configPath) : null,
       profile: configPath ? null : getActiveProfile() ?? null,
       stdoutLog: paths.stdoutLog,
       stderrLog: paths.stderrLog
     };
-    fs30.writeFileSync(paths.stateFile, JSON.stringify(state, null, 2), { mode: 384 });
+    fs33.writeFileSync(paths.stateFile, JSON.stringify(state, null, 2), { mode: 384 });
     return toStatus(paths, state, true);
   } finally {
-    if (stdoutFd !== null) fs30.closeSync(stdoutFd);
-    if (stderrFd !== null) fs30.closeSync(stderrFd);
+    if (stdoutFd !== null) fs33.closeSync(stdoutFd);
+    if (stderrFd !== null) fs33.closeSync(stderrFd);
   }
 }
 async function runStatusSyncForeground(options = {}) {
@@ -60245,17 +61468,17 @@ Examples:
 // src/commands/health.ts
 init_cjs_shim();
 init_output();
-import http5 from "node:http";
+import http7 from "node:http";
 
 // src/utils/health.ts
 init_cjs_shim();
 init_quota();
 init_audit();
 init_client();
-import fs31 from "node:fs";
-import os25 from "node:os";
-import path27 from "node:path";
-var DEFAULT_AUDIT_PATH3 = path27.join(os25.homedir(), ".switchbot", "audit.log");
+import fs34 from "node:fs";
+import os26 from "node:os";
+import path29 from "node:path";
+var DEFAULT_AUDIT_PATH3 = path29.join(os26.homedir(), ".switchbot", "audit.log");
 var AUDIT_ERROR_WINDOW_MS = 24 * 60 * 60 * 1e3;
 var EXPECTED_ERROR_CODES = /* @__PURE__ */ new Set([161, 171, 190]);
 function getHealthReport(auditPath = DEFAULT_AUDIT_PATH3) {
@@ -60277,7 +61500,7 @@ function getHealthReport(auditPath = DEFAULT_AUDIT_PATH3) {
     status: pct >= 90 ? "critical" : pct >= 70 ? "warn" : "ok"
   };
   let auditHealth;
-  if (!fs31.existsSync(auditPath)) {
+  if (!fs34.existsSync(auditPath)) {
     auditHealth = {
       present: false,
       recentErrors: 0,
@@ -60447,7 +61670,7 @@ Example:
     const opts = cmd.optsWithGlobals();
     const port = parseInt(opts.port, 10);
     const handler = createHealthHandler(opts.auditLog);
-    const server = http5.createServer(handler);
+    const server = http7.createServer(handler);
     server.on("error", (err) => {
       if (err.code === "EADDRINUSE") {
         handleError(Object.assign(new Error(`Port ${port} is already in use. Choose a different port with --port.`), { code: err.code }));
@@ -60478,13 +61701,13 @@ Example:
 init_cjs_shim();
 init_output();
 init_source();
-import https4 from "node:https";
+import https6 from "node:https";
 var pkgName = "@switchbot/openapi-cli";
 function fetchLatestVersion(packageName, timeoutMs = 8e3) {
   const encoded = packageName.replace("/", "%2F");
   const url2 = `https://registry.npmjs.org/${encoded}/latest`;
   return new Promise((resolve2, reject) => {
-    const req = https4.get(url2, { timeout: timeoutMs }, (res) => {
+    const req = https6.get(url2, { timeout: timeoutMs }, (res) => {
       const chunks = [];
       res.on("data", (c) => chunks.push(c));
       res.on("end", () => {
@@ -60581,8 +61804,8 @@ function registerUpgradeCheckCommand(program3) {
 init_cjs_shim();
 init_output();
 import { spawn as spawn5 } from "node:child_process";
-import fs32 from "node:fs";
-import path28 from "node:path";
+import fs35 from "node:fs";
+import path30 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 init_arg_parsers();
 init_source();
@@ -60644,7 +61867,7 @@ function persistState(partial2) {
 }
 function readLastLines(filePath, n = 20) {
   try {
-    const content = fs32.readFileSync(filePath, "utf-8");
+    const content = fs35.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
     return lines.slice(Math.max(0, lines.length - n)).join("\n").trim();
   } catch {
@@ -60734,10 +61957,10 @@ The daemon reads the same policy file as \`switchbot rules run\`.
       }
     }
     const thisFile = fileURLToPath3(import.meta.url);
-    const cliEntry = path28.basename(thisFile) === "index.js" ? thisFile : path28.resolve(path28.dirname(thisFile), "..", "index.js");
+    const cliEntry = path30.basename(thisFile) === "index.js" ? thisFile : path30.resolve(path30.dirname(thisFile), "..", "index.js");
     const args = ["rules", "run"];
     if (opts.policy) args.push(opts.policy);
-    fs32.mkdirSync(path28.dirname(DAEMON_PID_FILE), { recursive: true, mode: 448 });
+    fs35.mkdirSync(path30.dirname(DAEMON_PID_FILE), { recursive: true, mode: 448 });
     persistState({
       status: "starting",
       pid: null,
@@ -60749,14 +61972,14 @@ The daemon reads the same policy file as \`switchbot rules run\`.
       healthzPid: null,
       healthzPidFile: HEALTHZ_PID_FILE
     });
-    const logFd = fs32.openSync(DAEMON_LOG_FILE, "a");
+    const logFd = fs35.openSync(DAEMON_LOG_FILE, "a");
     const child = spawn5(process.execPath, [cliEntry, ...args], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
       env: { ...process.env }
     });
     child.unref();
-    fs32.closeSync(logFd);
+    fs35.closeSync(logFd);
     await probeLiveness({
       child,
       delayMs: 300,
@@ -60779,14 +62002,14 @@ The daemon reads the same policy file as \`switchbot rules run\`.
     let healthzPort = opts.healthzPort ? Number.parseInt(opts.healthzPort, 10) : null;
     if (healthzPort !== null) {
       const healthArgs = ["health", "serve", "--port", String(healthzPort)];
-      const healthLogFd = fs32.openSync(DAEMON_LOG_FILE, "a");
+      const healthLogFd = fs35.openSync(DAEMON_LOG_FILE, "a");
       const healthChild = spawn5(process.execPath, [cliEntry, ...healthArgs], {
         detached: true,
         stdio: ["ignore", healthLogFd, healthLogFd],
         env: { ...process.env }
       });
       healthChild.unref();
-      fs32.closeSync(healthLogFd);
+      fs35.closeSync(healthLogFd);
       if (healthChild.pid) {
         const healthAlive = await probeLiveness({ child: healthChild, delayMs: 200, fatal: false });
         if (healthAlive) {
@@ -60849,11 +62072,11 @@ The daemon reads the same policy file as \`switchbot rules run\`.
       });
     }
     try {
-      fs32.unlinkSync(DAEMON_PID_FILE);
+      fs35.unlinkSync(DAEMON_PID_FILE);
     } catch {
     }
     try {
-      fs32.unlinkSync(HEALTHZ_PID_FILE);
+      fs35.unlinkSync(HEALTHZ_PID_FILE);
     } catch {
     }
     persistState({