@agentmonitors/cli 0.3.2 → 0.5.0

package/dist/index.cjs

@@ -1218,7 +1218,7 @@ var require_command = __commonJS({
     init_cjs_shims();
     var EventEmitter2 = require("events").EventEmitter;
     var childProcess = require("child_process");
-    var path12 = require("path");
+    var path13 = require("path");
     var fs = require("fs");
     var process3 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -2020,13 +2020,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} source - expected values are default/config/env/cli/implied
        * @return {Command} `this` command for chaining
        */
-      setOptionValueWithSource(key, value, source5) {
+      setOptionValueWithSource(key, value, source6) {
         if (this._storeOptionsAsProperties) {
           this[key] = value;
         } else {
           this._optionValues[key] = value;
         }
-        this._optionValueSources[key] = source5;
+        this._optionValueSources[key] = source6;
         return this;
       }
       /**
@@ -2047,13 +2047,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {string}
        */
       getOptionValueSourceWithGlobals(key) {
-        let source5;
+        let source6;
         this._getCommandAndAncestors().forEach((cmd) => {
           if (cmd.getOptionValueSource(key) !== void 0) {
-            source5 = cmd.getOptionValueSource(key);
+            source6 = cmd.getOptionValueSource(key);
           }
         });
-        return source5;
+        return source6;
       }
       /**
        * Get user arguments from implied or explicit arguments.
@@ -2231,9 +2231,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path12.resolve(baseDir, baseName);
+          const localBin = path13.resolve(baseDir, baseName);
           if (fs.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path12.extname(baseName))) return void 0;
+          if (sourceExt.includes(path13.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext2) => fs.existsSync(`${localBin}${ext2}`)
           );
@@ -2251,17 +2251,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path12.resolve(
-            path12.dirname(resolvedScriptPath),
+          executableDir = path13.resolve(
+            path13.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path12.basename(
+            const legacyName = path13.basename(
               this._scriptPath,
-              path12.extname(this._scriptPath)
+              path13.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2272,7 +2272,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path12.extname(executableFile));
+        launchWithNode = sourceExt.includes(path13.extname(executableFile));
         let proc2;
         if (process3.platform !== "win32") {
           if (launchWithNode) {
@@ -2922,8 +2922,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const getErrorMessage = (option2) => {
           const bestOption = findBestOptionFromValue(option2);
           const optionKey = bestOption.attributeName();
-          const source5 = this.getOptionValueSource(optionKey);
-          if (source5 === "env") {
+          const source6 = this.getOptionValueSource(optionKey);
+          if (source6 === "env") {
             return `environment variable '${bestOption.envVar}'`;
           }
           return `option '${bestOption.flags}'`;
@@ -3187,7 +3187,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path12.basename(filename, path12.extname(filename));
+        this._name = path13.basename(filename, path13.extname(filename));
         return this;
       }
       /**
@@ -3201,9 +3201,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path13) {
-        if (path13 === void 0) return this._executableDir;
-        this._executableDir = path13;
+      executableDir(path14) {
+        if (path14 === void 0) return this._executableDir;
+        this._executableDir = path14;
         return this;
       }
       /**
@@ -3773,13 +3773,13 @@ var require_common = __commonJS({
       else if (isNothing(sequence)) return [];
       return [sequence];
     }
-    function extend2(target, source5) {
+    function extend2(target, source6) {
       var index, length, key, sourceKeys;
-      if (source5) {
-        sourceKeys = Object.keys(source5);
+      if (source6) {
+        sourceKeys = Object.keys(source6);
         for (index = 0, length = sourceKeys.length; index < length; index += 1) {
           key = sourceKeys[index];
-          target[key] = source5[key];
+          target[key] = source6[key];
         }
       }
       return target;
@@ -4837,7 +4837,7 @@ var require_function = __commonJS({
     function resolveJavascriptFunction(data) {
       if (data === null) return false;
       try {
-        var source5 = "(" + data + ")", ast = esprima.parse(source5, { range: true });
+        var source6 = "(" + data + ")", ast = esprima.parse(source6, { range: true });
         if (ast.type !== "Program" || ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement" || ast.body[0].expression.type !== "ArrowFunctionExpression" && ast.body[0].expression.type !== "FunctionExpression") {
           return false;
         }
@@ -4847,7 +4847,7 @@ var require_function = __commonJS({
       }
     }
     function constructJavascriptFunction(data) {
-      var source5 = "(" + data + ")", ast = esprima.parse(source5, { range: true }), params = [], body;
+      var source6 = "(" + data + ")", ast = esprima.parse(source6, { range: true }), params = [], body;
       if (ast.type !== "Program" || ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement" || ast.body[0].expression.type !== "ArrowFunctionExpression" && ast.body[0].expression.type !== "FunctionExpression") {
         throw new Error("Failed to resolve function");
       }
@@ -4856,9 +4856,9 @@ var require_function = __commonJS({
       });
       body = ast.body[0].expression.body.range;
       if (ast.body[0].expression.body.type === "BlockStatement") {
-        return new Function(params, source5.slice(body[0] + 1, body[1] - 1));
+        return new Function(params, source6.slice(body[0] + 1, body[1] - 1));
       }
-      return new Function(params, "return " + source5.slice(body[0], body[1]));
+      return new Function(params, "return " + source6.slice(body[0], body[1]));
     }
     function representJavascriptFunction(object3) {
       return object3.toString();
@@ -5084,16 +5084,16 @@ var require_loader = __commonJS({
         state.result += _result;
       }
     }
-    function mergeMappings(state, destination, source5, overridableKeys) {
+    function mergeMappings(state, destination, source6, overridableKeys) {
       var sourceKeys, key, index, quantity;
-      if (!common.isObject(source5)) {
+      if (!common.isObject(source6)) {
         throwError(state, "cannot merge mappings; the provided source object is unacceptable");
       }
-      sourceKeys = Object.keys(source5);
+      sourceKeys = Object.keys(source6);
       for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
         key = sourceKeys[index];
         if (!_hasOwnProperty.call(destination, key)) {
-          setProperty(destination, key, source5[key]);
+          setProperty(destination, key, source6[key]);
           overridableKeys[key] = true;
         }
       }
@@ -10226,8 +10226,8 @@ var require_utils2 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path12) {
-      let input = path12;
+    function removeDotSegments(path13) {
+      let input = path13;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -10427,8 +10427,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path12, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path12 && path12 !== "/" ? path12 : void 0;
+        const [path13, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path13 && path13 !== "/" ? path13 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -10581,10 +10581,10 @@ var require_fast_uri = __commonJS({
     function normalize2(uri2, options2) {
       if (typeof uri2 === "string") {
         uri2 = /** @type {T} */
-        serialize(parse4(uri2, options2), options2);
+        serialize2(parse4(uri2, options2), options2);
       } else if (typeof uri2 === "object") {
         uri2 = /** @type {T} */
-        parse4(serialize(uri2, options2), options2);
+        parse4(serialize2(uri2, options2), options2);
       }
       return uri2;
     }
@@ -10592,13 +10592,13 @@ var require_fast_uri = __commonJS({
       const schemelessOptions = options2 ? Object.assign({ scheme: "null" }, options2) : { scheme: "null" };
       const resolved = resolveComponent(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
-      return serialize(resolved, schemelessOptions);
+      return serialize2(resolved, schemelessOptions);
     }
     function resolveComponent(base, relative, options2, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse4(serialize(base, options2), options2);
-        relative = parse4(serialize(relative, options2), options2);
+        base = parse4(serialize2(base, options2), options2);
+        relative = parse4(serialize2(relative, options2), options2);
       }
       options2 = options2 || {};
       if (!options2.tolerant && relative.scheme) {
@@ -10650,19 +10650,19 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options2) {
       if (typeof uriA === "string") {
         uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse4(uriA, options2), true), { ...options2, skipEscape: true });
+        uriA = serialize2(normalizeComponentEncoding(parse4(uriA, options2), true), { ...options2, skipEscape: true });
       } else if (typeof uriA === "object") {
-        uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options2, skipEscape: true });
+        uriA = serialize2(normalizeComponentEncoding(uriA, true), { ...options2, skipEscape: true });
       }
       if (typeof uriB === "string") {
         uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse4(uriB, options2), true), { ...options2, skipEscape: true });
+        uriB = serialize2(normalizeComponentEncoding(parse4(uriB, options2), true), { ...options2, skipEscape: true });
       } else if (typeof uriB === "object") {
-        uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options2, skipEscape: true });
+        uriB = serialize2(normalizeComponentEncoding(uriB, true), { ...options2, skipEscape: true });
       }
       return uriA.toLowerCase() === uriB.toLowerCase();
     }
-    function serialize(cmpts, opts) {
+    function serialize2(cmpts, opts) {
       const component = {
         host: cmpts.host,
         scheme: cmpts.scheme,
@@ -10818,7 +10818,7 @@ var require_fast_uri = __commonJS({
       resolve,
       resolveComponent,
       equal,
-      serialize,
+      serialize: serialize2,
       parse: parse4
     };
     module2.exports = fastUri;
@@ -11553,12 +11553,12 @@ var require_ref = __commonJS({
       function callSyncRef() {
         cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v));
       }
-      function addErrorsFrom(source5) {
-        const errs = (0, codegen_1._)`${source5}.errors`;
+      function addErrorsFrom(source6) {
+        const errs = (0, codegen_1._)`${source6}.errors`;
         gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`);
         gen.assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
       }
-      function addEvaluatedFrom(source5) {
+      function addEvaluatedFrom(source6) {
         var _a2;
         if (!it.opts.unevaluated)
           return;
@@ -11569,7 +11569,7 @@ var require_ref = __commonJS({
               it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props);
             }
           } else {
-            const props = gen.var("props", (0, codegen_1._)`${source5}.evaluated.props`);
+            const props = gen.var("props", (0, codegen_1._)`${source6}.evaluated.props`);
             it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name);
           }
         }
@@ -11579,7 +11579,7 @@ var require_ref = __commonJS({
               it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items);
             }
           } else {
-            const items = gen.var("items", (0, codegen_1._)`${source5}.evaluated.items`);
+            const items = gen.var("items", (0, codegen_1._)`${source6}.evaluated.items`);
             it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name);
           }
         }
@@ -13851,8 +13851,8 @@ var require_dist = __commonJS({
 
 // src/index.ts
 init_cjs_shims();
-var import_node_fs6 = require("fs");
-var import_node_path9 = require("path");
+var import_node_fs7 = require("fs");
+var import_node_path10 = require("path");
 var import_node_url4 = require("url");
 
 // ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/esm.mjs
@@ -13905,6 +13905,23 @@ urgency: normal
 ---
 
 When the API response changes, review the differences and take appropriate action.
+`.trimStart(),
+  "command-poll": yaml2`
+---
+name: My command monitor
+watch:
+  type: command-poll
+  command:
+    - git
+    - status
+    - --porcelain
+  interval: 5m
+  change-detection:
+    strategy: text-diff
+urgency: normal
+---
+
+When the command output changes, review the differences and take appropriate action.
 `.trimStart(),
   schedule: yaml2`
 ---
@@ -13954,6 +13971,7 @@ Edit the file to configure your monitor, then run:`);
 
 // src/commands/validate.ts
 init_cjs_shims();
+var import_node_fs3 = require("fs");
 
 // ../../libs/core/dist/index.js
 init_cjs_shims();
@@ -14451,8 +14469,8 @@ function getErrorMap() {
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 init_cjs_shims();
 var makeIssue = (params) => {
-  const { data, path: path12, errorMaps, issueData } = params;
-  const fullPath = [...path12, ...issueData.path || []];
+  const { data, path: path13, errorMaps, issueData } = params;
+  const fullPath = [...path13, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -14572,11 +14590,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path12, key) {
+  constructor(parent, value, path13, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path12;
+    this._path = path13;
     this._key = key;
   }
   get path() {
@@ -22642,12 +22660,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path12) {
-    if (!path12) {
+  resolve(path13) {
+    if (!path13) {
       return this;
     }
-    const rootPath = this.getRootString(path12);
-    const dir = path12.substring(rootPath.length);
+    const rootPath = this.getRootString(path13);
+    const dir = path13.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -23399,8 +23417,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path12) {
-    return import_node_path2.win32.parse(path12).root;
+  getRootString(path13) {
+    return import_node_path2.win32.parse(path13).root;
   }
   /**
    * @internal
@@ -23446,8 +23464,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path12) {
-    return path12.startsWith("/") ? "/" : "";
+  getRootString(path13) {
+    return path13.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -23536,11 +23554,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path12 = this.cwd) {
-    if (typeof path12 === "string") {
-      path12 = this.cwd.resolve(path12);
+  depth(path13 = this.cwd) {
+    if (typeof path13 === "string") {
+      path13 = this.cwd.resolve(path13);
     }
-    return path12.depth();
+    return path13.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -24027,9 +24045,9 @@ var PathScurryBase = class {
     process3();
     return results;
   }
-  chdir(path12 = this.cwd) {
+  chdir(path13 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path12 === "string" ? this.cwd.resolve(path12) : path12;
+    this.cwd = typeof path13 === "string" ? this.cwd.resolve(path13) : path13;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -24391,8 +24409,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path12, n]) => [
-      path12,
+    return [...this.store.entries()].map(([path13, n]) => [
+      path13,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -24597,9 +24615,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path12, opts) {
+  constructor(patterns, path13, opts) {
     this.patterns = patterns;
-    this.path = path12;
+    this.path = path13;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -24618,11 +24636,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path12) {
-    return this.seen.has(path12) || !!this.#ignore?.ignored?.(path12);
+  #ignored(path13) {
+    return this.seen.has(path13) || !!this.#ignore?.ignored?.(path13);
   }
-  #childrenIgnored(path12) {
-    return !!this.#ignore?.childrenIgnored?.(path12);
+  #childrenIgnored(path13) {
+    return !!this.#ignore?.childrenIgnored?.(path13);
   }
   // backpressure mechanism
   pause() {
@@ -24837,8 +24855,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path12, opts) {
-    super(patterns, path12, opts);
+  constructor(patterns, path13, opts) {
+    super(patterns, path13, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -24875,8 +24893,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path12, opts) {
-    super(patterns, path12, opts);
+  constructor(patterns, path13, opts) {
+    super(patterns, path13, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -26384,7 +26402,7 @@ Subquery.prototype.getSQL = function() {
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path12, field }, columnIndex) => {
+    (result2, { path: path13, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -26396,8 +26414,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path12.entries()) {
-        if (pathChunkIndex < path12.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path13.entries()) {
+        if (pathChunkIndex < path13.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -26405,8 +26423,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         } else {
           const rawValue = row[columnIndex];
           const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-          if (joinsNotNullableMap && is(field, Column) && path12.length === 2) {
-            const objectName = path12[0];
+          if (joinsNotNullableMap && is(field, Column) && path13.length === 2) {
+            const objectName = path13[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -28669,24 +28687,24 @@ var SQLiteSelectBuilder = class {
     this.withList = config2.withList;
     this.distinct = config2.distinct;
   }
-  from(source5) {
+  from(source6) {
     const isPartialSelect = !!this.fields;
     let fields;
     if (this.fields) {
       fields = this.fields;
-    } else if (is(source5, Subquery)) {
+    } else if (is(source6, Subquery)) {
       fields = Object.fromEntries(
-        Object.keys(source5._.selectedFields).map((key) => [key, source5[key]])
+        Object.keys(source6._.selectedFields).map((key) => [key, source6[key]])
       );
-    } else if (is(source5, SQLiteViewBase)) {
-      fields = source5[ViewBaseConfig].selectedFields;
-    } else if (is(source5, SQL)) {
+    } else if (is(source6, SQLiteViewBase)) {
+      fields = source6[ViewBaseConfig].selectedFields;
+    } else if (is(source6, SQL)) {
       fields = {};
     } else {
-      fields = getTableColumns(source5);
+      fields = getTableColumns(source6);
     }
     return new SQLiteSelectBase({
-      table: source5,
+      table: source6,
       fields,
       isPartialSelect,
       session: this.session,
@@ -29590,8 +29608,8 @@ var SQLiteUpdateBase = class extends QueryPromise {
   static [entityKind] = "SQLiteUpdate";
   /** @internal */
   config;
-  from(source5) {
-    this.config.from = source5;
+  from(source6) {
+    this.config.from = source6;
     return this;
   }
   createJoin(joinType) {
@@ -29743,11 +29761,11 @@ var SQLiteCountBuilder = class _SQLiteCountBuilder extends SQL {
   static [entityKind] = "SQLiteCountBuilderAsync";
   [Symbol.toStringTag] = "SQLiteCountBuilderAsync";
   session;
-  static buildEmbeddedCount(source5, filters) {
-    return sql`(select count(*) from ${source5}${sql.raw(" where ").if(filters)}${filters})`;
+  static buildEmbeddedCount(source6, filters) {
+    return sql`(select count(*) from ${source6}${sql.raw(" where ").if(filters)}${filters})`;
   }
-  static buildCount(source5, filters) {
-    return sql`select count(*) from ${source5}${sql.raw(" where ").if(filters)}${filters}`;
+  static buildCount(source6, filters) {
+    return sql`select count(*) from ${source6}${sql.raw(" where ").if(filters)}${filters}`;
   }
   then(onfulfilled, onrejected) {
     return Promise.resolve(this.session.count(this.sql)).then(
@@ -30032,8 +30050,8 @@ var BaseSQLiteDatabase = class {
     };
     return { as };
   };
-  $count(source5, filters) {
-    return new SQLiteCountBuilder({ source: source5, filters, session: this.session });
+  $count(source6, filters) {
+    return new SQLiteCountBuilder({ source: source6, filters, session: this.session });
   }
   /**
    * Incorporates a previously defined CTE (using `$with`) into the main query.
@@ -30607,8 +30625,8 @@ function drizzle(...params) {
     const { connection, client, ...drizzleConfig } = params[0];
     if (client) return construct(client, drizzleConfig);
     if (typeof connection === "object") {
-      const { source: source5, ...options2 } = connection;
-      const instance2 = new import_better_sqlite3.default(source5, options2);
+      const { source: source6, ...options2 } = connection;
+      const instance2 = new import_better_sqlite3.default(source6, options2);
       return construct(instance2, drizzleConfig);
     }
     const instance = new import_better_sqlite3.default(connection);
@@ -30749,8 +30767,8 @@ var monitorFrontmatterSchema = external_exports.object({
   notify: notifySchema.optional(),
   tags: external_exports.array(external_exports.string()).optional()
 });
-function validateScope(scope, scopeSchema5) {
-  const validator = new Validator(scopeSchema5, "7", false);
+function validateScope(scope, scopeSchema6) {
+  const validator = new Validator(scopeSchema6, "7", false);
   const result = validator.validate(scope);
   if (result.valid) return [];
   const messages = result.errors.map((unit) => {
@@ -31224,13 +31242,13 @@ var InboxService = class {
 };
 var SourceRegistry = class {
   sources = /* @__PURE__ */ new Map();
-  register(source5) {
-    if (this.sources.has(source5.name)) {
+  register(source6) {
+    if (this.sources.has(source6.name)) {
       throw new Error(
-        `Observation source "${source5.name}" is already registered`
+        `Observation source "${source6.name}" is already registered`
       );
     }
-    this.sources.set(source5.name, source5);
+    this.sources.set(source6.name, source6);
   }
   get(name) {
     return this.sources.get(name);
@@ -31247,7 +31265,7 @@ var SourceRegistry = class {
 };
 function generateMonitorSchema(sources) {
   const sourceNames = sources.map((s) => s.name);
-  const conditionals = sources.map((source5) => ({
+  const conditionals = sources.map((source6) => ({
     if: {
       // `required: ['type']` on the inner `watch` is essential: JSON Schema
       // `properties` constraints are vacuously satisfied when the property is
@@ -31256,14 +31274,14 @@ function generateMonitorSchema(sources) {
       // instead of a clean "watch.type is required".
       properties: {
         watch: {
-          properties: { type: { const: source5.name } },
+          properties: { type: { const: source6.name } },
           required: ["type"]
         }
       },
       required: ["watch"]
     },
     then: {
-      properties: { watch: source5.scopeSchema }
+      properties: { watch: source6.scopeSchema }
     }
   }));
   return {
@@ -31315,6 +31333,195 @@ function generateMonitorSchema(sources) {
     allOf: conditionals
   };
 }
+function parseKeyedCollectionConfig(changeDetection) {
+  if (changeDetection === null || typeof changeDetection !== "object" || Array.isArray(changeDetection)) {
+    return void 0;
+  }
+  const collection = changeDetection["collection"];
+  if (collection === void 0) return void 0;
+  if (collection === null || typeof collection !== "object" || Array.isArray(collection)) {
+    throw new Error(
+      'change-detection.collection must be an object with "path" and "key"'
+    );
+  }
+  const c = collection;
+  const path72 = c["path"];
+  if (typeof path72 !== "string" || path72.length === 0) {
+    throw new Error(
+      "change-detection.collection.path must be a non-empty string"
+    );
+  }
+  const key = c["key"];
+  if (typeof key !== "string" || key.length === 0) {
+    throw new Error(
+      "change-detection.collection.key must be a non-empty string"
+    );
+  }
+  const rawIgnore = c["ignore-paths"];
+  let ignorePaths;
+  if (rawIgnore !== void 0) {
+    if (!Array.isArray(rawIgnore) || !rawIgnore.every((p) => typeof p === "string")) {
+      throw new Error(
+        "change-detection.collection.ignore-paths must be an array of strings"
+      );
+    }
+    ignorePaths = rawIgnore;
+  }
+  return ignorePaths ? { path: path72, key, ignorePaths } : { path: path72, key };
+}
+function assertValidSegment(path72, segment) {
+  if (/[[\]*?\s]/.test(segment)) {
+    throw new Error(
+      `Invalid collection path "${path72}": segment "${segment}" contains unsupported syntax (only plain field names are allowed \u2014 no "[index]", wildcards, or filters)`
+    );
+  }
+}
+function normalizeDottedPath(path72) {
+  if (path72 === "$" || path72.startsWith("$.")) return path72;
+  if (path72.startsWith("$")) {
+    throw new Error(
+      `Invalid collection path "${path72}": a path beginning with "$" must be explicit-root form ("$" or "$.field"). Write "${path72.slice(1)}" for a bare root-relative path, or "$.${path72.slice(1)}" for explicit-root form.`
+    );
+  }
+  return `$.${path72}`;
+}
+function resolveDottedPath(root, path72) {
+  const normalizedPath = normalizeDottedPath(path72);
+  if (normalizedPath === "$") return root;
+  const segments = normalizedPath.slice(2).split(".");
+  let current = root;
+  for (const segment of segments) {
+    if (segment.length === 0) {
+      throw new Error(`Invalid collection path "${path72}": empty path segment`);
+    }
+    assertValidSegment(path72, segment);
+    if (current === null || typeof current !== "object" || Array.isArray(current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function removeDottedPath(value, path72) {
+  const normalizedPath = normalizeDottedPath(path72);
+  if (normalizedPath === "$") return;
+  const segments = normalizedPath.slice(2).split(".");
+  let current = value;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = segments[i];
+    if (segment === void 0 || segment.length === 0) {
+      throw new Error(
+        `Invalid ignore-paths entry "${path72}": empty path segment`
+      );
+    }
+    assertValidSegment(path72, segment);
+    if (current === null || typeof current !== "object" || Array.isArray(current)) {
+      return;
+    }
+    current = current[segment];
+  }
+  const last = segments[segments.length - 1];
+  if (last === void 0 || last.length === 0) {
+    throw new Error(`Invalid ignore-paths entry "${path72}": empty path segment`);
+  }
+  assertValidSegment(path72, last);
+  if (current !== null && typeof current === "object" && !Array.isArray(current)) {
+    Reflect.deleteProperty(current, last);
+  }
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value !== null && typeof value === "object") {
+    const sorted = {};
+    for (const k of Object.keys(value).sort()) {
+      sorted[k] = sortKeys(value[k]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function normalizeElement(element, ignorePaths) {
+  const clone2 = structuredClone(element);
+  if (ignorePaths) {
+    for (const p of ignorePaths) removeDottedPath(clone2, p);
+  }
+  return sortKeys(clone2);
+}
+function serialize(value) {
+  return JSON.stringify(value);
+}
+function keyValueOf(element, keyField) {
+  if (element === null || typeof element !== "object" || Array.isArray(element)) {
+    throw new Error(
+      `collection element is not an object (cannot read key "${keyField}")`
+    );
+  }
+  const raw = element[keyField];
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "number" || typeof raw === "boolean") return String(raw);
+  throw new Error(
+    `collection element is missing a scalar key field "${keyField}"`
+  );
+}
+function diffKeyedCollection(parsedOutput, config2, monitorObjectKey, previousSnapshot, observationFields) {
+  const resolved = resolveDottedPath(parsedOutput, config2.path);
+  if (!Array.isArray(resolved)) {
+    throw new Error(
+      `collection path "${config2.path}" must select an array (got ${resolved === void 0 ? "nothing" : typeof resolved})`
+    );
+  }
+  const current = {};
+  for (const element of resolved) {
+    const keyValue = keyValueOf(element, config2.key);
+    if (Object.prototype.hasOwnProperty.call(current, keyValue)) {
+      throw new Error(
+        `collection key "${config2.key}" value "${keyValue}" is not unique within the collection`
+      );
+    }
+    current[keyValue] = normalizeElement(element, config2.ignorePaths);
+  }
+  if (previousSnapshot === void 0) {
+    return { observations: [], snapshot: current };
+  }
+  const observations = [];
+  const emit = (keyValue, changeKind) => {
+    const objectKey = `${monitorObjectKey}#${keyValue}`;
+    const title = `${titleVerb(changeKind)}: ${objectKey}`;
+    observations.push({
+      title,
+      summary: title,
+      objectKey,
+      changeKind,
+      payload: { ...observationFields?.payload, key: keyValue, changeKind },
+      queryScope: { ...observationFields?.queryScope, objectKey }
+    });
+  };
+  for (const keyValue of Object.keys(current)) {
+    if (!Object.prototype.hasOwnProperty.call(previousSnapshot, keyValue)) {
+      emit(keyValue, "created");
+    } else if (serialize(current[keyValue]) !== serialize(previousSnapshot[keyValue])) {
+      emit(keyValue, "modified");
+    }
+  }
+  for (const keyValue of Object.keys(previousSnapshot)) {
+    if (!Object.prototype.hasOwnProperty.call(current, keyValue)) {
+      emit(keyValue, "descoped");
+    }
+  }
+  return { observations, snapshot: current };
+}
+function titleVerb(changeKind) {
+  switch (changeKind) {
+    case "created":
+      return "Item added";
+    case "modified":
+      return "Item changed";
+    case "descoped":
+      return "Item removed";
+    case "deleted":
+      return "Item deleted";
+  }
+}
 function parseDuration(duration3) {
   const match2 = /^(?<digits>\d+)(?<unit>[smhd])$/.exec(duration3);
   const digits = match2?.groups?.["digits"];
@@ -31472,6 +31679,11 @@ function rowToEvent(row) {
     createdAt: row.createdAt
   };
 }
+function deliveryStateForRow(row) {
+  if (row.acknowledgedAt) return "acknowledged";
+  if (row.firstNotifiedAt) return "claimed";
+  return "unread";
+}
 function scopeMatches(eventScope, requested) {
   if (!requested) return true;
   for (const [key, value] of Object.entries(requested)) {
@@ -31639,6 +31851,13 @@ var RuntimeStore = class {
     if (query.objectKey)
       conditions.push(eq(monitorEvents.objectKey, query.objectKey));
     if (query.since) conditions.push(gt(monitorEvents.createdAt, query.since));
+    if (query.workspacePath !== void 0) {
+      const workspaceCondition = or(
+        eq(monitorEvents.workspacePath, query.workspacePath),
+        isNull(monitorEvents.workspacePath)
+      );
+      if (workspaceCondition) conditions.push(workspaceCondition);
+    }
     let rows = query.sessionId ? asInternalDb2(this.db).select({
       event: monitorEvents,
       state: sessionEventState
@@ -31713,6 +31932,37 @@ var RuntimeStore = class {
       createdAt: row.createdAt
     }));
   }
+  listDeliveryProjectionsForMonitor(monitorId, workspacePath) {
+    const conditions = [eq(monitorEvents.monitorId, monitorId)];
+    if (workspacePath !== void 0) {
+      const workspaceCondition = or(
+        eq(agentSessions.workspacePath, workspacePath),
+        isNull(agentSessions.workspacePath)
+      );
+      if (workspaceCondition) conditions.push(workspaceCondition);
+    }
+    const rows = asInternalDb2(this.db).select({
+      event: monitorEvents,
+      state: sessionEventState,
+      session: agentSessions
+    }).from(sessionEventState).innerJoin(monitorEvents, eq(sessionEventState.eventId, monitorEvents.id)).innerJoin(
+      agentSessions,
+      eq(sessionEventState.sessionId, agentSessions.id)
+    ).where(and(...conditions)).orderBy(desc(monitorEvents.createdAt)).all();
+    return rows.map(({ event, state, session }) => ({
+      eventId: event.id,
+      sessionId: session.id,
+      sessionRole: session.role,
+      sessionStatus: session.status,
+      deliveryState: deliveryStateForRow(state),
+      workspacePath: session.workspacePath ?? null,
+      createdAt: state.createdAt,
+      ...state.firstNotifiedAt ? { firstNotifiedAt: state.firstNotifiedAt } : {},
+      ...state.lastClaimAt ? { lastClaimAt: state.lastClaimAt } : {},
+      ...state.lastClaimLifecycle ? { lastClaimLifecycle: state.lastClaimLifecycle } : {},
+      ...state.acknowledgedAt ? { acknowledgedAt: state.acknowledgedAt } : {}
+    }));
+  }
   sessionsForWorkspace(workspacePath) {
     return asInternalDb2(this.db).select().from(agentSessions).where(
       workspacePath == null ? isNull(agentSessions.workspacePath) : or(
@@ -31820,6 +32070,14 @@ var DEFAULT_FILE_FINGERPRINT_POLL_MS = 3e4;
 var DEFAULT_API_POLL_MS = 3e5;
 var DEFAULT_HIGH_URGENCY_SETTLE_MS = 15e3;
 var MAX_RECAP_EVENTS = 10;
+var EXPLAIN_STAGE_LABELS = {
+  definition: "Definition",
+  scheduling: "Scheduling",
+  observation: "Observation",
+  notify: "Notify state",
+  materialization: "Materialization",
+  delivery: "Projection and delivery"
+};
 function watchConfig(watch) {
   const { type: _type, ...config2 } = watch;
   return config2;
@@ -31838,6 +32096,28 @@ function writeJsonAtomic(filePath2, payload) {
   (0, import_fs3.writeFileSync)(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
   (0, import_fs3.renameSync)(tmpPath, filePath2);
 }
+function monitorIdFromFilePath(filePath2) {
+  const base = import_path4.default.basename(filePath2);
+  return base === "MONITOR.md" ? import_path4.default.basename(import_path4.default.dirname(filePath2)) : import_path4.default.parse(filePath2).name;
+}
+function explainStage(id, status, reason, details) {
+  return {
+    id,
+    label: EXPLAIN_STAGE_LABELS[id],
+    status,
+    reason,
+    ...details ? { details } : {}
+  };
+}
+function explainVerdict(stages) {
+  const stopped = stages.find((stage2) => stage2.status !== "ok");
+  const stage = stopped ?? stages[stages.length - 1];
+  return {
+    status: stage?.status ?? "ok",
+    stage: stage?.id ?? "delivery",
+    reason: stage?.reason ?? "Monitor delivered successfully."
+  };
+}
 function serializeObservation(monitor, observation, observedAt) {
   return { monitor, observation, observedAt };
 }
@@ -31952,6 +32232,320 @@ var AgentMonitorRuntime = class {
   listObservationHistory(query = {}) {
     return this.store.listObservationHistory(query);
   }
+  async explainMonitor(input) {
+    const now = input.now ?? /* @__PURE__ */ new Date();
+    const historyLimit = input.historyLimit ?? 10;
+    const eventLimit = input.eventLimit ?? 10;
+    const stages = [];
+    const scan = await scanMonitors(input.monitorsDir);
+    const parseError = scan.errors.find(
+      (error2) => monitorIdFromFilePath(error2.filePath) === input.monitorId
+    );
+    const monitor = scan.monitors.find(
+      (candidate) => candidate.monitor.id === input.monitorId
+    )?.monitor;
+    const duplicate = scan.duplicateIds.find(
+      (candidate) => candidate.id === input.monitorId
+    );
+    if (parseError) {
+      stages.push(
+        explainStage(
+          "definition",
+          "failure",
+          `MONITOR.md failed to parse or validate: ${parseError.error}`,
+          { filePath: parseError.filePath }
+        )
+      );
+      return {
+        monitorId: input.monitorId,
+        generatedAt: now,
+        stages,
+        verdict: explainVerdict(stages),
+        observations: [],
+        events: [],
+        projections: [],
+        leadSessions: []
+      };
+    }
+    if (!monitor) {
+      stages.push(
+        explainStage(
+          "definition",
+          "failure",
+          `Monitor "${input.monitorId}" was not found in ${input.monitorsDir}.`
+        )
+      );
+      return {
+        monitorId: input.monitorId,
+        generatedAt: now,
+        stages,
+        verdict: explainVerdict(stages),
+        observations: [],
+        events: [],
+        projections: [],
+        leadSessions: []
+      };
+    }
+    if (duplicate) {
+      stages.push(
+        explainStage(
+          "definition",
+          "failure",
+          `Monitor id "${input.monitorId}" is duplicated across ${String(duplicate.filePaths.length)} files.`,
+          { filePaths: duplicate.filePaths }
+        )
+      );
+      return {
+        monitorId: input.monitorId,
+        generatedAt: now,
+        monitor: {
+          id: monitor.id,
+          displayName: monitor.displayName,
+          filePath: monitor.filePath,
+          sourceName: monitor.frontmatter.watch.type,
+          urgency: monitor.frontmatter.urgency
+        },
+        stages,
+        verdict: explainVerdict(stages),
+        observations: [],
+        events: [],
+        projections: [],
+        leadSessions: []
+      };
+    }
+    const sourceName = monitor.frontmatter.watch.type;
+    const source6 = this.registry.get(sourceName);
+    const scopeErrors = source6 ? validateScope(
+      watchConfig(monitor.frontmatter.watch),
+      source6.scopeSchema
+    ) : [`Unknown source "${sourceName}".`];
+    if (scopeErrors.length > 0) {
+      stages.push(
+        explainStage(
+          "definition",
+          "failure",
+          `Monitor definition is invalid: ${scopeErrors.join("; ")}`,
+          { filePath: monitor.filePath, sourceName }
+        )
+      );
+      return {
+        monitorId: input.monitorId,
+        generatedAt: now,
+        monitor: {
+          id: monitor.id,
+          displayName: monitor.displayName,
+          filePath: monitor.filePath,
+          sourceName,
+          urgency: monitor.frontmatter.urgency
+        },
+        stages,
+        verdict: explainVerdict(stages),
+        observations: [],
+        events: [],
+        projections: [],
+        leadSessions: []
+      };
+    }
+    stages.push(
+      explainStage("definition", "ok", "Monitor definition is valid.", {
+        filePath: monitor.filePath,
+        sourceName
+      })
+    );
+    const runtimeState = this.store.getMonitorState(input.monitorId);
+    const schedule = this.scheduleForMonitor(monitor, now);
+    const lastObservationAt = runtimeState.lastObservationAt;
+    const nextDueAt = schedule.due ? now : new Date(
+      (lastObservationAt?.getTime() ?? now.getTime()) + schedule.nextPollMs
+    );
+    stages.push(
+      explainStage(
+        "scheduling",
+        "ok",
+        lastObservationAt ? `Last tick completed at ${lastObservationAt.toISOString()}; next due ${schedule.due ? "now" : nextDueAt.toISOString()}.` : "No completed tick is recorded yet; the monitor is due on the next daemon tick.",
+        {
+          due: schedule.due,
+          nextPollMs: schedule.nextPollMs,
+          nextDueAt: nextDueAt.toISOString(),
+          ...lastObservationAt ? { lastObservationAt: lastObservationAt.toISOString() } : {}
+        }
+      )
+    );
+    const observations = this.store.listObservationHistory({
+      monitorId: input.monitorId,
+      limit: historyLimit
+    });
+    const latestObservation = observations[0];
+    if (!latestObservation) {
+      stages.push(
+        explainStage(
+          "observation",
+          "failure",
+          "No observation history has been recorded for this monitor."
+        )
+      );
+    } else if (latestObservation.result === "errored") {
+      stages.push(
+        explainStage(
+          "observation",
+          "failure",
+          "The most recent source observation errored.",
+          latestObservation.observationData
+        )
+      );
+    } else if (latestObservation.result === "no-change") {
+      stages.push(
+        explainStage(
+          "observation",
+          "healthy",
+          "Source ran, observed 0 changes \u2014 your watched target genuinely hasn\u2019t changed (not a bug).",
+          latestObservation.observationData
+        )
+      );
+    } else if (latestObservation.result === "rebaselined") {
+      stages.push(
+        explainStage(
+          "observation",
+          "healthy",
+          "Source rebaselined and emitted no change \u2014 your watched target is being tracked, nothing to report (not a bug).",
+          latestObservation.observationData
+        )
+      );
+    } else {
+      stages.push(
+        explainStage(
+          "observation",
+          "ok",
+          `The latest observation outcome was ${latestObservation.result}.`,
+          latestObservation.observationData
+        )
+      );
+    }
+    const observationHealthy = latestObservation?.result === "no-change" || latestObservation?.result === "rebaselined";
+    const notifyState = runtimeState.notifyState;
+    const pendingDebounce = notifyState.pendingDebounce;
+    const suppressedUntil = notifyState.suppressedUntil ? new Date(notifyState.suppressedUntil) : null;
+    if (pendingDebounce && new Date(pendingDebounce.dueAt) > now) {
+      stages.push(
+        explainStage(
+          "notify",
+          "pending",
+          `debounce is holding ${String(pendingDebounce.observations.length)} observation(s) until ${pendingDebounce.dueAt}.`,
+          {
+            dueAt: pendingDebounce.dueAt,
+            observations: pendingDebounce.observations.length
+          }
+        )
+      );
+    } else if (suppressedUntil && suppressedUntil > now) {
+      stages.push(
+        explainStage(
+          "notify",
+          "pending",
+          `throttle is suppressing new notifications until ${suppressedUntil.toISOString()}.`,
+          { suppressedUntil: suppressedUntil.toISOString() }
+        )
+      );
+    } else {
+      stages.push(
+        explainStage(
+          "notify",
+          "ok",
+          "No debounce or throttle hold is currently active."
+        )
+      );
+    }
+    const events = this.store.listEvents({
+      monitorId: input.monitorId,
+      // Scope to the explained workspace so a same-id monitor in another
+      // workspace cannot leak its events into this report (issue #94 review).
+      ...input.workspacePath !== void 0 ? { workspacePath: input.workspacePath } : {}
+    }).slice(0, eventLimit);
+    if (events.length === 0) {
+      stages.push(
+        observationHealthy ? explainStage(
+          "materialization",
+          "healthy",
+          "No events materialized \u2014 expected, because the source observed no changes (not a bug)."
+        ) : explainStage(
+          "materialization",
+          "failure",
+          "No monitor_events rows exist for this monitor."
+        )
+      );
+    } else {
+      stages.push(
+        explainStage(
+          "materialization",
+          "ok",
+          `${String(events.length)} recent monitor_events row(s) found.`,
+          { eventIds: events.map((event) => event.id) }
+        )
+      );
+    }
+    const projections = this.store.listDeliveryProjectionsForMonitor(
+      input.monitorId,
+      // Scope to the explained workspace's sessions (plus global sessions) so
+      // projections from other workspaces are not overcounted (issue #94 review).
+      input.workspacePath
+    );
+    const leadSessions = this.store.sessionsForWorkspace(input.workspacePath).filter((session) => session.role === "lead");
+    if (events.length > 0 && projections.length === 0) {
+      stages.push(
+        explainStage(
+          "delivery",
+          "failure",
+          leadSessions.length === 0 ? "No lead session is registered for this workspace, so events were not projected." : "No session_event_state projections exist for the materialized events.",
+          { leadSessions: leadSessions.map((session) => session.id) }
+        )
+      );
+    } else if (events.length > 0) {
+      const counts = projections.reduce(
+        (acc, projection) => {
+          acc[projection.deliveryState] = (acc[projection.deliveryState] ?? 0) + 1;
+          return acc;
+        },
+        {}
+      );
+      stages.push(
+        explainStage(
+          "delivery",
+          "ok",
+          `Events are projected to lead sessions (${Object.entries(counts).map(([state, count]) => `${state}: ${String(count)}`).join(", ")}).`,
+          counts
+        )
+      );
+    } else {
+      stages.push(
+        observationHealthy ? explainStage(
+          "delivery",
+          "healthy",
+          "Nothing to deliver \u2014 the source observed no changes, so there is no signal to project (not a bug)."
+        ) : explainStage(
+          "delivery",
+          "pending",
+          "Delivery has not started because no event has materialized yet."
+        )
+      );
+    }
+    return {
+      monitorId: input.monitorId,
+      generatedAt: now,
+      monitor: {
+        id: monitor.id,
+        displayName: monitor.displayName,
+        filePath: monitor.filePath,
+        sourceName,
+        urgency: monitor.frontmatter.urgency
+      },
+      stages,
+      verdict: explainVerdict(stages),
+      observations,
+      events,
+      projections,
+      leadSessions
+    };
+  }
   acknowledgeSession(sessionId, eventIds) {
     const ids = eventIds ?? this.store.unreadEventsForSession(sessionId).map((e) => e.id);
     this.store.acknowledgeEvents(sessionId, ids);
@@ -32099,8 +32693,8 @@ var AgentMonitorRuntime = class {
     for (const parsed of result.monitors) {
       const monitor = parsed.monitor;
       const sourceName = monitor.frontmatter.watch.type;
-      const source5 = this.registry.get(sourceName);
-      if (!source5) {
+      const source6 = this.registry.get(sourceName);
+      if (!source6) {
         throw new Error(
           `Monitor "${monitor.id}" references unknown source "${sourceName}".`
         );
@@ -32112,7 +32706,7 @@ var AgentMonitorRuntime = class {
       let observationResult;
       try {
         const monitorState2 = this.store.getMonitorState(monitor.id);
-        observationResult = await source5.observe(
+        observationResult = await source6.observe(
           watchConfig(monitor.frontmatter.watch),
           {
             previousState: monitorState2.sourceState,
@@ -32263,18 +32857,18 @@ var AgentMonitorRuntime = class {
     for (const parsed of result.monitors) {
       const monitor = parsed.monitor;
       const sourceName = monitor.frontmatter.watch.type;
-      const source5 = this.registry.get(sourceName);
-      if (!source5) {
+      const source6 = this.registry.get(sourceName);
+      if (!source6) {
         throw new Error(
           `Monitor "${monitor.id}" references unknown source "${sourceName}".`
         );
       }
-      if (!source5.watch) continue;
+      if (!source6.watch) continue;
       if (this.activeWatchers.has(monitor.id)) continue;
       const controller = new AbortController();
       controllers.set(monitor.id, controller);
       this.activeWatchers.add(monitor.id);
-      const watch = source5.watch.bind(source5);
+      const watch = source6.watch.bind(source6);
       tasks.push(
         this.consumeWatch(
           monitor,
@@ -32668,12 +33262,17 @@ function parseScopeConfig2(config2) {
   const cd = config2["change-detection"];
   const strategy = cd?.strategy;
   const changeDetection = strategy === "status-code" || strategy === "json-diff" ? strategy : "text-diff";
+  const collection = parseKeyedCollectionConfig(config2["change-detection"]);
+  if (collection && changeDetection !== "json-diff") {
+    throw new Error("change-detection.collection requires strategy: json-diff");
+  }
   return {
     url,
     auth: config2["auth"],
     headers: config2["headers"],
     method: typeof config2["method"] === "string" ? config2["method"] : void 0,
-    changeDetection
+    changeDetection,
+    collection
   };
 }
 function resolveAuth(auth) {
@@ -32693,12 +33292,12 @@ function resolveAuth(auth) {
   const encoded = Buffer.from(`${username}:${password}`).toString("base64");
   return { Authorization: `Basic ${encoded}` };
 }
-function sortKeys(value) {
-  if (Array.isArray(value)) return value.map(sortKeys);
+function sortKeys2(value) {
+  if (Array.isArray(value)) return value.map(sortKeys2);
   if (value !== null && typeof value === "object") {
     const sorted = {};
     for (const key of Object.keys(value).sort()) {
-      sorted[key] = sortKeys(value[key]);
+      sorted[key] = sortKeys2(value[key]);
     }
     return sorted;
   }
@@ -32710,8 +33309,8 @@ function hasChanged(strategy, prev, curr) {
       return prev.status !== curr.status;
     case "json-diff":
       try {
-        const prevJson = JSON.stringify(sortKeys(JSON.parse(prev.body)));
-        const currJson = JSON.stringify(sortKeys(JSON.parse(curr.body)));
+        const prevJson = JSON.stringify(sortKeys2(JSON.parse(prev.body)));
+        const currJson = JSON.stringify(sortKeys2(JSON.parse(curr.body)));
         return prevJson !== currJson;
       } catch {
         return prev.body !== curr.body;
@@ -32750,7 +33349,37 @@ var scopeSchema2 = {
         strategy: {
           type: "string",
           enum: ["json-diff", "text-diff", "status-code"]
+        },
+        // Keyed-collection mode (003 §12). The `collection` block is only valid
+        // under `strategy: json-diff`; the `if/then` below enforces that at
+        // authoring time (BP3).
+        collection: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: 'Dotted path to the array within the parsed JSON (e.g. "tasks" or "$.tasks")'
+            },
+            key: {
+              type: "string",
+              description: "Field on each element used as the per-object identity"
+            },
+            "ignore-paths": {
+              type: "array",
+              items: { type: "string" },
+              description: 'Dotted paths (relative to each element, e.g. "fetchedAt" or "$.fetchedAt") removed before comparison'
+            }
+          },
+          required: ["path", "key"]
         }
+      },
+      // BP3: change-detection.collection requires strategy: json-diff. Under any
+      // other strategy (or the defaulted text-diff), presence of `collection` is an
+      // authoring-time error.
+      if: { required: ["collection"] },
+      then: {
+        properties: { strategy: { const: "json-diff" } },
+        required: ["strategy"]
       }
     }
   },
@@ -32761,15 +33390,30 @@ var source2 = {
   stateful: true,
   scopeSchema: scopeSchema2,
   async observe(config2, context = { now: /* @__PURE__ */ new Date() }) {
-    const { url, auth, headers, method, changeDetection } = parseScopeConfig2(config2);
+    const { url, auth, headers, method, changeDetection, collection } = parseScopeConfig2(config2);
     const authHeaders = resolveAuth(auth);
     const response = await fetch(url, {
       method: method ?? "GET",
       headers: { ...authHeaders, ...headers }
     });
     const body = await response.text();
-    const curr = { body, status: response.status };
     const prev = context.previousState && typeof context.previousState === "object" && !Array.isArray(context.previousState) ? context.previousState : void 0;
+    if (collection) {
+      const result = diffKeyedCollection(
+        JSON.parse(body),
+        collection,
+        url,
+        prev?.keyedSnapshot,
+        { payload: { url }, queryScope: { url } }
+      );
+      const curr2 = {
+        body,
+        status: response.status,
+        keyedSnapshot: result.snapshot
+      };
+      return { observations: result.observations, nextState: curr2 };
+    }
+    const curr = { body, status: response.status };
     if (prev !== void 0 && hasChanged(changeDetection, prev, curr)) {
       return {
         observations: [
@@ -32804,9 +33448,425 @@ var source2 = {
 };
 var index_default2 = source2;
 
-// ../../plugins/source-schedule/dist/index.js
+// ../../plugins/source-command-poll/dist/index.js
 init_cjs_shims();
+var import_child_process = require("child_process");
+var DEFAULT_TIMEOUT_MS = 3e4;
+var SIGKILL_GRACE_MS = 5e3;
+var STDOUT_CAP_BYTES = 1024 * 1024;
+var STDERR_TAIL_CHARS = 2e3;
 function parseScopeConfig3(config2) {
+  const command = config2["command"];
+  if (!Array.isArray(command) || command.length === 0 || !command.every((c) => typeof c === "string")) {
+    throw new Error(
+      'scope.command must be a non-empty array of strings (argv form, e.g. ["git", "status"])'
+    );
+  }
+  const cd = config2["change-detection"];
+  const rawStrategy = cd?.strategy;
+  const strategy = rawStrategy === "json-diff" || rawStrategy === "exit-code" ? rawStrategy : "text-diff";
+  const ignorePaths = parseTopLevelIgnorePaths(cd);
+  if (ignorePaths.length > 0 && strategy !== "json-diff") {
+    throw new Error(
+      "change-detection.ignore-paths requires strategy: json-diff"
+    );
+  }
+  const collection = parseKeyedCollectionConfig(config2["change-detection"]);
+  if (collection && strategy !== "json-diff") {
+    throw new Error("change-detection.collection requires strategy: json-diff");
+  }
+  const cwd = typeof config2["cwd"] === "string" ? config2["cwd"] : void 0;
+  const rawEnv = config2["env"];
+  const env = rawEnv !== null && typeof rawEnv === "object" && !Array.isArray(rawEnv) && Object.values(rawEnv).every((v) => typeof v === "string") ? rawEnv : void 0;
+  const rawTimeout = config2["timeout"];
+  const timeoutMs = typeof rawTimeout === "string" ? parseDuration(rawTimeout) : DEFAULT_TIMEOUT_MS;
+  const key = config2["key"];
+  const objectKey = typeof key === "string" && key.length > 0 ? key : command.join(" ");
+  return {
+    command,
+    cwd,
+    env,
+    timeoutMs,
+    objectKey,
+    strategy,
+    ignorePaths,
+    collection
+  };
+}
+async function runCommand(scope) {
+  return new Promise((resolve) => {
+    const [file, ...args] = scope.command;
+    const child = (0, import_child_process.execFile)(
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      file,
+      args,
+      {
+        cwd: scope.cwd,
+        // `env` is merged over the inherited daemon environment (003 §11.1).
+        env: scope.env ? { ...process.env, ...scope.env } : process.env,
+        // We enforce the timeout ourselves (SIGTERM→SIGKILL) rather than relying on
+        // execFile's `timeout`, so the grace escalation matches the spec exactly.
+        shell: false,
+        // Bound stdout capture at the 1 MiB cap (003 §11.2). When the child overruns,
+        // execFile kills it and reports ERR_CHILD_PROCESS_STDIO_MAXBUFFER with the
+        // captured-so-far bytes — we treat that as a truncated result, not a failure.
+        maxBuffer: STDOUT_CAP_BYTES,
+        encoding: "buffer"
+      },
+      (error2, stdoutBuf, stderrBuf) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(killTimer);
+        clearTimeout(graceTimer);
+        const stderrFull = stderrBuf instanceof Buffer ? stderrBuf.toString("utf8") : "";
+        const stderrTail = stderrFull.slice(-STDERR_TAIL_CHARS);
+        const err = error2;
+        const overflowed = err?.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+        if (timedOut) {
+          resolve({
+            kind: "failure",
+            error: `Command timed out after ${String(scope.timeoutMs)}ms`,
+            stderrTail
+          });
+          return;
+        }
+        if (err !== null && typeof err.code === "string" && !overflowed) {
+          resolve({
+            kind: "failure",
+            error: err.message,
+            stderrTail
+          });
+          return;
+        }
+        const buf = Buffer.isBuffer(stdoutBuf) ? stdoutBuf : Buffer.from(String(stdoutBuf), "utf8");
+        const { text: text2, truncated } = capStdout(buf, overflowed);
+        const exitCode = err != null && typeof err.code === "number" ? err.code : 0;
+        resolve({
+          kind: "result",
+          result: { stdout: text2, exitCode, truncated }
+        });
+      }
+    );
+    let settled = false;
+    let timedOut = false;
+    let graceTimer;
+    const killTimer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      graceTimer = setTimeout(() => {
+        child.kill("SIGKILL");
+      }, SIGKILL_GRACE_MS);
+      graceTimer.unref();
+    }, scope.timeoutMs);
+    killTimer.unref();
+  });
+}
+function capStdout(stdout, overflowed) {
+  const truncated = overflowed || stdout.length > STDOUT_CAP_BYTES;
+  const slice = stdout.length > STDOUT_CAP_BYTES ? stdout.subarray(0, STDOUT_CAP_BYTES) : stdout;
+  return { text: slice.toString("utf8"), truncated };
+}
+function sortKeys3(value) {
+  if (Array.isArray(value)) return value.map(sortKeys3);
+  if (value !== null && typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      sorted[key] = sortKeys3(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function parseTopLevelIgnorePaths(changeDetection) {
+  const rawIgnorePaths = changeDetection?.["ignore-paths"];
+  if (rawIgnorePaths === void 0) return [];
+  if (!Array.isArray(rawIgnorePaths) || !rawIgnorePaths.every((entry) => typeof entry === "string")) {
+    throw new Error(
+      "change-detection.ignore-paths must be an array of strings"
+    );
+  }
+  return rawIgnorePaths;
+}
+function normalizeJsonPath(path13) {
+  if (path13 === "$" || path13.startsWith("$.")) return path13;
+  return `$.${path13}`;
+}
+function assertValidJsonPathSegment(path13, segment) {
+  if (segment.length === 0) {
+    throw new Error(
+      `Invalid change-detection.ignore-paths entry "${path13}": empty path segment`
+    );
+  }
+  if (/[.[\]*?]/.test(segment)) {
+    throw new Error(
+      `Invalid change-detection.ignore-paths entry "${path13}": unsupported path segment "${segment}"`
+    );
+  }
+}
+function stripIgnoredJsonPaths(value, ignorePaths) {
+  if (ignorePaths.length === 0) return value;
+  const cloned = structuredClone(value);
+  for (const path13 of ignorePaths) {
+    removeJsonPath(cloned, path13);
+  }
+  return cloned;
+}
+function removeJsonPath(value, path13) {
+  const normalizedPath = normalizeJsonPath(path13);
+  if (normalizedPath === "$") return;
+  const segments = normalizedPath.slice(2).split(".");
+  let current = value;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = segments[i];
+    assertValidJsonPathSegment(path13, segment ?? "");
+    if (current === null || typeof current !== "object") return;
+    if (!Object.hasOwn(current, segment ?? "")) return;
+    current = current[segment ?? ""];
+  }
+  const last = segments.at(-1) ?? "";
+  assertValidJsonPathSegment(path13, last);
+  if (current !== null && typeof current === "object") {
+    Reflect.deleteProperty(current, last);
+  }
+}
+function hasChanged2(strategy, ignorePaths, prev, curr) {
+  switch (strategy) {
+    case "exit-code":
+      return prev.exitCode !== curr.exitCode;
+    case "json-diff": {
+      let prevParsed;
+      let currParsed;
+      try {
+        prevParsed = JSON.parse(prev.stdout);
+        currParsed = JSON.parse(curr.stdout);
+      } catch {
+        return prev.stdout !== curr.stdout;
+      }
+      return JSON.stringify(
+        sortKeys3(stripIgnoredJsonPaths(prevParsed, ignorePaths))
+      ) !== JSON.stringify(sortKeys3(stripIgnoredJsonPaths(currParsed, ignorePaths)));
+    }
+    case "text-diff":
+      return prev.stdout !== curr.stdout;
+  }
+}
+function isCommandState(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const v = value;
+  return typeof v["stdout"] === "string" && typeof v["exitCode"] === "number" && typeof v["truncated"] === "boolean" && (v["health"] === "ok" || v["health"] === "failing") && typeof v["baselined"] === "boolean";
+}
+function changedObservation(scope, result) {
+  return {
+    title: `Command output changed: ${scope.objectKey}`,
+    summary: `Command output changed: ${scope.objectKey}`,
+    payload: {
+      command: scope.command,
+      exitCode: result.exitCode,
+      strategy: scope.strategy,
+      stdout: result.stdout,
+      truncated: result.truncated
+    },
+    snapshotText: result.stdout,
+    objectKey: scope.objectKey,
+    queryScope: { command: scope.objectKey },
+    snapshot: {
+      command: scope.command,
+      exitCode: result.exitCode,
+      stdoutLength: result.stdout.length,
+      strategy: scope.strategy
+    },
+    changeKind: "modified"
+  };
+}
+var scopeSchema3 = {
+  type: "object",
+  properties: {
+    command: {
+      type: "array",
+      items: { type: "string" },
+      minItems: 1,
+      description: "Argv array; command[0] is the executable (resolved via PATH). Spawned directly, never via a shell."
+    },
+    cwd: {
+      type: "string",
+      description: "Working directory for the child process"
+    },
+    env: {
+      type: "object",
+      additionalProperties: { type: "string" },
+      description: "Literal env vars merged over the inherited daemon environment"
+    },
+    timeout: {
+      type: "string",
+      pattern: "^\\d+[smhd]$",
+      description: 'Wall-clock limit (e.g. "30s"). Expiry is an execution failure.'
+    },
+    key: {
+      type: "string",
+      description: "Overrides the observation objectKey (defaults to the joined argv)"
+    },
+    interval: {
+      type: "string",
+      pattern: "^\\d+[smhd]$",
+      description: 'Polling interval (e.g., "5m"). Used by the scheduling engine, not by this plugin directly.'
+    },
+    "change-detection": {
+      type: "object",
+      properties: {
+        strategy: {
+          type: "string",
+          enum: ["text-diff", "json-diff", "exit-code"]
+        },
+        // Keyed-collection mode (003 §12). The `collection` block is only valid
+        // under `strategy: json-diff`; the `if/then` below enforces that at
+        // authoring time (BP3).
+        collection: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: 'Dotted path to the array within the parsed JSON (e.g. "tasks" or "$.tasks")'
+            },
+            key: {
+              type: "string",
+              description: "Field on each element used as the per-object identity"
+            },
+            "ignore-paths": {
+              type: "array",
+              items: { type: "string" },
+              description: 'Dotted paths (relative to each element, e.g. "fetchedAt" or "$.fetchedAt") removed before comparison'
+            }
+          },
+          required: ["path", "key"],
+          additionalProperties: false
+        },
+        "ignore-paths": {
+          type: "array",
+          items: { type: "string" },
+          description: "Dotted paths removed from parsed JSON before plain json-diff comparison"
+        }
+      },
+      additionalProperties: false,
+      // BP3: change-detection.collection requires strategy: json-diff. Under any
+      // other strategy (or the defaulted text-diff), presence of `collection` is an
+      // authoring-time error.
+      allOf: [
+        {
+          if: { required: ["collection"] },
+          then: {
+            properties: { strategy: { const: "json-diff" } },
+            required: ["strategy"]
+          }
+        },
+        {
+          if: { required: ["ignore-paths"] },
+          then: {
+            properties: { strategy: { const: "json-diff" } },
+            required: ["strategy"]
+          }
+        }
+      ]
+    }
+  },
+  required: ["command"]
+};
+var source3 = {
+  name: "command-poll",
+  stateful: true,
+  scopeSchema: scopeSchema3,
+  async observe(config2, context = { now: /* @__PURE__ */ new Date() }) {
+    const scope = parseScopeConfig3(config2);
+    const prev = isCommandState(context.previousState) ? context.previousState : void 0;
+    const outcome = await runCommand(scope);
+    if (outcome.kind === "failure") {
+      const wasFailing = prev?.health === "failing";
+      const nextState2 = {
+        stdout: prev?.stdout ?? "",
+        exitCode: prev?.exitCode ?? 0,
+        truncated: prev?.truncated ?? false,
+        health: "failing",
+        baselined: prev?.baselined ?? false,
+        // Carry the keyed baseline forward untouched so recovery diffs against it.
+        ...prev?.keyedSnapshot ? { keyedSnapshot: prev.keyedSnapshot } : {}
+      };
+      return {
+        observations: wasFailing ? [] : [failingObservation(scope, outcome)],
+        nextState: nextState2
+      };
+    }
+    const result = outcome.result;
+    const recovered = prev?.health === "failing";
+    const hadBaseline = prev?.baselined ?? false;
+    const observations = [];
+    if (recovered) {
+      observations.push(recoveredObservation(scope));
+    }
+    if (scope.collection) {
+      const result2 = diffKeyedCollection(
+        JSON.parse(result.stdout),
+        scope.collection,
+        scope.objectKey,
+        hadBaseline ? prev?.keyedSnapshot : void 0,
+        {
+          payload: { command: scope.command },
+          queryScope: { command: scope.objectKey }
+        }
+      );
+      observations.push(...result2.observations);
+      const nextState2 = {
+        stdout: result.stdout,
+        exitCode: result.exitCode,
+        truncated: result.truncated,
+        health: "ok",
+        baselined: true,
+        keyedSnapshot: result2.snapshot
+      };
+      return { observations, nextState: nextState2 };
+    }
+    const nextState = {
+      stdout: result.stdout,
+      exitCode: result.exitCode,
+      truncated: result.truncated,
+      health: "ok",
+      baselined: true
+    };
+    if (prev !== void 0 && hadBaseline && hasChanged2(scope.strategy, scope.ignorePaths, prev, result)) {
+      observations.push(changedObservation(scope, result));
+    }
+    return { observations, nextState };
+  }
+};
+function failingObservation(scope, outcome) {
+  return {
+    title: `Command failing: ${scope.objectKey}`,
+    summary: `Command failing: ${scope.objectKey}`,
+    payload: {
+      command: scope.command,
+      error: outcome.error,
+      stderrTail: outcome.stderrTail
+    },
+    objectKey: scope.objectKey,
+    queryScope: { command: scope.objectKey },
+    changeKind: "modified"
+  };
+}
+function recoveredObservation(scope) {
+  return {
+    title: `Command recovered: ${scope.objectKey}`,
+    summary: `Command recovered: ${scope.objectKey}`,
+    payload: { command: scope.command },
+    objectKey: scope.objectKey,
+    queryScope: { command: scope.objectKey },
+    changeKind: "modified"
+  };
+}
+var index_default3 = source3;
+
+// ../../plugins/source-schedule/dist/index.js
+init_cjs_shims();
+function parseScopeConfig4(config2) {
   const cron = config2["cron"];
   if (typeof cron !== "string") {
     throw new Error("scope.cron must be a string");
@@ -32817,7 +33877,7 @@ function parseScopeConfig3(config2) {
     label: typeof config2["label"] === "string" ? config2["label"] : void 0
   };
 }
-var scopeSchema3 = {
+var scopeSchema4 = {
   type: "object",
   properties: {
     cron: {
@@ -32835,11 +33895,11 @@ var scopeSchema3 = {
   },
   required: ["cron"]
 };
-var source3 = {
+var source4 = {
   name: "schedule",
-  scopeSchema: scopeSchema3,
+  scopeSchema: scopeSchema4,
   observe(config2, context = { now: /* @__PURE__ */ new Date() }) {
-    const { cron, timezone, label } = parseScopeConfig3(config2);
+    const { cron, timezone, label } = parseScopeConfig4(config2);
     return Promise.resolve({
       observations: [
         {
@@ -32861,12 +33921,12 @@ var source3 = {
     });
   }
 };
-var index_default3 = source3;
+var index_default4 = source4;
 
 // ../../plugins/source-incoming-changes/dist/index.js
 init_cjs_shims();
-var import_child_process = require("child_process");
-function parseScopeConfig4(config2) {
+var import_child_process2 = require("child_process");
+function parseScopeConfig5(config2) {
   const paths = config2["paths"];
   if (!Array.isArray(paths) || !paths.every((p) => typeof p === "string")) {
     throw new Error("scope.paths must be an array of strings");
@@ -32882,7 +33942,7 @@ var MAX_BUFFER = 64 * 1024 * 1024;
 function tryResolveCurrentRef(cwd, branch) {
   const ref = branch ?? "HEAD";
   try {
-    const raw = (0, import_child_process.execFileSync)("git", ["rev-parse", "--end-of-options", ref], {
+    const raw = (0, import_child_process2.execFileSync)("git", ["rev-parse", "--end-of-options", ref], {
       cwd,
       encoding: "utf-8",
       maxBuffer: MAX_BUFFER
@@ -32907,7 +33967,7 @@ function tryGetDiffEntries(cwd, fromRef, toRef, paths) {
   ];
   let output;
   try {
-    output = (0, import_child_process.execFileSync)("git", args, {
+    output = (0, import_child_process2.execFileSync)("git", args, {
       cwd,
       encoding: "buffer",
       maxBuffer: MAX_BUFFER
@@ -32943,7 +34003,7 @@ function tryGetDiffEntries(cwd, fromRef, toRef, paths) {
 }
 function getFileContent(cwd, ref, filePath2) {
   try {
-    const content = (0, import_child_process.execFileSync)("git", ["show", `${ref}:${filePath2}`], {
+    const content = (0, import_child_process2.execFileSync)("git", ["show", `${ref}:${filePath2}`], {
       cwd,
       encoding: "buffer",
       maxBuffer: MAX_BUFFER
@@ -32985,7 +34045,7 @@ function buildObservation(entry, fromRef, toRef, cwd) {
   }
   return observation;
 }
-var scopeSchema4 = {
+var scopeSchema5 = {
   $schema: "http://json-schema.org/draft-07/schema#",
   type: "object",
   properties: {
@@ -33010,13 +34070,13 @@ var scopeSchema4 = {
   },
   required: ["paths"]
 };
-var source4 = {
+var source5 = {
   name: "incoming-changes",
   stateful: true,
-  scopeSchema: scopeSchema4,
+  scopeSchema: scopeSchema5,
   observe(config2, context = { now: /* @__PURE__ */ new Date() }) {
     try {
-      const { paths, branch, cwd } = parseScopeConfig4(config2);
+      const { paths, branch, cwd } = parseScopeConfig5(config2);
       const currentRef = tryResolveCurrentRef(cwd, branch);
       if (currentRef === void 0) {
         return Promise.resolve({ observations: [] });
@@ -33056,7 +34116,7 @@ var source4 = {
     }
   }
 };
-var index_default4 = source4;
+var index_default5 = source5;
 
 // src/sources.ts
 function registerCoreSources(registry2) {
@@ -33064,6 +34124,7 @@ function registerCoreSources(registry2) {
   registry2.register(index_default2);
   registry2.register(index_default3);
   registry2.register(index_default4);
+  registry2.register(index_default5);
 }
 
 // src/validation.ts
@@ -33104,6 +34165,33 @@ function requireDirectory(dirPath, json) {
 }
 
 // src/commands/validate.ts
+function changeDetectionCollectionError(watchConfig2) {
+  const cd = watchConfig2["change-detection"];
+  if (cd === null || typeof cd !== "object" || Array.isArray(cd))
+    return void 0;
+  const cdObj = cd;
+  if (cdObj["collection"] === void 0) return void 0;
+  const strategy = cdObj["strategy"];
+  if (strategy === "json-diff") return void 0;
+  return "change-detection.collection requires strategy: json-diff";
+}
+function oldSourceScopeShapeHint(filePath2) {
+  let content;
+  try {
+    content = (0, import_node_fs3.readFileSync)(filePath2, "utf-8");
+  } catch {
+    return null;
+  }
+  const normalised = content.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
+  const frontmatter = /^---\n(?<frontmatter>[\s\S]*?)\n---/.exec(normalised)?.groups?.["frontmatter"];
+  if (!frontmatter) return null;
+  const rawSource = /^source:\s*(?<source>[^\n#]+)/m.exec(frontmatter)?.groups?.["source"];
+  const source6 = rawSource?.trim().replace(/^['"]|['"]$/g, "");
+  const hasScope = /^scope\s*:/m.test(frontmatter);
+  const hasWatch = /^watch\s*:/m.test(frontmatter);
+  if (!source6 || !hasScope || hasWatch) return null;
+  return `did you mean to use the current watch shape? Move source/scope into watch:, for example: watch: { type: ${source6}, ... }`;
+}
 var validateCommand = new Command("validate").description("Validate MONITOR.md files in a directory").argument("[path]", "Path to monitors directory", ".claude/monitors").addOption(
   new Option("--format <format>", "Output format").choices(["text", "json"]).default("text")
 ).action(async (monitorPath, options2) => {
@@ -33114,8 +34202,8 @@ var validateCommand = new Command("validate").description("Validate MONITOR.md f
   const scopeErrors = [];
   const validMonitors = result.monitors.filter((m) => {
     const sourceName = m.monitor.frontmatter.watch.type;
-    const source5 = registry2.get(sourceName);
-    if (!source5) {
+    const source6 = registry2.get(sourceName);
+    if (!source6) {
       scopeErrors.push({
         id: m.monitor.id,
         errors: [
@@ -33125,21 +34213,23 @@ var validateCommand = new Command("validate").description("Validate MONITOR.md f
       return false;
     }
     const { type: _type, ...watchConfig2 } = m.monitor.frontmatter.watch;
-    const errors = validateScope(watchConfig2, source5.scopeSchema);
-    if (errors.length > 0) {
-      scopeErrors.push({ id: m.monitor.id, errors });
+    const errors = validateScope(watchConfig2, source6.scopeSchema);
+    const collectionError = changeDetectionCollectionError(watchConfig2);
+    const allScopeErrors = collectionError ? [collectionError, ...errors.filter((e) => !e.includes("then"))] : errors;
+    if (allScopeErrors.length > 0) {
+      scopeErrors.push({ id: m.monitor.id, errors: allScopeErrors });
       return false;
     }
     return true;
   });
   const duplicateErrors = result.duplicateIds.map((dup) => ({
     filePath: dup.filePaths.join(", "),
-    error: `Duplicate monitor id "${dup.id}" \u2014 ids are derived from folder names and must be unique within a tree`
+    error: `Duplicate monitor id "${dup.id}" -- ids are derived from folder names and must be unique within a tree`
   }));
   const allErrors = [
     ...result.errors.map((e) => ({
       filePath: e.filePath,
-      error: e.error
+      error: [e.error, oldSourceScopeShapeHint(e.filePath)].filter(Boolean).join("; ")
     })),
     ...scopeErrors.map((e) => ({
       filePath: e.id,
@@ -33389,19 +34479,14 @@ inboxCommand.command("archive").description("Archive a completed or failed inbox
 
 // src/commands/monitor-test.ts
 init_cjs_shims();
-var import_node_fs4 = require("fs");
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_fs5 = require("fs");
 var import_promises4 = require("timers/promises");
 
-// src/runtime-client.ts
-init_cjs_shims();
-
-// src/runtime.ts
-init_cjs_shims();
-
 // src/daemon-ipc.ts
 init_cjs_shims();
 var import_node_crypto = require("crypto");
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_os2 = require("os");
 var import_node_path4 = __toESM(require("path"), 1);
 var import_node_net = __toESM(require("net"), 1);
@@ -33424,6 +34509,7 @@ var daemonMethodSchema = external_exports.enum([
   "events.ack",
   "hook.claim",
   "history.list",
+  "monitor.explain",
   "daemon.tick"
 ]);
 var daemonResponseSchema = external_exports.object({
@@ -33472,6 +34558,13 @@ var historyListParamsSchema = external_exports.object({
   monitorId: external_exports.string().optional(),
   limit: external_exports.number().int().positive().optional()
 });
+var monitorExplainParamsSchema = external_exports.object({
+  monitorId: external_exports.string(),
+  monitorsDir: external_exports.string(),
+  workspacePath: external_exports.string().optional(),
+  historyLimit: external_exports.number().int().positive().optional(),
+  eventLimit: external_exports.number().int().positive().optional()
+});
 var daemonTickParamsSchema = external_exports.object({
   monitorsDir: external_exports.string(),
   workspacePath: external_exports.string().optional()
@@ -33481,6 +34574,13 @@ var daemonRequestSchema = external_exports.object({
   method: daemonMethodSchema,
   params: external_exports.record(external_exports.string(), external_exports.unknown())
 });
+var DaemonConnectionError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+  }
+  name = "DaemonConnectionError";
+};
 function isErrnoException(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2;
 }
@@ -33501,7 +34601,7 @@ function resolveSocketPath(overridePath) {
 }
 function cleanupSocket(socketPath) {
   try {
-    (0, import_node_fs3.rmSync)(socketPath);
+    (0, import_node_fs4.rmSync)(socketPath);
   } catch (error2) {
     const code = isErrnoException(error2) ? String(error2.code) : "";
     if (code !== "ENOENT") throw error2;
@@ -33542,8 +34642,8 @@ function acquireStartupLock(socketPath) {
   const pidFile = import_node_path4.default.join(lock, "pid");
   const tryMkdir = () => {
     try {
-      (0, import_node_fs3.mkdirSync)(lock);
-      (0, import_node_fs3.writeFileSync)(pidFile, String(process.pid), "utf-8");
+      (0, import_node_fs4.mkdirSync)(lock);
+      (0, import_node_fs4.writeFileSync)(pidFile, String(process.pid), "utf-8");
       return true;
     } catch (err) {
       if (!isErrnoException(err) || err.code !== "EEXIST") throw err;
@@ -33553,7 +34653,7 @@ function acquireStartupLock(socketPath) {
   if (tryMkdir()) return true;
   let holderPid;
   try {
-    holderPid = parseInt((0, import_node_fs3.readFileSync)(pidFile, "utf-8"), 10);
+    holderPid = parseInt((0, import_node_fs4.readFileSync)(pidFile, "utf-8"), 10);
   } catch {
     return false;
   }
@@ -33574,11 +34674,11 @@ function acquireStartupLock(socketPath) {
     return false;
   }
   try {
-    (0, import_node_fs3.unlinkSync)(pidFile);
+    (0, import_node_fs4.unlinkSync)(pidFile);
   } catch {
   }
   try {
-    (0, import_node_fs3.rmdirSync)(lock);
+    (0, import_node_fs4.rmdirSync)(lock);
   } catch {
   }
   return tryMkdir();
@@ -33587,11 +34687,11 @@ function releaseStartupLock(socketPath) {
   const lock = lockPath(socketPath);
   const pidFile = import_node_path4.default.join(lock, "pid");
   try {
-    (0, import_node_fs3.unlinkSync)(pidFile);
+    (0, import_node_fs4.unlinkSync)(pidFile);
   } catch {
   }
   try {
-    (0, import_node_fs3.rmdirSync)(lock);
+    (0, import_node_fs4.rmdirSync)(lock);
   } catch {
   }
 }
@@ -33662,6 +34762,16 @@ function handleRequest(runtime, request, stop) {
         })
       );
     }
+    case "monitor.explain": {
+      const params = monitorExplainParamsSchema.parse(request.params);
+      return runtime.explainMonitor({
+        monitorId: params.monitorId,
+        monitorsDir: params.monitorsDir,
+        ...params.workspacePath ? { workspacePath: params.workspacePath } : {},
+        ...params.historyLimit ? { historyLimit: params.historyLimit } : {},
+        ...params.eventLimit ? { eventLimit: params.eventLimit } : {}
+      });
+    }
     case "daemon.tick": {
       const params = daemonTickParamsSchema.parse(request.params);
       return runtime.tick(params.monitorsDir, params.workspacePath);
@@ -33673,7 +34783,7 @@ function createDaemonServer({
   socketPath,
   onStop
 }) {
-  (0, import_node_fs3.mkdirSync)(import_node_path4.default.dirname(socketPath), { recursive: true });
+  (0, import_node_fs4.mkdirSync)(import_node_path4.default.dirname(socketPath), { recursive: true });
   let serverClosed = false;
   const server = import_node_net.default.createServer((socket) => {
     let buffer = "";
@@ -33731,7 +34841,7 @@ function createDaemonServer({
         const live = await probeSocket(socketPath);
         if (!live) {
           try {
-            (0, import_node_fs3.unlinkSync)(socketPath);
+            (0, import_node_fs4.unlinkSync)(socketPath);
           } catch (unlinkErr) {
             const code = isErrnoException(unlinkErr) ? String(unlinkErr.code) : "";
             if (code !== "ENOENT") throw unlinkErr;
@@ -33797,11 +34907,20 @@ async function callDaemon(method, params = {}, options2 = {}) {
       });
     };
     socket.setTimeout(timeoutMs, () => {
-      fail(new Error(`Timed out waiting for AgentMon daemon at ${socketPath}`));
+      fail(
+        new DaemonConnectionError(
+          `Timed out waiting for AgentMon daemon at ${socketPath}`
+        )
+      );
     });
     socket.setEncoding("utf-8");
     socket.on("error", (error2) => {
-      fail(error2);
+      fail(
+        new DaemonConnectionError(
+          error2 instanceof Error ? error2.message : String(error2),
+          error2
+        )
+      );
     });
     socket.on("data", (chunk) => {
       buffer += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
@@ -33842,7 +34961,11 @@ async function daemonAvailable(socketPath) {
   }
 }
 
+// src/runtime-client.ts
+init_cjs_shims();
+
 // src/runtime.ts
+init_cjs_shims();
 function createRuntime(dbPath = resolveDbPath()) {
   const db = createDb(dbPath);
   const registry2 = new SourceRegistry();
@@ -33905,6 +35028,13 @@ async function listObservationHistoryClient(query, socketPath) {
     socketPath ? { socketPath } : {}
   );
 }
+async function explainMonitorClient(input, socketPath) {
+  return await callDaemon(
+    "monitor.explain",
+    input,
+    socketPath ? { socketPath } : {}
+  );
+}
 async function daemonStatusClient(socketPath) {
   return await callDaemon(
     "status",
@@ -33921,6 +35051,127 @@ async function daemonTickClient(monitorsDir, workspacePath) {
 var monitorTestCommand = new Command("monitor").description(
   "Monitor utilities"
 );
+var EXPLAIN_STAGE_LABELS2 = {
+  definition: "Definition",
+  scheduling: "Scheduling",
+  observation: "Observation",
+  notify: "Notify state",
+  materialization: "Materialization",
+  delivery: "Projection and delivery"
+};
+function monitorIdFromFilePath2(filePath2) {
+  const base = import_node_path5.default.basename(filePath2);
+  return base === "MONITOR.md" ? import_node_path5.default.basename(import_node_path5.default.dirname(filePath2)) : import_node_path5.default.parse(filePath2).name;
+}
+function explainStage2(id, status, reason, details) {
+  return {
+    id,
+    label: EXPLAIN_STAGE_LABELS2[id],
+    status,
+    reason,
+    ...details ? { details } : {}
+  };
+}
+function explainVerdict2(stages) {
+  const stopped = stages.find((stage2) => stage2.status !== "ok");
+  const stage = stopped ?? stages[stages.length - 1];
+  return {
+    status: stage?.status ?? "ok",
+    stage: stage?.id ?? "delivery",
+    reason: stage?.reason ?? "Monitor delivered successfully."
+  };
+}
+function statusGlyph(status) {
+  if (status === "ok") return "\u2713";
+  if (status === "pending") return "\u23F3";
+  if (status === "healthy") return "\u25CB";
+  return "\u2717";
+}
+function printExplainText(report) {
+  console.log(`Monitor ${report.monitorId}`);
+  for (const stage of report.stages) {
+    console.log(`${statusGlyph(stage.status)} ${stage.label}: ${stage.reason}`);
+  }
+  console.log(
+    `Verdict: ${report.verdict.status} at ${EXPLAIN_STAGE_LABELS2[report.verdict.stage]} - ${report.verdict.reason}`
+  );
+}
+async function buildDaemonUnavailableReport(input) {
+  const generatedAt = /* @__PURE__ */ new Date();
+  const stages = [];
+  const scan = await scanMonitors(input.monitorsDir);
+  const parseError = scan.errors.find(
+    (error2) => monitorIdFromFilePath2(error2.filePath) === input.monitorId
+  );
+  const monitor = scan.monitors.find(
+    (candidate) => candidate.monitor.id === input.monitorId
+  )?.monitor;
+  if (parseError) {
+    stages.push(
+      explainStage2(
+        "definition",
+        "failure",
+        `MONITOR.md failed to parse or validate: ${parseError.error}`,
+        { filePath: parseError.filePath }
+      )
+    );
+  } else if (!monitor) {
+    stages.push(
+      explainStage2(
+        "definition",
+        "failure",
+        `Monitor "${input.monitorId}" was not found in ${input.monitorsDir}.`
+      )
+    );
+  } else {
+    const registry2 = new SourceRegistry();
+    registerCoreSources(registry2);
+    const sourceName = monitor.frontmatter.watch.type;
+    const source6 = registry2.get(sourceName);
+    const { type: _type, ...monitorWatchConfig } = monitor.frontmatter.watch;
+    const scopeErrors = source6 ? validateScope(monitorWatchConfig, source6.scopeSchema) : [`Unknown source "${sourceName}".`];
+    stages.push(
+      scopeErrors.length === 0 ? explainStage2("definition", "ok", "Monitor definition is valid.", {
+        filePath: monitor.filePath,
+        sourceName
+      }) : explainStage2(
+        "definition",
+        "failure",
+        `Monitor definition is invalid: ${scopeErrors.join("; ")}`,
+        { filePath: monitor.filePath, sourceName }
+      )
+    );
+  }
+  if (stages[0]?.status === "ok") {
+    stages.push(
+      explainStage2(
+        "scheduling",
+        "failure",
+        `The daemon is not running or unreachable: ${input.errorMessage}`,
+        { workspacePath: input.workspacePath }
+      )
+    );
+  }
+  return {
+    monitorId: input.monitorId,
+    generatedAt,
+    ...monitor ? {
+      monitor: {
+        id: monitor.id,
+        displayName: monitor.displayName,
+        filePath: monitor.filePath,
+        sourceName: monitor.frontmatter.watch.type,
+        urgency: monitor.frontmatter.urgency
+      }
+    } : {},
+    stages,
+    verdict: explainVerdict2(stages),
+    observations: [],
+    events: [],
+    projections: [],
+    leadSessions: []
+  };
+}
 function printJsonResult(monitorName, sourceName, baseline, observations) {
   console.log(
     JSON.stringify(
@@ -33967,24 +35218,24 @@ function createFollowupObservationContext(context) {
     previousState: context.previousState
   };
 }
-async function handleStatefulSource(source5, scope, monitorName, json, context) {
+async function handleStatefulSource(source6, scope, monitorName, json, context) {
   if (!json) {
     console.log(
       `
-Baseline established. The "${source5.name}" source requires a prior baseline before it can detect changes.`
+Baseline established. The "${source6.name}" source requires a prior baseline before it can detect changes.`
     );
     console.log(
       "Running a second observation to demonstrate change detection...\n"
     );
   }
   await (0, import_promises4.setTimeout)(100);
-  const secondResult = await source5.observe(
+  const secondResult = await source6.observe(
     scope,
     createFollowupObservationContext(context)
   );
   const secondObservations = secondResult.observations;
   if (json) {
-    printJsonResult(monitorName, source5.name, true, secondObservations);
+    printJsonResult(monitorName, source6.name, true, secondObservations);
     return;
   }
   if (secondObservations.length > 0) {
@@ -33994,7 +35245,7 @@ Baseline established. The "${source5.name}" source requires a prior baseline bef
   console.log(
     "No changes detected since baseline. This is expected \u2014 both observations happened within the same command invocation."
   );
-  const messages = SOURCE_TEST_MESSAGES[source5.name] ?? DEFAULT_TEST_MESSAGES;
+  const messages = SOURCE_TEST_MESSAGES[source6.name] ?? DEFAULT_TEST_MESSAGES;
   for (const msg of messages) {
     console.log(`
 ${msg}`);
@@ -34004,13 +35255,13 @@ monitorTestCommand.command("test").description("Dry-run a monitor observation so
   new Option("--format <format>", "Output format").choices(["text", "json"]).default("text")
 ).action(async (filePath2, options2) => {
   const json = options2.format === "json";
-  if (!(0, import_node_fs4.existsSync)(filePath2)) {
+  if (!(0, import_node_fs5.existsSync)(filePath2)) {
     reportError(`Monitor file not found: ${filePath2}`, json);
     return;
   }
   let content;
   try {
-    content = (0, import_node_fs4.readFileSync)(filePath2, "utf-8");
+    content = (0, import_node_fs5.readFileSync)(filePath2, "utf-8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     reportError(`Cannot read monitor file: ${msg}`, json);
@@ -34023,8 +35274,8 @@ monitorTestCommand.command("test").description("Dry-run a monitor observation so
   }
   const registry2 = new SourceRegistry();
   registerCoreSources(registry2);
-  const source5 = registry2.get(result.monitor.frontmatter.watch.type);
-  if (!source5) {
+  const source6 = registry2.get(result.monitor.frontmatter.watch.type);
+  if (!source6) {
     reportError(
       `Unknown source: "${result.monitor.frontmatter.watch.type}". Available: ${registry2.names().join(", ")}`,
       json
@@ -34035,27 +35286,27 @@ monitorTestCommand.command("test").description("Dry-run a monitor observation so
   const { type: _type, ...monitorWatchConfig } = result.monitor.frontmatter.watch;
   if (!json) {
     console.log(
-      `Testing monitor "${monitorName}" (source: ${source5.name})...`
+      `Testing monitor "${monitorName}" (source: ${source6.name})...`
     );
   }
   try {
     let context = { now: /* @__PURE__ */ new Date() };
-    const firstResult = await source5.observe(monitorWatchConfig, context);
+    const firstResult = await source6.observe(monitorWatchConfig, context);
     const observations = firstResult.observations;
     context = {
       now: /* @__PURE__ */ new Date(),
       previousState: firstResult.nextState
     };
-    if (observations.length === 0 && source5.stateful) {
+    if (observations.length === 0 && source6.stateful) {
       await handleStatefulSource(
-        source5,
+        source6,
         monitorWatchConfig,
         monitorName,
         json,
         context
       );
     } else if (json) {
-      printJsonResult(monitorName, source5.name, false, observations);
+      printJsonResult(monitorName, source6.name, false, observations);
     } else if (observations.length === 0) {
       console.log("No observations produced.");
     } else {
@@ -34066,6 +35317,55 @@ monitorTestCommand.command("test").description("Dry-run a monitor observation so
     reportError(`Observation failed: ${message}`, json);
   }
 });
+monitorTestCommand.command("explain").description("Explain where a monitor's signal currently stops").argument("<monitorId>", "Monitor id to diagnose").option(
+  "--dir <path>",
+  "Directory containing monitor definitions",
+  ".claude/monitors"
+).option("--workspace <path>", "Workspace path used by the daemon").option("--socket <path>", "Unix domain socket path for the daemon").option("--history-limit <n>", "Observation history rows to include", "10").option("--event-limit <n>", "Materialized event rows to include", "10").addOption(
+  new Option("--format <format>", "Output format").choices(["text", "json"]).default("text")
+).action(
+  async (monitorId, options2) => {
+    const json = options2.format === "json";
+    const monitorsDir = import_node_path5.default.resolve(options2.dir);
+    const workspacePath = import_node_path5.default.resolve(options2.workspace ?? process.cwd());
+    const historyLimit = Number.parseInt(options2.historyLimit, 10);
+    const eventLimit = Number.parseInt(options2.eventLimit, 10);
+    try {
+      const report = await explainMonitorClient(
+        {
+          monitorId,
+          monitorsDir,
+          workspacePath,
+          ...Number.isFinite(historyLimit) && historyLimit > 0 ? { historyLimit } : {},
+          ...Number.isFinite(eventLimit) && eventLimit > 0 ? { eventLimit } : {}
+        },
+        options2.socket
+      );
+      if (json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+      }
+      printExplainText(report);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (!(err instanceof DaemonConnectionError)) {
+        reportError(`Explain failed: ${message}`, json);
+        return;
+      }
+      const report = await buildDaemonUnavailableReport({
+        monitorId,
+        monitorsDir,
+        workspacePath,
+        errorMessage: message
+      });
+      if (json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+      }
+      printExplainText(report);
+    }
+  }
+);
 monitorTestCommand.command("history").description(
   "Show recent observation outcomes per tick (triggered / suppressed / no-change / errored / rebaselined)"
 ).argument("[monitorId]", "Filter to a single monitor id").option("--socket <path>", "Unix domain socket path for the daemon").option("--limit <n>", "Maximum rows to return", "50").addOption(
@@ -34114,12 +35414,14 @@ sourceCommand.command("list").description("List installed observation sources").
   registerCoreSources(registry2);
   const sources = registry2.list();
   if (options2.format === "json") {
-    const output = sources.map((source5) => {
-      const requiredFields = source5.scopeSchema["required"] ?? [];
-      const properties = source5.scopeSchema["properties"] ?? {};
+    const output = sources.map((source6) => {
+      const requiredFields = source6.scopeSchema["required"] ?? [];
+      const properties = source6.scopeSchema["properties"] ?? {};
+      const configFields = Object.keys(properties);
       return {
-        name: source5.name,
-        scopeFields: Object.keys(properties),
+        name: source6.name,
+        configFields,
+        scopeFields: configFields,
         required: requiredFields
       };
     });
@@ -34131,11 +35433,11 @@ sourceCommand.command("list").description("List installed observation sources").
     return;
   }
   console.log("Installed sources:\n");
-  for (const source5 of sources) {
-    const requiredFields = source5.scopeSchema["required"] ?? [];
-    const properties = source5.scopeSchema["properties"] ?? {};
-    console.log(`  ${source5.name}`);
-    console.log(`    Scope fields: ${Object.keys(properties).join(", ")}`);
+  for (const source6 of sources) {
+    const requiredFields = source6.scopeSchema["required"] ?? [];
+    const properties = source6.scopeSchema["properties"] ?? {};
+    console.log(`  ${source6.name}`);
+    console.log(`    Config fields: ${Object.keys(properties).join(", ")}`);
     console.log(`    Required: ${requiredFields.join(", ") || "(none)"}`);
     console.log("");
   }
@@ -34432,15 +35734,15 @@ daemonCommand.command("stop").description("Ask the local AgentMon daemon to stop
 
 // src/commands/session.ts
 init_cjs_shims();
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 
 // src/local-state.ts
 init_cjs_shims();
-var import_node_fs5 = require("fs");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_fs6 = require("fs");
+var import_node_path6 = __toESM(require("path"), 1);
 var DEFAULT_REAP_AFTER_MS2 = 5 * 60 * 1e3;
 function filePath(workspacePath) {
-  return import_node_path5.default.join(workspacePath, ".claude", "agentmonitors.local.md");
+  return import_node_path6.default.join(workspacePath, ".claude", "agentmonitors.local.md");
 }
 function parseFrontmatter(raw) {
   const lines = raw.split("\n");
@@ -34469,7 +35771,7 @@ function parseFrontmatter(raw) {
 function readLocalState(workspacePath) {
   let raw;
   try {
-    raw = (0, import_node_fs5.readFileSync)(filePath(workspacePath), "utf-8");
+    raw = (0, import_node_fs6.readFileSync)(filePath(workspacePath), "utf-8");
   } catch {
     return { enabled: false };
   }
@@ -34490,7 +35792,7 @@ function readLocalState(workspacePath) {
 }
 function writeLocalState(workspacePath, state) {
   const target = filePath(workspacePath);
-  (0, import_node_fs5.mkdirSync)(import_node_path5.default.dirname(target), { recursive: true });
+  (0, import_node_fs6.mkdirSync)(import_node_path6.default.dirname(target), { recursive: true });
   const lines = [
     "---",
     `enabled: ${String(state.enabled)}`,
@@ -34502,25 +35804,25 @@ function writeLocalState(workspacePath, state) {
     "> Local AgentMon coordination state. Gitignored; safe to delete (it is regenerated).",
     ""
   ];
-  (0, import_node_fs5.writeFileSync)(target, lines.join("\n"), "utf-8");
+  (0, import_node_fs6.writeFileSync)(target, lines.join("\n"), "utf-8");
 }
 
 // src/workspace-paths.ts
 init_cjs_shims();
 var import_node_crypto2 = require("crypto");
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 function workspacePaths(workspacePath) {
-  const hash = (0, import_node_crypto2.createHash)("sha256").update(import_node_path6.default.resolve(workspacePath)).digest("hex").slice(0, 16);
-  const dataRoot = process.env["XDG_DATA_HOME"] ?? import_node_path6.default.join(import_node_os3.default.homedir(), ".local", "share");
-  const dir = import_node_path6.default.join(dataRoot, "agentmonitors", "workspaces", hash);
+  const hash = (0, import_node_crypto2.createHash)("sha256").update(import_node_path7.default.resolve(workspacePath)).digest("hex").slice(0, 16);
+  const dataRoot = process.env["XDG_DATA_HOME"] ?? import_node_path7.default.join(import_node_os3.default.homedir(), ".local", "share");
+  const dir = import_node_path7.default.join(dataRoot, "agentmonitors", "workspaces", hash);
   return {
     dir,
-    db: import_node_path6.default.join(dir, "inbox.db"),
+    db: import_node_path7.default.join(dir, "inbox.db"),
     // Keep the socket short: a 16-char hash under the data dir stays well under
     // the 100-char limit on most setups; resolveSocketPath's /tmp fallback still
     // applies if a deep home dir pushes it over.
-    socket: import_node_path6.default.join(dir, "agentmonitors.sock")
+    socket: import_node_path7.default.join(dir, "agentmonitors.sock")
   };
 }
 
@@ -34528,15 +35830,15 @@ function workspacePaths(workspacePath) {
 init_cjs_shims();
 var import_node_child_process = require("child_process");
 var import_node_url3 = require("url");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 function cliEntry() {
   const thisFile = (0, import_node_url3.fileURLToPath)(importMetaUrl);
-  const isBundle = import_node_path7.default.basename(import_node_path7.default.dirname(thisFile)) === "dist";
+  const isBundle = import_node_path8.default.basename(import_node_path8.default.dirname(thisFile)) === "dist";
   if (isBundle) {
     return thisFile;
   }
-  const packageRoot = import_node_path7.default.resolve(import_node_path7.default.dirname(thisFile), "..");
-  return import_node_path7.default.join(packageRoot, "dist", "index.cjs");
+  const packageRoot = import_node_path8.default.resolve(import_node_path8.default.dirname(thisFile), "..");
+  return import_node_path8.default.join(packageRoot, "dist", "index.cjs");
 }
 function spawnDetachedDaemon(options2) {
   const args = [
@@ -34743,7 +36045,7 @@ sessionCommand.command("start").description(
   const paths = workspacePaths(workspacePath);
   const socket = resolveSocketPath(state.socket ?? paths.socket);
   const db = state.db ?? paths.db;
-  const monitorsDir = import_node_path8.default.join(workspacePath, ".claude", "monitors");
+  const monitorsDir = import_node_path9.default.join(workspacePath, ".claude", "monitors");
   const BOOT_TIMEOUT_MS = 8e3;
   if (!await daemonAvailable(socket)) {
     spawnDetachedDaemon({
@@ -35136,10 +36438,10 @@ function cached(getter) {
 function nullish(input) {
   return input === null || input === void 0;
 }
-function cleanRegex(source5) {
-  const start = source5.startsWith("^") ? 1 : 0;
-  const end = source5.endsWith("$") ? source5.length - 1 : source5.length;
-  return source5.slice(start, end);
+function cleanRegex(source6) {
+  const start = source6.startsWith("^") ? 1 : 0;
+  const end = source6.endsWith("$") ? source6.length - 1 : source6.length;
+  return source6.slice(start, end);
 }
 function floatSafeRemainder2(val, step) {
   const valDecCount = (val.toString().split(".")[1] || "").length;
@@ -35177,10 +36479,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path12) {
-  if (!path12)
+function getElementAtPath(obj, path13) {
+  if (!path13)
     return obj;
-  return path12.reduce((acc, key) => acc?.[key], obj);
+  return path13.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -35500,11 +36802,11 @@ function aborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path12, issues) {
+function prefixIssues(path13, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path12);
+    iss.path.unshift(path13);
     return iss;
   });
 }
@@ -42413,9 +43715,9 @@ async function runChannelServe(options2) {
 // src/index.ts
 function getVersion() {
   try {
-    const dir = (0, import_node_path9.dirname)((0, import_node_url4.fileURLToPath)(importMetaUrl));
+    const dir = (0, import_node_path10.dirname)((0, import_node_url4.fileURLToPath)(importMetaUrl));
     const pkg = JSON.parse(
-      (0, import_node_fs6.readFileSync)((0, import_node_path9.join)(dir, "..", "package.json"), "utf8")
+      (0, import_node_fs7.readFileSync)((0, import_node_path10.join)(dir, "..", "package.json"), "utf8")
     );
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {