@mulmoclaude/core 1.0.1 → 1.2.1

package/dist/dist-Cwk0e12G.js

@@ -0,0 +1,50 @@
+//#region ../common/dist/index.js
+/** Narrow `unknown` to a plain object (not null, not array). */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Check that a record has a specific key with a string value. */
+function hasStringProp(value, key) {
+	return isRecord(value) && typeof value[key] === "string";
+}
+/** 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`
+*  is server-only.
+*
+*  A non-Error object with a non-empty string `details` (gRPC convention) or
+*  `message` field surfaces that field — `details` wins — instead of the
+*  `[object Object]` a bare `String(err)` would print; an empty-string field
+*  falls through. `fallback` covers the error-boundary idiom where a thrown
+*  non-Error should read as a descriptive message rather than `String(err)`
+*  noise; omit it in logging contexts where `String(err)` is fine. */
+function errorMessage(err, fallback) {
+	if (err instanceof Error) return err.message;
+	if (hasStringProp(err, "details") && err.details) return err.details;
+	if (hasStringProp(err, "message") && err.message) return err.message;
+	if (fallback !== void 0) return fallback;
+	return String(err);
+}
+var HTML_ESCAPES = /* @__PURE__ */ new Map([
+	["&", "&"],
+	["<", "&lt;"],
+	[">", "&gt;"],
+	["\"", "&quot;"],
+	["'", "&#39;"]
+]);
+/** HTML-escape text destined for markup or an attribute value — the fixed
+*  five-character map, nothing more. Lives here rather than in
+*  `@mulmoclaude/core/wiki` (#2483) because `@mulmoclaude/markdown-utils` is a
+*  leaf that core depends on and so cannot import back up; core/wiki
+*  re-exports this, keeping its consumers' import path unchanged.
+*
+*  Escaping `&` first is what makes a single pass safe — the entities this
+*  introduces contain none of the other four characters, so nothing is
+*  double-escaped. Not a sanitiser: it neither strips tags nor validates URLs. */
+function escapeHtml(value) {
+	return value.replace(/[&<>"']/g, (char) => HTML_ESCAPES.get(char) ?? char);
+}
+//#endregion
+export { escapeHtml as n, errorMessage as t };
+
+//# sourceMappingURL=dist-Cwk0e12G.js.map

package/dist/dist-Cwk0e12G.js.map

@@ -0,0 +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"}

package/dist/dist-pWpC-b04.cjs

@@ -0,0 +1,61 @@
+//#region ../common/dist/index.js
+/** Narrow `unknown` to a plain object (not null, not array). */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Check that a record has a specific key with a string value. */
+function hasStringProp(value, key) {
+	return isRecord(value) && typeof value[key] === "string";
+}
+/** 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`
+*  is server-only.
+*
+*  A non-Error object with a non-empty string `details` (gRPC convention) or
+*  `message` field surfaces that field — `details` wins — instead of the
+*  `[object Object]` a bare `String(err)` would print; an empty-string field
+*  falls through. `fallback` covers the error-boundary idiom where a thrown
+*  non-Error should read as a descriptive message rather than `String(err)`
+*  noise; omit it in logging contexts where `String(err)` is fine. */
+function errorMessage(err, fallback) {
+	if (err instanceof Error) return err.message;
+	if (hasStringProp(err, "details") && err.details) return err.details;
+	if (hasStringProp(err, "message") && err.message) return err.message;
+	if (fallback !== void 0) return fallback;
+	return String(err);
+}
+var HTML_ESCAPES = /* @__PURE__ */ new Map([
+	["&", "&"],
+	["<", "&lt;"],
+	[">", "&gt;"],
+	["\"", "&quot;"],
+	["'", "&#39;"]
+]);
+/** HTML-escape text destined for markup or an attribute value — the fixed
+*  five-character map, nothing more. Lives here rather than in
+*  `@mulmoclaude/core/wiki` (#2483) because `@mulmoclaude/markdown-utils` is a
+*  leaf that core depends on and so cannot import back up; core/wiki
+*  re-exports this, keeping its consumers' import path unchanged.
+*
+*  Escaping `&` first is what makes a single pass safe — the entities this
+*  introduces contain none of the other four characters, so nothing is
+*  double-escaped. Not a sanitiser: it neither strips tags nor validates URLs. */
+function escapeHtml(value) {
+	return value.replace(/[&<>"']/g, (char) => HTML_ESCAPES.get(char) ?? char);
+}
+//#endregion
+Object.defineProperty(exports, "errorMessage", {
+	enumerable: true,
+	get: function() {
+		return errorMessage;
+	}
+});
+Object.defineProperty(exports, "escapeHtml", {
+	enumerable: true,
+	get: function() {
+		return escapeHtml;
+	}
+});
+
+//# sourceMappingURL=dist-pWpC-b04.cjs.map

package/dist/dist-pWpC-b04.cjs.map

@@ -0,0 +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"}

package/dist/feeds/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_ids = require("../ids-DWmHjm17.cjs");
-const require_ingestTypes = require("../ingestTypes-DbuQNuK6.cjs");
+const require_ids = require("../ids-BnTh3Hl0.cjs");
+const require_ingestTypes = require("../ingestTypes-xX8VpQqh.cjs");
 exports.AGENT_INGEST_KIND = require_ingestTypes.AGENT_INGEST_KIND;
 exports.DEFAULT_FEED_MAX_ITEMS = require_ingestTypes.DEFAULT_FEED_MAX_ITEMS;
 exports.FEED_SCHEDULES = require_ids.FEED_SCHEDULES;

package/dist/feeds/index.js

@@ -1,3 +1,3 @@
-import { c as INGEST_KINDS, s as FEED_SCHEDULES } from "../ids-D1M1T6KJ.js";
-import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../ingestTypes-Ci4eOgv-.js";
+import { l as FEED_SCHEDULES, u as INGEST_KINDS } from "../ids-s4GfmE93.js";
+import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../ingestTypes-L59cIGgX.js";
 export { AGENT_INGEST_KIND, DEFAULT_FEED_MAX_ITEMS, FEED_SCHEDULES, INGEST_KINDS, isFeedSchedule };

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

@@ -1,3 +1,4 @@
+import { StructuredLogger } from '../../host/hostSlot.js';
 /** Outcome of launching one hidden/visible agent-ingest worker. `chatId` lets
  *  the caller register a completion hook so a failed refresh doesn't die
  *  silently. */
@@ -23,13 +24,8 @@ export type AgentWorkerRunner = (args: {
         didError: boolean;
     }) => void | Promise<void>;
 }) => Promise<AgentWorkerResult>;
-/** Structured logger, `(prefix, msg, data?)` — same shape as `CollectionLogger`. */
-export interface FeedsLogger {
-    error: (prefix: string, message: string, data?: Record<string, unknown>) => void;
-    warn: (prefix: string, message: string, data?: Record<string, unknown>) => void;
-    info: (prefix: string, message: string, data?: Record<string, unknown>) => void;
-    debug: (prefix: string, message: string, data?: Record<string, unknown>) => void;
-}
+/** Public alias of the shared `StructuredLogger` — same shape as `CollectionLogger`. */
+export type FeedsLogger = StructuredLogger;
 export interface FeedsHost {
     /** Absolute workspace root — the default for `refreshDue()` and state paths. */
     workspaceRoot: string;
@@ -47,5 +43,6 @@ export declare function requireFeedsHost(): FeedsHost;
 /** Test-only: clear the configured host. */
 export declare function resetFeedsHostForTesting(): void;
 /** Forwarding logger so engine modules can `import { log }` without each
- *  reaching for `requireFeedsHost().log`. */
+ *  reaching for `requireFeedsHost().log`. Non-critical: calls before the host
+ *  is wired are dropped (not thrown), matching the collection/google seams. */
 export declare const log: FeedsLogger;

package/dist/feeds/server/index.cjs

@@ -1,43 +1,37 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("../../rolldown-runtime-D6vf50IK.cjs");
-const require_ids = require("../../ids-DWmHjm17.cjs");
-const require_discovery = require("../../discovery-Dpz6SWwe.cjs");
-require("../../server-BjWrcc5T.cjs");
-const require_ingestTypes = require("../../ingestTypes-DbuQNuK6.cjs");
+const require_ids = require("../../ids-BnTh3Hl0.cjs");
+const require_discovery = require("../../discovery--kRUWed0.cjs");
+const require_server = require("../../server-w5ZZRLju.cjs");
+const require_ingestTypes = require("../../ingestTypes-xX8VpQqh.cjs");
 const require_feeds_paths = require("../paths.cjs");
-const require_notifier = require("../../notifier-bS8IEeLA.cjs");
+const require_notifier = require("../../notifier-tMsAXyXp.cjs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
-let node_fs_promises = require("node:fs/promises");
 let node_crypto = require("node:crypto");
+let node_fs_promises = require("node:fs/promises");
 let node_dns_promises = require("node:dns/promises");
 let node_net = require("node:net");
 let fast_xml_parser = require("fast-xml-parser");
 let _receptron_task_scheduler = require("@receptron/task-scheduler");
 //#region src/feeds/server/host.ts
-var current = null;
+var hostSlot = require_discovery.createHostSlot("@mulmoclaude/core/feeds: configureFeedsHost()");
 /** Wire the feeds engine to a host. Call once at startup, before any refresh. */
 function configureFeedsHost(host) {
-	if (current && current !== host) throw new Error("@mulmoclaude/core/feeds: configureFeedsHost() was already called with a different host");
-	current = host;
+	hostSlot.set(host);
 }
 /** The configured host, or throw if `configureFeedsHost` was never called. */
 function requireFeedsHost() {
-	if (!current) throw new Error("@mulmoclaude/core/feeds: configureFeedsHost() was not called by the host");
-	return current;
+	return hostSlot.get();
 }
 /** Test-only: clear the configured host. */
 function resetFeedsHostForTesting() {
-	current = null;
+	hostSlot.reset();
 }
 /** Forwarding logger so engine modules can `import { log }` without each
-*  reaching for `requireFeedsHost().log`. */
-var log = {
-	error: (prefix, msg, data) => requireFeedsHost().log.error(prefix, msg, data),
-	warn: (prefix, msg, data) => requireFeedsHost().log.warn(prefix, msg, data),
-	info: (prefix, msg, data) => requireFeedsHost().log.info(prefix, msg, data),
-	debug: (prefix, msg, data) => requireFeedsHost().log.debug(prefix, msg, data)
-};
+*  reaching for `requireFeedsHost().log`. Non-critical: calls before the host
+*  is wired are dropped (not thrown), matching the collection/google seams. */
+var log = require_discovery.createForwardingLogger(() => hostSlot.peek()?.log ?? null);
 //#endregion
 //#region src/feeds/server/registry.ts
 /** Every registered feed, as a discovered collection (carrying its
@@ -87,69 +81,156 @@ function getRetriever(kind) {
 	return registry.get(kind);
 }
 //#endregion
-//#region src/feeds/server/fetch/httpClient.ts
-var ONE_SECOND_MS = 1e3;
-/** Identifies the bot to site operators. */
-var FEED_USER_AGENT = "MulmoClaude-FeedBot/1.0 (+https://github.com/receptron/mulmoclaude)";
-/** Per-request wall-clock cap so a hung server can't wedge a refresh. */
-var DEFAULT_FEED_TIMEOUT_MS = 30 * ONE_SECOND_MS;
-/** Cap on redirect hops followed (each re-checked for SSRF). */
-var MAX_REDIRECTS = 5;
-var BLOCKED_V4_CIDRS = [
+//#region ../common/dist/ssrf.js
+var ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+var BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
+	"localhost",
+	"ip6-localhost",
+	"ip6-loopback"
+]);
+var BLOCKED_HOSTNAME_SUFFIXES = [
+	".localhost",
+	".local",
+	".internal"
+];
+/** IPv4 ranges that must never be fetched, as [firstAddress, prefixLength].
+*  The union of the pre-#2459 per-guard tables — removing an entry weakens
+*  every guard in the repo at once, so treat edits as security changes. */
+var BLOCKED_IPV4_RANGES = [
 	["0.0.0.0", 8],
 	["10.0.0.0", 8],
 	["100.64.0.0", 10],
 	["127.0.0.0", 8],
 	["169.254.0.0", 16],
 	["172.16.0.0", 12],
-	["192.168.0.0", 16]
+	["192.0.0.0", 24],
+	["192.168.0.0", 16],
+	["198.18.0.0", 15],
+	["224.0.0.0", 4],
+	["240.0.0.0", 4]
 ];
+/** Dotted-decimal IPv4 → unsigned 32-bit value; null for anything else
+*  (hex / octal octets, whitespace, wrong part count). */
 function ipv4ToInt(address) {
-	const octets = address.split(".").map(Number);
-	if (octets.length !== 4 || octets.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return null;
-	return (octets[0] << 24 | octets[1] << 16 | octets[2] << 8 | octets[3]) >>> 0;
+	const parts = address.split(".");
+	if (parts.length !== 4) return null;
+	const octets = parts.map((part) => /^\d{1,3}$/.test(part) ? Number(part) : NaN);
+	if (octets.some((octet) => Number.isNaN(octet) || octet > 255)) return null;
+	return octets.reduce((value, octet) => value * 256 + octet, 0);
+}
+function isBlockedIpv4Value(value) {
+	return BLOCKED_IPV4_RANGES.some(([base, prefix]) => {
+		const baseValue = ipv4ToInt(base);
+		if (baseValue === null) return false;
+		const mask = prefix === 0 ? 0 : -1 << 32 - prefix >>> 0;
+		return (value & mask) === (baseValue & mask);
+	});
 }
+/** True when this parses as IPv4 AND falls inside a blocked range. Non-IPv4
+*  input is false — "not a blocked literal", not "safe"; a caller that must
+*  reject non-IP input entirely does so at its own boundary. */
 function isBlockedIpv4(address) {
 	const value = ipv4ToInt(address);
-	if (value === null) return true;
-	return BLOCKED_V4_CIDRS.some(([base, bits]) => {
-		const baseInt = ipv4ToInt(base) ?? 0;
-		const mask = bits === 0 ? 0 : 4294967295 << 32 - bits >>> 0;
-		return (value & mask) === (baseInt & mask);
-	});
+	if (value === null) return false;
+	return isBlockedIpv4Value(value);
+}
+/** `URL.hostname` keeps the brackets on an IPv6 literal (`[::1]`); strip them
+*  so the address checks see the bare address. */
+function stripIpv6Brackets(hostname) {
+	return hostname.replace(/^\[|\]$/g, "");
+}
+/** The 32-bit value inside an IPv4-mapped IPv6 literal, or null when the
+*  address is not v4-mapped. The hex spelling matters: WHATWG URL serializes
+*  `[::ffff:127.0.0.1]` as `::ffff:7f00:1`, so matching only the dotted form
+*  would wave the mapped loopback through any URL-sourced check. */
+function mappedIpv4Value(lower) {
+	const dotted = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
+	if (dotted) return ipv4ToInt(dotted[1]);
+	const hex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(lower);
+	if (hex) return Number.parseInt(hex[1], 16) * 65536 + Number.parseInt(hex[2], 16);
+	return null;
 }
+/** Blocks loopback/unspecified, fc00::/7 unique-local, fe80::/10 link-local,
+*  and IPv4-mapped forms of blocked v4 addresses. Mask-based on the leading
+*  group — prefix string matching would miss e.g. fe9a:: (inside fe80::/10). */
 function isBlockedIpv6(address) {
-	const lower = address.toLowerCase();
+	const lower = stripIpv6Brackets(address.toLowerCase());
 	if (lower === "::1" || lower === "::") return true;
-	if (lower.startsWith("fe80")) return true;
-	if (lower.startsWith("fc") || lower.startsWith("fd")) return true;
-	const mapped = /^::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.exec(lower);
-	return mapped ? isBlockedIpv4(mapped[1]) : false;
-}
-/** True for any address we must not fetch (also blocks non-IP input). */
+	const mapped = mappedIpv4Value(lower);
+	if (mapped !== null) return isBlockedIpv4Value(mapped);
+	const [head] = lower.split(":");
+	if (head.length === 0) return false;
+	const leading = Number.parseInt(head, 16);
+	if (Number.isNaN(leading)) return false;
+	if ((leading & 65024) === 64512) return true;
+	if ((leading & 65472) === 65152) return true;
+	return false;
+}
+/** True when this literal address must never be fetched. Non-IP input is
+*  false — see `isBlockedIpv4`. */
 function isBlockedIp(address) {
+	return address.includes(":") ? isBlockedIpv6(address) : isBlockedIpv4(address);
+}
+/** Names that are internal by convention (localhost, *.local, *.internal…),
+*  rejected without waiting for DNS to prove it. */
+function isBlockedHostname(hostname) {
+	const lower = hostname.toLowerCase().replace(/\.$/, "");
+	if (BLOCKED_HOSTNAMES.has(lower)) return true;
+	return BLOCKED_HOSTNAME_SUFFIXES.some((suffix) => lower.endsWith(suffix));
+}
+function parseUrl(raw) {
+	try {
+		return new URL(raw);
+	} catch {
+		return null;
+	}
+}
+/** Parse and apply every check that doesn't need the network: shape, scheme,
+*  obviously-internal hostname, and literal addresses. Returns null on reject.
+*  Callers must still vet what non-literal hostnames resolve to. */
+function parseSafeUrlShape(raw) {
+	const url = parseUrl(raw);
+	if (url === null) return null;
+	if (!ALLOWED_PROTOCOLS.has(url.protocol)) return null;
+	const hostname = stripIpv6Brackets(url.hostname);
+	if (hostname.length === 0) return null;
+	if (isBlockedHostname(hostname)) return null;
+	if (isBlockedIp(hostname)) return null;
+	return url;
+}
+//#endregion
+//#region src/feeds/server/fetch/httpClient.ts
+var ONE_SECOND_MS = 1e3;
+/** Identifies the bot to site operators. */
+var FEED_USER_AGENT = "MulmoClaude-FeedBot/1.0 (+https://github.com/receptron/mulmoclaude)";
+/** Per-request wall-clock cap so a hung server can't wedge a refresh. */
+var DEFAULT_FEED_TIMEOUT_MS = 30 * ONE_SECOND_MS;
+/** Cap on redirect hops followed (each re-checked for SSRF). */
+var MAX_REDIRECTS = 5;
+/** DNS answers should be IP literals; anything else is blocked outright. */
+function isBlockedResolvedIp(address) {
 	const kind = (0, node_net.isIP)(address);
 	if (kind === 4) return isBlockedIpv4(address);
 	if (kind === 6) return isBlockedIpv6(address);
 	return true;
 }
-/** Reject non-http(s) URLs and URLs that resolve to a private/loopback
-*  address (SSRF guard). Throws with a clear reason; returns void on pass. */
-async function assertFetchableUrl(rawUrl) {
-	if (!/^https?:\/\//i.test(rawUrl)) throw new Error(`refusing non-http(s) URL: ${rawUrl}`);
-	const { hostname } = new URL(rawUrl);
-	const host = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
-	if ((0, node_net.isIP)(host)) {
-		if (isBlockedIp(host)) throw new Error(`refusing to fetch a private/loopback address: ${host}`);
-		return;
-	}
-	let addresses;
+async function resolveAddresses(host) {
 	try {
-		addresses = await (0, node_dns_promises.lookup)(host, { all: true });
+		return await (0, node_dns_promises.lookup)(host, { all: true });
 	} catch (err) {
 		throw new Error(`could not resolve host '${host}': ${String(err)}`);
 	}
-	const blocked = addresses.find((entry) => isBlockedIp(entry.address));
+}
+/** Reject non-http(s) URLs, internal-by-convention hostnames, and URLs whose
+*  host is / resolves to a private/loopback address (SSRF guard). Throws with
+*  a clear reason; returns void on pass. */
+async function assertFetchableUrl(rawUrl) {
+	if (!/^https?:\/\//i.test(rawUrl)) throw new Error(`refusing non-http(s) URL: ${rawUrl}`);
+	const url = parseSafeUrlShape(rawUrl);
+	if (url === null) throw new Error(`refusing to fetch a private/loopback/internal address: ${rawUrl}`);
+	const host = stripIpv6Brackets(url.hostname);
+	if ((0, node_net.isIP)(host)) return;
+	const blocked = (await resolveAddresses(host)).find((entry) => isBlockedResolvedIp(entry.address));
 	if (blocked) throw new Error(`refusing to fetch '${host}' — resolves to a private/loopback address (${blocked.address})`);
 }
 async function fetchOnce(url, timeoutMs) {
@@ -308,7 +389,8 @@ function step(current, token) {
 	if (current === null || current === void 0) return void 0;
 	if (token.kind === "key") {
 		if (typeof current !== "object" || Array.isArray(current)) return void 0;
-		return current[token.key];
+		const record = current;
+		return Object.hasOwn(record, token.key) ? record[token.key] : void 0;
 	}
 	return Array.isArray(current) ? current[token.index] : void 0;
 }
@@ -497,10 +579,10 @@ async function refreshViaAgent(workspaceRoot, collection, opts) {
 	if (!ingest || ingest.kind !== "agent") return result(slug, { errors: ["collection has no agent ingest config"] });
 	const workerRunner = workerRunnerOrNull();
 	if (!workerRunner) return result(slug, { errors: ["agent ingest worker runner not configured"] });
-	const template = await require_discovery.readSkillTemplate(collection.skillDir, ingest.template);
+	const template = await require_server.readSkillTemplate(collection.skillDir, ingest.template);
 	if (template === null) return result(slug, { errors: [`ingest template '${ingest.template}' could not be read`] });
 	const items = await require_discovery.listItems(collection.dataDir, { workspaceRoot });
-	const message = require_discovery.buildCollectionActionSeedPrompt(items, collection.schema, template, require_discovery.promptPathsFor(collection, workspaceRoot));
+	const message = require_server.buildCollectionActionSeedPrompt(items, collection.schema, template, require_server.promptPathsFor(collection, workspaceRoot));
 	let launch;
 	try {
 		launch = await workerRunner({