@mulmoclaude/core 1.12.0 → 1.13.0

package/dist/{dist-pWpC-b04.cjs → dist-21pMsI1a.cjs}

@@ -3,10 +3,24 @@
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/** An array of unknowns. Prefer this over a bare `Array.isArray` in typed code:
+*  `Array.isArray(x: unknown)` narrows to `any[]`, silently reintroducing
+*  `any`, whereas this keeps the element type `unknown`. */
+function isUnknownArray(value) {
+	return Array.isArray(value);
+}
+/** Error-like object with a `code` property (e.g. Node.js fs errors). */
+function isErrorWithCode(value) {
+	return isRecord(value) && typeof value.code === "string";
+}
 /** Check that a record has a specific key with a string value. */
 function hasStringProp(value, key) {
 	return isRecord(value) && typeof value[key] === "string";
 }
+/** Check that a record has a specific key with a number value. */
+function hasNumberProp(value, key) {
+	return isRecord(value) && typeof value[key] === "number";
+}
 /** Normalise an unknown thrown value into a human-readable string. Isomorphic
 *  (host, bridges, plugins, Vue) — this is the single home for the helper that
 *  #2217 could only consolidate for server code, since `@mulmoclaude/core/utils`
@@ -57,5 +71,35 @@ Object.defineProperty(exports, "escapeHtml", {
 		return escapeHtml;
 	}
 });
+Object.defineProperty(exports, "hasNumberProp", {
+	enumerable: true,
+	get: function() {
+		return hasNumberProp;
+	}
+});
+Object.defineProperty(exports, "hasStringProp", {
+	enumerable: true,
+	get: function() {
+		return hasStringProp;
+	}
+});
+Object.defineProperty(exports, "isErrorWithCode", {
+	enumerable: true,
+	get: function() {
+		return isErrorWithCode;
+	}
+});
+Object.defineProperty(exports, "isRecord", {
+	enumerable: true,
+	get: function() {
+		return isRecord;
+	}
+});
+Object.defineProperty(exports, "isUnknownArray", {
+	enumerable: true,
+	get: function() {
+		return isUnknownArray;
+	}
+});
 
-//# sourceMappingURL=dist-pWpC-b04.cjs.map
+//# sourceMappingURL=dist-21pMsI1a.cjs.map

package/dist/{dist-pWpC-b04.cjs.map → dist-21pMsI1a.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"dist-pWpC-b04.cjs","names":[],"sources":["../../common/dist/index.js"],"sourcesContent":["// General-purpose runtime type guards, shared across the MulmoClaude host,\n// bridges, and plugins. This is a leaf package — pure and dependency-free — so\n// any tier can import it without creating an uphill edge.\n//\n// These originated as `server/utils/types.ts` (#504), which centralised 40+\n// hand-written inline `typeof x === \"object\"` checks. They are promoted here so\n// the same guards stop being re-hand-written in every bridge and plugin too.\n/** Narrow `unknown` to a plain object (not null, not array). */\nexport function isRecord(value) {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n/** Narrow `unknown` to any object (not null, arrays allowed).\n *  Use `isRecord` when you need to access string keys. */\nexport function isObj(value) {\n    return typeof value === \"object\" && value !== null;\n}\n/** Non-empty string after trimming whitespace. */\nexport function isNonEmptyString(value) {\n    return typeof value === \"string\" && value.trim().length > 0;\n}\n/** Record whose values are all strings. */\nexport function isStringRecord(value) {\n    if (!isRecord(value))\n        return false;\n    return Object.values(value).every((val) => typeof val === \"string\");\n}\n/** String array (every element is a string). */\nexport function isStringArray(value) {\n    return Array.isArray(value) && value.every((val) => typeof val === \"string\");\n}\n/** An array of unknowns. Prefer this over a bare `Array.isArray` in typed code:\n *  `Array.isArray(x: unknown)` narrows to `any[]`, silently reintroducing\n *  `any`, whereas this keeps the element type `unknown`. */\nexport function isUnknownArray(value) {\n    return Array.isArray(value);\n}\n/** Error-like object with a `code` property (e.g. Node.js fs errors). */\nexport function isErrorWithCode(value) {\n    return isRecord(value) && typeof value.code === \"string\";\n}\n/** Check that a record has a specific key with a string value. */\nexport function hasStringProp(value, key) {\n    return isRecord(value) && typeof value[key] === \"string\";\n}\n/** Check that a record has a specific key with a number value. */\nexport function hasNumberProp(value, key) {\n    return isRecord(value) && typeof value[key] === \"number\";\n}\n/** Split a comma-separated env value into trimmed, non-empty entries.\n *  `lowercase` folds case for identifiers compared case-insensitively\n *  (JIDs, email addresses, hex pubkeys). Absent/empty input → empty list. */\nexport function parseCsvList(raw, opts) {\n    return (raw ?? \"\")\n        .split(\",\")\n        .map((entry) => (opts?.lowercase ? entry.trim().toLowerCase() : entry.trim()))\n        .filter(Boolean);\n}\n/** A comma-separated env value as a Set — the canonical allowlist shape,\n *  where an empty set is the \"allow all\" sentinel (`set.size === 0`). */\nexport function parseCsvSet(raw, opts) {\n    return new Set(parseCsvList(raw, opts));\n}\n/** Normalise an unknown thrown value into a human-readable string. Isomorphic\n *  (host, bridges, plugins, Vue) — this is the single home for the helper that\n *  #2217 could only consolidate for server code, since `@mulmoclaude/core/utils`\n *  is server-only.\n *\n *  A non-Error object with a non-empty string `details` (gRPC convention) or\n *  `message` field surfaces that field — `details` wins — instead of the\n *  `[object Object]` a bare `String(err)` would print; an empty-string field\n *  falls through. `fallback` covers the error-boundary idiom where a thrown\n *  non-Error should read as a descriptive message rather than `String(err)`\n *  noise; omit it in logging contexts where `String(err)` is fine. */\nexport function errorMessage(err, fallback) {\n    if (err instanceof Error)\n        return err.message;\n    if (hasStringProp(err, \"details\") && err.details)\n        return err.details;\n    if (hasStringProp(err, \"message\") && err.message)\n        return err.message;\n    if (fallback !== undefined)\n        return fallback;\n    return String(err);\n}\n/** `Date` → `YYYY-MM-DD` in UTC — for dates that must not shift with the\n *  host's local timezone (tool-trace search dirs, API date keys). Isomorphic\n *  single source (#2480): the host re-exports it from `server/utils/date.ts`,\n *  x-plugin imports it directly. The `@receptron/task-scheduler` copy stays\n *  local on purpose — that leaf package is published independently and kept\n *  dependency-free. Wall-clock questions use the host's `toLocalIsoDate`. */\nexport function toUtcIsoDate(timestamp) {\n    const year = timestamp.getUTCFullYear();\n    const month = String(timestamp.getUTCMonth() + 1).padStart(2, \"0\");\n    const day = String(timestamp.getUTCDate()).padStart(2, \"0\");\n    return `${year}-${month}-${day}`;\n}\n// A Map, not an object literal: `{}[char]` reads through the prototype chain,\n// so a future caller widening the regex would silently get `[object Object]`\n// for keys like `constructor`.\nconst HTML_ESCAPES = new Map([\n    [\"&\", \"&amp;\"],\n    [\"<\", \"&lt;\"],\n    [\">\", \"&gt;\"],\n    ['\"', \"&quot;\"],\n    [\"'\", \"&#39;\"],\n]);\n/** HTML-escape text destined for markup or an attribute value — the fixed\n *  five-character map, nothing more. Lives here rather than in\n *  `@mulmoclaude/core/wiki` (#2483) because `@mulmoclaude/markdown-utils` is a\n *  leaf that core depends on and so cannot import back up; core/wiki\n *  re-exports this, keeping its consumers' import path unchanged.\n *\n *  Escaping `&` first is what makes a single pass safe — the entities this\n *  introduces contain none of the other four characters, so nothing is\n *  double-escaped. Not a sanitiser: it neither strips tags nor validates URLs. */\nexport function escapeHtml(value) {\n    return value.replace(/[&<>\"']/g, (char) => HTML_ESCAPES.get(char) ?? char);\n}\nexport { scanEnvOptions, snakeToLowerCamel } from \"./envScan.js\";\n"],"mappings":";;AAQA,SAAgB,SAAS,OAAO;CAC5B,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC9E;;AA+BA,SAAgB,cAAc,OAAO,KAAK;CACtC,OAAO,SAAS,KAAK,KAAK,OAAO,MAAM,SAAS;AACpD;;;;;;;;;;;;AA8BA,SAAgB,aAAa,KAAK,UAAU;CACxC,IAAI,eAAe,OACf,OAAO,IAAI;CACf,IAAI,cAAc,KAAK,SAAS,KAAK,IAAI,SACrC,OAAO,IAAI;CACf,IAAI,cAAc,KAAK,SAAS,KAAK,IAAI,SACrC,OAAO,IAAI;CACf,IAAI,aAAa,KAAA,GACb,OAAO;CACX,OAAO,OAAO,GAAG;AACrB;AAgBA,IAAM,+BAAe,IAAI,IAAI;CACzB,CAAC,KAAK,OAAO;CACb,CAAC,KAAK,MAAM;CACZ,CAAC,KAAK,MAAM;CACZ,CAAC,MAAK,QAAQ;CACd,CAAC,KAAK,OAAO;AACjB,CAAC;;;;;;;;;;AAUD,SAAgB,WAAW,OAAO;CAC9B,OAAO,MAAM,QAAQ,aAAa,SAAS,aAAa,IAAI,IAAI,KAAK,IAAI;AAC7E"}
+{"version":3,"file":"dist-21pMsI1a.cjs","names":[],"sources":["../../common/dist/index.js"],"sourcesContent":["// General-purpose runtime type guards, shared across the MulmoClaude host,\n// bridges, and plugins. This is a leaf package — pure and dependency-free — so\n// any tier can import it without creating an uphill edge.\n//\n// These originated as `server/utils/types.ts` (#504), which centralised 40+\n// hand-written inline `typeof x === \"object\"` checks. They are promoted here so\n// the same guards stop being re-hand-written in every bridge and plugin too.\n/** Narrow `unknown` to a plain object (not null, not array). */\nexport function isRecord(value) {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n/** Narrow `unknown` to any object (not null, arrays allowed).\n *  Use `isRecord` when you need to access string keys. */\nexport function isObj(value) {\n    return typeof value === \"object\" && value !== null;\n}\n/** Non-empty string after trimming whitespace. */\nexport function isNonEmptyString(value) {\n    return typeof value === \"string\" && value.trim().length > 0;\n}\n/** Record whose values are all strings. */\nexport function isStringRecord(value) {\n    if (!isRecord(value))\n        return false;\n    return Object.values(value).every((val) => typeof val === \"string\");\n}\n/** String array (every element is a string). */\nexport function isStringArray(value) {\n    return Array.isArray(value) && value.every((val) => typeof val === \"string\");\n}\n/** An array of unknowns. Prefer this over a bare `Array.isArray` in typed code:\n *  `Array.isArray(x: unknown)` narrows to `any[]`, silently reintroducing\n *  `any`, whereas this keeps the element type `unknown`. */\nexport function isUnknownArray(value) {\n    return Array.isArray(value);\n}\n/** Error-like object with a `code` property (e.g. Node.js fs errors). */\nexport function isErrorWithCode(value) {\n    return isRecord(value) && typeof value.code === \"string\";\n}\n/** Check that a record has a specific key with a string value. */\nexport function hasStringProp(value, key) {\n    return isRecord(value) && typeof value[key] === \"string\";\n}\n/** Check that a record has a specific key with a number value. */\nexport function hasNumberProp(value, key) {\n    return isRecord(value) && typeof value[key] === \"number\";\n}\n/** Split a comma-separated env value into trimmed, non-empty entries.\n *  `lowercase` folds case for identifiers compared case-insensitively\n *  (JIDs, email addresses, hex pubkeys). Absent/empty input → empty list. */\nexport function parseCsvList(raw, opts) {\n    return (raw ?? \"\")\n        .split(\",\")\n        .map((entry) => (opts?.lowercase ? entry.trim().toLowerCase() : entry.trim()))\n        .filter(Boolean);\n}\n/** A comma-separated env value as a Set — the canonical allowlist shape,\n *  where an empty set is the \"allow all\" sentinel (`set.size === 0`). */\nexport function parseCsvSet(raw, opts) {\n    return new Set(parseCsvList(raw, opts));\n}\n/** Normalise an unknown thrown value into a human-readable string. Isomorphic\n *  (host, bridges, plugins, Vue) — this is the single home for the helper that\n *  #2217 could only consolidate for server code, since `@mulmoclaude/core/utils`\n *  is server-only.\n *\n *  A non-Error object with a non-empty string `details` (gRPC convention) or\n *  `message` field surfaces that field — `details` wins — instead of the\n *  `[object Object]` a bare `String(err)` would print; an empty-string field\n *  falls through. `fallback` covers the error-boundary idiom where a thrown\n *  non-Error should read as a descriptive message rather than `String(err)`\n *  noise; omit it in logging contexts where `String(err)` is fine. */\nexport function errorMessage(err, fallback) {\n    if (err instanceof Error)\n        return err.message;\n    if (hasStringProp(err, \"details\") && err.details)\n        return err.details;\n    if (hasStringProp(err, \"message\") && err.message)\n        return err.message;\n    if (fallback !== undefined)\n        return fallback;\n    return String(err);\n}\n/** `Date` → `YYYY-MM-DD` in UTC — for dates that must not shift with the\n *  host's local timezone (tool-trace search dirs, API date keys). Isomorphic\n *  single source (#2480): the host re-exports it from `server/utils/date.ts`,\n *  x-plugin imports it directly. The `@receptron/task-scheduler` copy stays\n *  local on purpose — that leaf package is published independently and kept\n *  dependency-free. Wall-clock questions use the host's `toLocalIsoDate`. */\nexport function toUtcIsoDate(timestamp) {\n    const year = timestamp.getUTCFullYear();\n    const month = String(timestamp.getUTCMonth() + 1).padStart(2, \"0\");\n    const day = String(timestamp.getUTCDate()).padStart(2, \"0\");\n    return `${year}-${month}-${day}`;\n}\n// A Map, not an object literal: `{}[char]` reads through the prototype chain,\n// so a future caller widening the regex would silently get `[object Object]`\n// for keys like `constructor`.\nconst HTML_ESCAPES = new Map([\n    [\"&\", \"&amp;\"],\n    [\"<\", \"&lt;\"],\n    [\">\", \"&gt;\"],\n    ['\"', \"&quot;\"],\n    [\"'\", \"&#39;\"],\n]);\n/** HTML-escape text destined for markup or an attribute value — the fixed\n *  five-character map, nothing more. Lives here rather than in\n *  `@mulmoclaude/core/wiki` (#2483) because `@mulmoclaude/markdown-utils` is a\n *  leaf that core depends on and so cannot import back up; core/wiki\n *  re-exports this, keeping its consumers' import path unchanged.\n *\n *  Escaping `&` first is what makes a single pass safe — the entities this\n *  introduces contain none of the other four characters, so nothing is\n *  double-escaped. Not a sanitiser: it neither strips tags nor validates URLs. */\nexport function escapeHtml(value) {\n    return value.replace(/[&<>\"']/g, (char) => HTML_ESCAPES.get(char) ?? char);\n}\nexport { scanEnvOptions, snakeToLowerCamel } from \"./envScan.js\";\n"],"mappings":";;AAQA,SAAgB,SAAS,OAAO;CAC5B,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC9E;;;;AAuBA,SAAgB,eAAe,OAAO;CAClC,OAAO,MAAM,QAAQ,KAAK;AAC9B;;AAEA,SAAgB,gBAAgB,OAAO;CACnC,OAAO,SAAS,KAAK,KAAK,OAAO,MAAM,SAAS;AACpD;;AAEA,SAAgB,cAAc,OAAO,KAAK;CACtC,OAAO,SAAS,KAAK,KAAK,OAAO,MAAM,SAAS;AACpD;;AAEA,SAAgB,cAAc,OAAO,KAAK;CACtC,OAAO,SAAS,KAAK,KAAK,OAAO,MAAM,SAAS;AACpD;;;;;;;;;;;;AA0BA,SAAgB,aAAa,KAAK,UAAU;CACxC,IAAI,eAAe,OACf,OAAO,IAAI;CACf,IAAI,cAAc,KAAK,SAAS,KAAK,IAAI,SACrC,OAAO,IAAI;CACf,IAAI,cAAc,KAAK,SAAS,KAAK,IAAI,SACrC,OAAO,IAAI;CACf,IAAI,aAAa,KAAA,GACb,OAAO;CACX,OAAO,OAAO,GAAG;AACrB;AAgBA,IAAM,+BAAe,IAAI,IAAI;CACzB,CAAC,KAAK,OAAO;CACb,CAAC,KAAK,MAAM;CACZ,CAAC,KAAK,MAAM;CACZ,CAAC,MAAK,QAAQ;CACd,CAAC,KAAK,OAAO;AACjB,CAAC;;;;;;;;;;AAUD,SAAgB,WAAW,OAAO;CAC9B,OAAO,MAAM,QAAQ,aAAa,SAAS,aAAa,IAAI,IAAI,KAAK,IAAI;AAC7E"}

package/dist/{dist-Cwk0e12G.js → dist-DP1FTGnO.js}

@@ -3,10 +3,24 @@
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/** An array of unknowns. Prefer this over a bare `Array.isArray` in typed code:
+*  `Array.isArray(x: unknown)` narrows to `any[]`, silently reintroducing
+*  `any`, whereas this keeps the element type `unknown`. */
+function isUnknownArray(value) {
+	return Array.isArray(value);
+}
+/** Error-like object with a `code` property (e.g. Node.js fs errors). */
+function isErrorWithCode(value) {
+	return isRecord(value) && typeof value.code === "string";
+}
 /** Check that a record has a specific key with a string value. */
 function hasStringProp(value, key) {
 	return isRecord(value) && typeof value[key] === "string";
 }
+/** Check that a record has a specific key with a number value. */
+function hasNumberProp(value, key) {
+	return isRecord(value) && typeof value[key] === "number";
+}
 /** Normalise an unknown thrown value into a human-readable string. Isomorphic
 *  (host, bridges, plugins, Vue) — this is the single home for the helper that
 *  #2217 could only consolidate for server code, since `@mulmoclaude/core/utils`
@@ -45,6 +59,6 @@ function escapeHtml(value) {
 	return value.replace(/[&<>"']/g, (char) => HTML_ESCAPES.get(char) ?? char);
 }
 //#endregion
-export { escapeHtml as n, errorMessage as t };
+export { isErrorWithCode as a, hasStringProp as i, escapeHtml as n, isRecord as o, hasNumberProp as r, isUnknownArray as s, errorMessage as t };
 
-//# sourceMappingURL=dist-Cwk0e12G.js.map
+//# sourceMappingURL=dist-DP1FTGnO.js.map

package/dist/{dist-Cwk0e12G.js.map → dist-DP1FTGnO.js.map}

@@ -1 +1 @@
-{"version":3,"file":"dist-Cwk0e12G.js","names":[],"sources":["../../common/dist/index.js"],"sourcesContent":["// General-purpose runtime type guards, shared across the MulmoClaude host,\n// bridges, and plugins. This is a leaf package — pure and dependency-free — so\n// any tier can import it without creating an uphill edge.\n//\n// These originated as `server/utils/types.ts` (#504), which centralised 40+\n// hand-written inline `typeof x === \"object\"` checks. They are promoted here so\n// the same guards stop being re-hand-written in every bridge and plugin too.\n/** Narrow `unknown` to a plain object (not null, not array). */\nexport function isRecord(value) {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n/** Narrow `unknown` to any object (not null, arrays allowed).\n *  Use `isRecord` when you need to access string keys. */\nexport function isObj(value) {\n    return typeof value === \"object\" && value !== null;\n}\n/** Non-empty string after trimming whitespace. */\nexport function isNonEmptyString(value) {\n    return typeof value === \"string\" && value.trim().length > 0;\n}\n/** Record whose values are all strings. */\nexport function isStringRecord(value) {\n    if (!isRecord(value))\n        return false;\n    return Object.values(value).every((val) => typeof val === \"string\");\n}\n/** String array (every element is a string). */\nexport function isStringArray(value) {\n    return Array.isArray(value) && value.every((val) => typeof val === \"string\");\n}\n/** An array of unknowns. Prefer this over a bare `Array.isArray` in typed code:\n *  `Array.isArray(x: unknown)` narrows to `any[]`, silently reintroducing\n *  `any`, whereas this keeps the element type `unknown`. */\nexport function isUnknownArray(value) {\n    return Array.isArray(value);\n}\n/** Error-like object with a `code` property (e.g. Node.js fs errors). */\nexport function isErrorWithCode(value) {\n    return isRecord(value) && typeof value.code === \"string\";\n}\n/** Check that a record has a specific key with a string value. */\nexport function hasStringProp(value, key) {\n    return isRecord(value) && typeof value[key] === \"string\";\n}\n/** Check that a record has a specific key with a number value. */\nexport function hasNumberProp(value, key) {\n    return isRecord(value) && typeof value[key] === \"number\";\n}\n/** Split a comma-separated env value into trimmed, non-empty entries.\n *  `lowercase` folds case for identifiers compared case-insensitively\n *  (JIDs, email addresses, hex pubkeys). Absent/empty input → empty list. */\nexport function parseCsvList(raw, opts) {\n    return (raw ?? \"\")\n        .split(\",\")\n        .map((entry) => (opts?.lowercase ? entry.trim().toLowerCase() : entry.trim()))\n        .filter(Boolean);\n}\n/** A comma-separated env value as a Set — the canonical allowlist shape,\n *  where an empty set is the \"allow all\" sentinel (`set.size === 0`). */\nexport function parseCsvSet(raw, opts) {\n    return new Set(parseCsvList(raw, opts));\n}\n/** Normalise an unknown thrown value into a human-readable string. Isomorphic\n *  (host, bridges, plugins, Vue) — this is the single home for the helper that\n *  #2217 could only consolidate for server code, since `@mulmoclaude/core/utils`\n *  is server-only.\n *\n *  A non-Error object with a non-empty string `details` (gRPC convention) or\n *  `message` field surfaces that field — `details` wins — instead of the\n *  `[object Object]` a bare `String(err)` would print; an empty-string field\n *  falls through. `fallback` covers the error-boundary idiom where a thrown\n *  non-Error should read as a descriptive message rather than `String(err)`\n *  noise; omit it in logging contexts where `String(err)` is fine. */\nexport function errorMessage(err, fallback) {\n    if (err instanceof Error)\n        return err.message;\n    if (hasStringProp(err, \"details\") && err.details)\n        return err.details;\n    if (hasStringProp(err, \"message\") && err.message)\n        return err.message;\n    if (fallback !== undefined)\n        return fallback;\n    return String(err);\n}\n/** `Date` → `YYYY-MM-DD` in UTC — for dates that must not shift with the\n *  host's local timezone (tool-trace search dirs, API date keys). Isomorphic\n *  single source (#2480): the host re-exports it from `server/utils/date.ts`,\n *  x-plugin imports it directly. The `@receptron/task-scheduler` copy stays\n *  local on purpose — that leaf package is published independently and kept\n *  dependency-free. Wall-clock questions use the host's `toLocalIsoDate`. */\nexport function toUtcIsoDate(timestamp) {\n    const year = timestamp.getUTCFullYear();\n    const month = String(timestamp.getUTCMonth() + 1).padStart(2, \"0\");\n    const day = String(timestamp.getUTCDate()).padStart(2, \"0\");\n    return `${year}-${month}-${day}`;\n}\n// A Map, not an object literal: `{}[char]` reads through the prototype chain,\n// so a future caller widening the regex would silently get `[object Object]`\n// for keys like `constructor`.\nconst HTML_ESCAPES = new Map([\n    [\"&\", \"&amp;\"],\n    [\"<\", \"&lt;\"],\n    [\">\", \"&gt;\"],\n    ['\"', \"&quot;\"],\n    [\"'\", \"&#39;\"],\n]);\n/** HTML-escape text destined for markup or an attribute value — the fixed\n *  five-character map, nothing more. Lives here rather than in\n *  `@mulmoclaude/core/wiki` (#2483) because `@mulmoclaude/markdown-utils` is a\n *  leaf that core depends on and so cannot import back up; core/wiki\n *  re-exports this, keeping its consumers' import path unchanged.\n *\n *  Escaping `&` first is what makes a single pass safe — the entities this\n *  introduces contain none of the other four characters, so nothing is\n *  double-escaped. Not a sanitiser: it neither strips tags nor validates URLs. */\nexport function escapeHtml(value) {\n    return value.replace(/[&<>\"']/g, (char) => HTML_ESCAPES.get(char) ?? char);\n}\nexport { scanEnvOptions, snakeToLowerCamel } from \"./envScan.js\";\n"],"mappings":";;AAQA,SAAgB,SAAS,OAAO;CAC5B,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC9E;;AA+BA,SAAgB,cAAc,OAAO,KAAK;CACtC,OAAO,SAAS,KAAK,KAAK,OAAO,MAAM,SAAS;AACpD;;;;;;;;;;;;AA8BA,SAAgB,aAAa,KAAK,UAAU;CACxC,IAAI,eAAe,OACf,OAAO,IAAI;CACf,IAAI,cAAc,KAAK,SAAS,KAAK,IAAI,SACrC,OAAO,IAAI;CACf,IAAI,cAAc,KAAK,SAAS,KAAK,IAAI,SACrC,OAAO,IAAI;CACf,IAAI,aAAa,KAAA,GACb,OAAO;CACX,OAAO,OAAO,GAAG;AACrB;AAgBA,IAAM,+BAAe,IAAI,IAAI;CACzB,CAAC,KAAK,OAAO;CACb,CAAC,KAAK,MAAM;CACZ,CAAC,KAAK,MAAM;CACZ,CAAC,MAAK,QAAQ;CACd,CAAC,KAAK,OAAO;AACjB,CAAC;;;;;;;;;;AAUD,SAAgB,WAAW,OAAO;CAC9B,OAAO,MAAM,QAAQ,aAAa,SAAS,aAAa,IAAI,IAAI,KAAK,IAAI;AAC7E"}
+{"version":3,"file":"dist-DP1FTGnO.js","names":[],"sources":["../../common/dist/index.js"],"sourcesContent":["// General-purpose runtime type guards, shared across the MulmoClaude host,\n// bridges, and plugins. This is a leaf package — pure and dependency-free — so\n// any tier can import it without creating an uphill edge.\n//\n// These originated as `server/utils/types.ts` (#504), which centralised 40+\n// hand-written inline `typeof x === \"object\"` checks. They are promoted here so\n// the same guards stop being re-hand-written in every bridge and plugin too.\n/** Narrow `unknown` to a plain object (not null, not array). */\nexport function isRecord(value) {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n/** Narrow `unknown` to any object (not null, arrays allowed).\n *  Use `isRecord` when you need to access string keys. */\nexport function isObj(value) {\n    return typeof value === \"object\" && value !== null;\n}\n/** Non-empty string after trimming whitespace. */\nexport function isNonEmptyString(value) {\n    return typeof value === \"string\" && value.trim().length > 0;\n}\n/** Record whose values are all strings. */\nexport function isStringRecord(value) {\n    if (!isRecord(value))\n        return false;\n    return Object.values(value).every((val) => typeof val === \"string\");\n}\n/** String array (every element is a string). */\nexport function isStringArray(value) {\n    return Array.isArray(value) && value.every((val) => typeof val === \"string\");\n}\n/** An array of unknowns. Prefer this over a bare `Array.isArray` in typed code:\n *  `Array.isArray(x: unknown)` narrows to `any[]`, silently reintroducing\n *  `any`, whereas this keeps the element type `unknown`. */\nexport function isUnknownArray(value) {\n    return Array.isArray(value);\n}\n/** Error-like object with a `code` property (e.g. Node.js fs errors). */\nexport function isErrorWithCode(value) {\n    return isRecord(value) && typeof value.code === \"string\";\n}\n/** Check that a record has a specific key with a string value. */\nexport function hasStringProp(value, key) {\n    return isRecord(value) && typeof value[key] === \"string\";\n}\n/** Check that a record has a specific key with a number value. */\nexport function hasNumberProp(value, key) {\n    return isRecord(value) && typeof value[key] === \"number\";\n}\n/** Split a comma-separated env value into trimmed, non-empty entries.\n *  `lowercase` folds case for identifiers compared case-insensitively\n *  (JIDs, email addresses, hex pubkeys). Absent/empty input → empty list. */\nexport function parseCsvList(raw, opts) {\n    return (raw ?? \"\")\n        .split(\",\")\n        .map((entry) => (opts?.lowercase ? entry.trim().toLowerCase() : entry.trim()))\n        .filter(Boolean);\n}\n/** A comma-separated env value as a Set — the canonical allowlist shape,\n *  where an empty set is the \"allow all\" sentinel (`set.size === 0`). */\nexport function parseCsvSet(raw, opts) {\n    return new Set(parseCsvList(raw, opts));\n}\n/** Normalise an unknown thrown value into a human-readable string. Isomorphic\n *  (host, bridges, plugins, Vue) — this is the single home for the helper that\n *  #2217 could only consolidate for server code, since `@mulmoclaude/core/utils`\n *  is server-only.\n *\n *  A non-Error object with a non-empty string `details` (gRPC convention) or\n *  `message` field surfaces that field — `details` wins — instead of the\n *  `[object Object]` a bare `String(err)` would print; an empty-string field\n *  falls through. `fallback` covers the error-boundary idiom where a thrown\n *  non-Error should read as a descriptive message rather than `String(err)`\n *  noise; omit it in logging contexts where `String(err)` is fine. */\nexport function errorMessage(err, fallback) {\n    if (err instanceof Error)\n        return err.message;\n    if (hasStringProp(err, \"details\") && err.details)\n        return err.details;\n    if (hasStringProp(err, \"message\") && err.message)\n        return err.message;\n    if (fallback !== undefined)\n        return fallback;\n    return String(err);\n}\n/** `Date` → `YYYY-MM-DD` in UTC — for dates that must not shift with the\n *  host's local timezone (tool-trace search dirs, API date keys). Isomorphic\n *  single source (#2480): the host re-exports it from `server/utils/date.ts`,\n *  x-plugin imports it directly. The `@receptron/task-scheduler` copy stays\n *  local on purpose — that leaf package is published independently and kept\n *  dependency-free. Wall-clock questions use the host's `toLocalIsoDate`. */\nexport function toUtcIsoDate(timestamp) {\n    const year = timestamp.getUTCFullYear();\n    const month = String(timestamp.getUTCMonth() + 1).padStart(2, \"0\");\n    const day = String(timestamp.getUTCDate()).padStart(2, \"0\");\n    return `${year}-${month}-${day}`;\n}\n// A Map, not an object literal: `{}[char]` reads through the prototype chain,\n// so a future caller widening the regex would silently get `[object Object]`\n// for keys like `constructor`.\nconst HTML_ESCAPES = new Map([\n    [\"&\", \"&amp;\"],\n    [\"<\", \"&lt;\"],\n    [\">\", \"&gt;\"],\n    ['\"', \"&quot;\"],\n    [\"'\", \"&#39;\"],\n]);\n/** HTML-escape text destined for markup or an attribute value — the fixed\n *  five-character map, nothing more. Lives here rather than in\n *  `@mulmoclaude/core/wiki` (#2483) because `@mulmoclaude/markdown-utils` is a\n *  leaf that core depends on and so cannot import back up; core/wiki\n *  re-exports this, keeping its consumers' import path unchanged.\n *\n *  Escaping `&` first is what makes a single pass safe — the entities this\n *  introduces contain none of the other four characters, so nothing is\n *  double-escaped. Not a sanitiser: it neither strips tags nor validates URLs. */\nexport function escapeHtml(value) {\n    return value.replace(/[&<>\"']/g, (char) => HTML_ESCAPES.get(char) ?? char);\n}\nexport { scanEnvOptions, snakeToLowerCamel } from \"./envScan.js\";\n"],"mappings":";;AAQA,SAAgB,SAAS,OAAO;CAC5B,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC9E;;;;AAuBA,SAAgB,eAAe,OAAO;CAClC,OAAO,MAAM,QAAQ,KAAK;AAC9B;;AAEA,SAAgB,gBAAgB,OAAO;CACnC,OAAO,SAAS,KAAK,KAAK,OAAO,MAAM,SAAS;AACpD;;AAEA,SAAgB,cAAc,OAAO,KAAK;CACtC,OAAO,SAAS,KAAK,KAAK,OAAO,MAAM,SAAS;AACpD;;AAEA,SAAgB,cAAc,OAAO,KAAK;CACtC,OAAO,SAAS,KAAK,KAAK,OAAO,MAAM,SAAS;AACpD;;;;;;;;;;;;AA0BA,SAAgB,aAAa,KAAK,UAAU;CACxC,IAAI,eAAe,OACf,OAAO,IAAI;CACf,IAAI,cAAc,KAAK,SAAS,KAAK,IAAI,SACrC,OAAO,IAAI;CACf,IAAI,cAAc,KAAK,SAAS,KAAK,IAAI,SACrC,OAAO,IAAI;CACf,IAAI,aAAa,KAAA,GACb,OAAO;CACX,OAAO,OAAO,GAAG;AACrB;AAgBA,IAAM,+BAAe,IAAI,IAAI;CACzB,CAAC,KAAK,OAAO;CACb,CAAC,KAAK,MAAM;CACZ,CAAC,KAAK,MAAM;CACZ,CAAC,MAAK,QAAQ;CACd,CAAC,KAAK,OAAO;AACjB,CAAC;;;;;;;;;;AAUD,SAAgB,WAAW,OAAO;CAC9B,OAAO,MAAM,QAAQ,aAAa,SAAS,aAAa,IAAI,IAAI,KAAK,IAAI;AAC7E"}

package/dist/feeds/server/engine.d.ts

@@ -1,6 +1,33 @@
 import { LoadedCollection } from '../../collection/server/index.js';
+import { CollectionItem } from '../../collection/index.js';
+import { IngestSpec } from '../ingestTypes.js';
 import { RefreshResult } from './refreshResult.js';
 export type { RefreshResult } from './refreshResult.js';
+/** Fields the feed itself produces: what it actually returned this run, the
+ *  declared map's targets, and the primary key the retriever derives. Anything
+ *  else on a record got there some other way — the user.
+ *
+ *  Both sources, because neither alone is enough. The in-tree retrievers project
+ *  through `map`, so it describes them exactly — but `registerRetriever` lets a
+ *  host add one that returns whatever it likes, and only the observed keys catch
+ *  that. Conversely a run that fetched nothing has no keys to observe, and only
+ *  `map` keeps the cap working through it. */
+export declare const ingestedFields: (items: readonly CollectionItem[], mappedTargets: readonly string[], primaryKey: string) => ReadonlySet<string>;
+/** The collection fields a declarative `map` names. Read as `unknown` and
+ *  narrowed here rather than through the zod-derived union, whose `map` does not
+ *  survive the `kind` narrowing well enough to index safely. Only the keys are
+ *  wanted, so the value type never has to be reconstructed. */
+export declare function mappedTargetsOf(ingest: IngestSpec | undefined): string[];
+/** Whether a record carries content the feed did not put there.
+ *
+ *  Only a NON-EMPTY value counts. A record saved through the UI can carry every
+ *  declared field as an empty string, and treating those as local content would
+ *  make every touched record un-prunable — the cap would quietly stop working.
+ *
+ *  An edit to a MAPPED field deliberately does not count: a feed is
+ *  one-directional, so the next refresh writes over it by design. The local
+ *  COLUMN is the durable half, and the half worth protecting. */
+export declare function hasLocalContent(item: CollectionItem, ingested: ReadonlySet<string>): boolean;
 /** Fetch one feed now, upsert its records, then enforce the maxItems cap.
  *  Failure-isolated: returns an errors array rather than throwing. */
 export declare function refreshOne(workspaceRoot: string, feed: LoadedCollection, opts?: {

package/dist/feeds/server/index.cjs

@@ -1,11 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("../../rolldown-runtime-D6vf50IK.cjs");
 const require_calendarGrid = require("../../calendarGrid-CaS9er8i.cjs");
-const require_discovery = require("../../discovery-NRy3tyUA.cjs");
-const require_server = require("../../server-7U-3DE2e.cjs");
+const require_project = require("../../project-CCtT_fQr.cjs");
+const require_discovery = require("../../discovery-DAoMnBYM.cjs");
+const require_server = require("../../server-B_b0bLSW.cjs");
 const require_feeds_paths = require("../paths.cjs");
 const require_ingestTypes = require("../../ingestTypes-D1GQdG8e.cjs");
-const require_notifier = require("../../notifier-tMsAXyXp.cjs");
+const require_notifier = require("../../notifier-C3IhYxqh.cjs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
 let node_crypto = require("node:crypto");
@@ -702,6 +703,60 @@ function writableFeedStore(workspaceRoot, feed) {
 		delete: remove
 	};
 }
+/** Fields the feed itself produces: what it actually returned this run, the
+*  declared map's targets, and the primary key the retriever derives. Anything
+*  else on a record got there some other way — the user.
+*
+*  Both sources, because neither alone is enough. The in-tree retrievers project
+*  through `map`, so it describes them exactly — but `registerRetriever` lets a
+*  host add one that returns whatever it likes, and only the observed keys catch
+*  that. Conversely a run that fetched nothing has no keys to observe, and only
+*  `map` keeps the cap working through it. */
+var ingestedFields = (items, mappedTargets, primaryKey) => /* @__PURE__ */ new Set([
+	primaryKey,
+	...mappedTargets,
+	...items.flatMap((item) => Object.keys(item))
+]);
+/** The collection fields a declarative `map` names. Read as `unknown` and
+*  narrowed here rather than through the zod-derived union, whose `map` does not
+*  survive the `kind` narrowing well enough to index safely. Only the keys are
+*  wanted, so the value type never has to be reconstructed. */
+function mappedTargetsOf(ingest) {
+	const map = ingest === void 0 || ingest.kind === "agent" ? void 0 : ingest.map;
+	return typeof map === "object" && map !== null ? Object.keys(map) : [];
+}
+/** Whether a record carries content the feed did not put there.
+*
+*  Only a NON-EMPTY value counts. A record saved through the UI can carry every
+*  declared field as an empty string, and treating those as local content would
+*  make every touched record un-prunable — the cap would quietly stop working.
+*
+*  An edit to a MAPPED field deliberately does not count: a feed is
+*  one-directional, so the next refresh writes over it by design. The local
+*  COLUMN is the durable half, and the half worth protecting. */
+function hasLocalContent(item, ingested) {
+	return Object.entries(item).some(([field, value]) => !ingested.has(field) && value !== void 0 && value !== null && value !== "");
+}
+/** The stored record, or null when it cannot be read.
+*
+*  `readItem` answers null for a MISSING record but THROWS on unparsable JSON
+*  or an IO error. Letting that escape would fail the whole refresh over one bad
+*  file — and write nothing at all, since the loop aborts partway. Before the
+*  merge landed, the ingest simply overwrote such a file and the feed healed
+*  itself; treating "unreadable" as "absent" keeps that. (Observed during Claude
+*  review; both review bots were rate-limited on this PR.) */
+async function readableRecord(store, feed, itemId) {
+	try {
+		return await store.read(itemId);
+	} catch (error) {
+		log.warn("feeds", "unreadable feed record — the retrieved item will replace it", {
+			slug: feed.slug,
+			itemId,
+			error: String(error)
+		});
+		return null;
+	}
+}
 async function upsertItems(workspaceRoot, feed, items) {
 	const store = writableFeedStore(workspaceRoot, feed);
 	if (!store) return 0;
@@ -709,7 +764,7 @@ async function upsertItems(workspaceRoot, feed, items) {
 	for (const item of items) {
 		const itemId = item[feed.schema.primaryKey];
 		if (typeof itemId !== "string" || itemId.length === 0) continue;
-		const result = await store.write(itemId, item);
+		const result = await store.write(itemId, require_project.mergeIntoExisting(await readableRecord(store, feed, itemId), item));
 		if (result.kind === "ok") written += 1;
 		else log.warn("feeds", "feed item write skipped", {
 			slug: feed.slug,
@@ -733,7 +788,7 @@ function recordTime(item, field) {
 /** Enforce `ingest.maxItems` (default 100): keep the newest N records by
 *  the schema's date field, delete the rest. No-op when the cap is 0/absent
 *  of a date field, or when under the cap. Returns the number deleted. */
-async function pruneFeed(workspaceRoot, feed) {
+async function pruneFeed(workspaceRoot, feed, fetched) {
 	const ingest = feedIngest(feed.schema);
 	const cap = (ingest && ingest.kind !== "agent" ? ingest.maxItems : void 0) ?? 100;
 	if (cap <= 0) return 0;
@@ -746,7 +801,15 @@ async function pruneFeed(workspaceRoot, feed) {
 	if (!store) return 0;
 	const items = await store.list();
 	if (items.length <= cap) return 0;
-	const stale = [...items].sort((left, right) => recordTime(right, dateField) - recordTime(left, dateField)).slice(cap);
+	const ingested = ingestedFields(fetched, mappedTargetsOf(ingest), feed.schema.primaryKey);
+	const aged = [...items].sort((left, right) => recordTime(right, dateField) - recordTime(left, dateField)).slice(cap);
+	const stale = aged.filter((item) => !hasLocalContent(item, ingested));
+	const kept = aged.length - stale.length;
+	if (kept > 0) log.info("feeds", "keeping aged-out records that carry local content", {
+		slug: feed.slug,
+		kept,
+		cap
+	});
 	let removed = 0;
 	for (const item of stale) {
 		const itemId = item[feed.schema.primaryKey];
@@ -789,7 +852,7 @@ async function refreshOne(workspaceRoot, feed, opts) {
 			cursor: result.cursor,
 			consecutiveFailures: 0
 		});
-		const removed = await pruneFeed(workspaceRoot, feed);
+		const removed = await pruneFeed(workspaceRoot, feed, result.items);
 		log.info("feeds", "feed refreshed", {
 			slug,
 			written,
@@ -919,8 +982,10 @@ exports.feedDir = require_feeds_paths.feedDir;
 exports.feedRefreshTaskDef = feedRefreshTaskDef;
 exports.feedStatePath = require_feeds_paths.feedStatePath;
 exports.feedsRoot = require_feeds_paths.feedsRoot;
+exports.hasLocalContent = hasLocalContent;
 exports.ingestStateDir = require_feeds_paths.ingestStateDir;
 exports.ingestStatePath = require_feeds_paths.ingestStatePath;
+exports.ingestedFields = ingestedFields;
 exports.isFeedSchedule = require_ingestTypes.isFeedSchedule;
 exports.listFeeds = listFeeds;
 exports.readFeedState = readFeedState;