@agentmonitors/cli 0.3.2 → 0.4.0

package/dist/index.cjs

@@ -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.
@@ -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}'`;
@@ -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;
         }
       }
@@ -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);
           }
         }
@@ -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`
 ---
@@ -28669,24 +28686,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 +29607,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 +29760,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 +30049,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 +30624,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 +30766,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 +31241,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 +31264,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 +31273,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 +31332,194 @@ 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 resolveDottedPath(root, path72) {
+  if (path72 === "$") return root;
+  if (!path72.startsWith("$.")) {
+    throw new Error(
+      `Invalid collection path "${path72}": must start with "$." (e.g. "$.tasks")`
+    );
+  }
+  const segments = path72.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) {
+  if (path72 === "$") return;
+  if (!path72.startsWith("$.")) {
+    throw new Error(
+      `Invalid ignore-paths entry "${path72}": must start with "$." (e.g. "$.fetchedAt")`
+    );
+  }
+  const segments = path72.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"];
@@ -32099,8 +32304,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 +32317,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 +32468,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 +32873,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 +32903,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 +32920,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 +32960,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")'
+            },
+            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) 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 +33001,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 +33059,335 @@ 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 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, 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 hasChanged2(strategy, prev, curr) {
+  switch (strategy) {
+    case "exit-code":
+      return prev.exitCode !== curr.exitCode;
+    case "json-diff":
+      try {
+        const prevJson = JSON.stringify(sortKeys3(JSON.parse(prev.stdout)));
+        const currJson = JSON.stringify(sortKeys3(JSON.parse(curr.stdout)));
+        return prevJson !== currJson;
+      } catch {
+        return prev.stdout !== curr.stdout;
+      }
+    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")'
+            },
+            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) 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"]
+      }
+    }
+  },
+  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, 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 +33398,7 @@ function parseScopeConfig3(config2) {
     label: typeof config2["label"] === "string" ? config2["label"] : void 0
   };
 }
-var scopeSchema3 = {
+var scopeSchema4 = {
   type: "object",
   properties: {
     cron: {
@@ -32835,11 +33416,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 +33442,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 +33463,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 +33488,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 +33524,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 +33566,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 +33591,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 +33637,7 @@ var source4 = {
     }
   }
 };
-var index_default4 = source4;
+var index_default5 = source5;
 
 // src/sources.ts
 function registerCoreSources(registry2) {
@@ -33064,6 +33645,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 +33686,16 @@ 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";
+}
 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 +33706,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,9 +33717,11 @@ 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;
@@ -33967,24 +34561,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 +34588,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}`);
@@ -34023,8 +34617,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 +34629,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 {
@@ -34114,11 +34708,11 @@ 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"] ?? {};
       return {
-        name: source5.name,
+        name: source6.name,
         scopeFields: Object.keys(properties),
         required: requiredFields
       };
@@ -34131,10 +34725,10 @@ 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}`);
+  for (const source6 of sources) {
+    const requiredFields = source6.scopeSchema["required"] ?? [];
+    const properties = source6.scopeSchema["properties"] ?? {};
+    console.log(`  ${source6.name}`);
     console.log(`    Scope fields: ${Object.keys(properties).join(", ")}`);
     console.log(`    Required: ${requiredFields.join(", ") || "(none)"}`);
     console.log("");
@@ -35136,10 +35730,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;