@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.921

package/dist/repertoire/house-sweep.js

@@ -0,0 +1,469 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sameUtcDay = exports.writeLedger = exports.readLastDigestAt = exports.readLedger = exports.recallSweep = exports.rememberSweep = exports.ledgerPath = exports.progressPath = exports.houseSweepDir = exports.safe = exports.clip = exports.LIST_CAP = exports.REMIND_DAYS = exports.GRANT_WARNING_DAYS = exports.FAILED_HISTORY_DAYS = exports.MISSING_GRACE_DAYS = exports.PARITY_MAX_AGE_DAYS = exports.TEMPERATURE_C = exports.CRITICAL_CAPACITY_PERCENT = exports.CAPACITY_PERCENT = exports.STALL_MIN_AGE_HOURS = void 0;
+exports.queueProblem = queueProblem;
+exports.runHouseSweep = runHouseSweep;
+exports.draftDigest = draftDigest;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const friends_1 = require("@ouro.bot/friends");
+const runtime_1 = require("../nerves/runtime");
+const steward_policy_1 = require("../heart/steward-policy");
+const delegated_command_grants_1 = require("../a2a/delegated-command-grants");
+const escalation_grants_1 = require("../a2a/escalation-grants");
+/**
+ * The Butler's daily house-care sweep, gathered in one deterministic read so the model does not chain a dozen calls:
+ * stalled or failed downloads and missing episodes and movies (Sonarr and Radarr), failed imports, disk and parity,
+ * container state against the steward policy, and grants that expire or no longer work. It changes nothing in the
+ * house. Its only writes are its own bookkeeping under `state/house-sweep/`: when each queue item last moved, and
+ * which findings the owner has already been told about, so a repeat finding is not repeated unless it changed.
+ */
+exports.STALL_MIN_AGE_HOURS = 6;
+exports.CAPACITY_PERCENT = 90;
+exports.CRITICAL_CAPACITY_PERCENT = 98;
+exports.TEMPERATURE_C = 50;
+exports.PARITY_MAX_AGE_DAYS = 45;
+exports.MISSING_GRACE_DAYS = 3;
+exports.FAILED_HISTORY_DAYS = 3;
+exports.GRANT_WARNING_DAYS = 7;
+exports.REMIND_DAYS = 7;
+exports.LIST_CAP = 8;
+const HOUR_MS = 3_600_000;
+const DAY_MS = 86_400_000;
+const dict = (value) => (value && typeof value === "object" && !Array.isArray(value) ? value : {});
+const list = (value) => (Array.isArray(value) ? value : []);
+const text = (value) => (typeof value === "string" ? value : "");
+const num = (value) => (typeof value === "number" && Number.isFinite(value) ? value : null);
+const lower = (value) => text(value).toLowerCase();
+const clip = (value, max) => (value.length > max ? `${value.slice(0, max - 3)}...` : value);
+exports.clip = clip;
+/** Names and messages come from outside (release titles, friend names): strip control characters, newlines and links before they can reach a digest. */
+const safe = (value) => value.replace(/mailto:\S*/giu, "").replace(/[\u200b-\u200f\u202a-\u202e\u2060-\u206f\ufeff]/gu, "").replace(/\b[a-z][a-z0-9+.-]*:\/\/\S*/giu, "").replace(/[\u0000-\u001f\u007f-\u009f]+/gu, " ").replace(/\s+/gu, " ").trim();
+exports.safe = safe;
+const fingerprintOf = (id, detail) => (0, node_crypto_1.createHash)("sha256").update(`${id}\0${detail}`).digest("hex").slice(0, 12);
+// ---- bookkeeping -------------------------------------------------------------------------------------------------
+const houseSweepDir = (agentRoot) => path.join(agentRoot, "state", "house-sweep");
+exports.houseSweepDir = houseSweepDir;
+function readJson(file) {
+    try {
+        return dict(JSON.parse(fs.readFileSync(file, "utf8")));
+    }
+    catch {
+        return {};
+    }
+}
+function writeJson(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+const progressPath = (agentRoot) => path.join((0, exports.houseSweepDir)(agentRoot), "queue-progress.json");
+exports.progressPath = progressPath;
+const ledgerPath = (agentRoot) => path.join((0, exports.houseSweepDir)(agentRoot), "reported.json");
+exports.ledgerPath = ledgerPath;
+const lastSweeps = new Map();
+const rememberSweep = (agentRoot, scope, findings) => { lastSweeps.set(`${path.resolve(agentRoot)}\0${scope}`, findings.map(({ id, fingerprint, summary }) => ({ id, fingerprint, summary }))); };
+exports.rememberSweep = rememberSweep;
+const recallSweep = (agentRoot, scope) => lastSweeps.get(`${path.resolve(agentRoot)}\0${scope}`);
+exports.recallSweep = recallSweep;
+const readLedger = (agentRoot) => dict(readJson((0, exports.ledgerPath)(agentRoot)).entries);
+exports.readLedger = readLedger;
+/** When the last live digest went out (ISO), or "" when none has. Kept beside the ledger so a retry or a second path cannot send two in a day. */
+const readLastDigestAt = (agentRoot) => text(readJson((0, exports.ledgerPath)(agentRoot)).lastDigestAt);
+exports.readLastDigestAt = readLastDigestAt;
+const writeLedger = (agentRoot, entries, lastDigestAt = (0, exports.readLastDigestAt)(agentRoot)) => writeJson((0, exports.ledgerPath)(agentRoot), { schemaVersion: 1, entries, ...(lastDigestAt ? { lastDigestAt } : {}) });
+exports.writeLedger = writeLedger;
+const sameUtcDay = (a, b) => a.length > 0 && a.slice(0, 10) === b.slice(0, 10);
+exports.sameUtcDay = sameUtcDay;
+function readCredentials(file) {
+    const parsed = readJson(file);
+    const pick = (name) => {
+        const entry = dict(parsed[name]);
+        return text(entry.url) && text(entry.apiKey) ? { url: text(entry.url).replace(/\/+$/u, ""), apiKey: text(entry.apiKey) } : null;
+    };
+    return { sonarr: pick("sonarr"), radarr: pick("radarr") };
+}
+async function arrGet(service, creds, pathAndQuery, fetchImpl) {
+    const response = await fetchImpl(`${creds.url}/api/v3${pathAndQuery}`, { headers: { "X-Api-Key": creds.apiKey, Accept: "application/json" }, signal: AbortSignal.timeout(20_000) });
+    if (!response.ok)
+        throw new Error(`${service} answered HTTP ${response.status}`);
+    return response.json();
+}
+const records = (payload) => (Array.isArray(payload) ? payload : list(dict(payload).records)).map(dict);
+/** The same notion of "stuck" the replay gate applies to a queue record: Sonarr flags it, or a partial download with no ETA has sat for hours. */
+function queueProblem(item, nowMs) {
+    const flagged = (value) => ["warning", "error", "failed"].includes(lower(value));
+    const messages = list(item.statusMessages).flatMap((entry) => [text(dict(entry).title), ...list(dict(entry).messages).map(text)]).filter(Boolean);
+    const errorMessage = text(item.errorMessage);
+    if (flagged(item.trackedDownloadStatus) || flagged(item.status) || messages.length > 0) {
+        return (0, exports.clip)(errorMessage || messages[0] || `status ${text(item.trackedDownloadStatus) || text(item.status)}`, 140);
+    }
+    const size = num(item.size) ?? 0;
+    const left = num(item.sizeleft) ?? 0;
+    const noEta = item.timeleft === undefined || item.timeleft === null || item.timeleft === "00:00:00";
+    const addedAt = Date.parse(text(item.added));
+    if (size > 0 && left > 0 && noEta && Number.isFinite(addedAt) && nowMs - addedAt >= exports.STALL_MIN_AGE_HOURS * HOUR_MS)
+        return "partial download with no ETA";
+    return null;
+}
+const nameOf = (service, item) => text(service === "sonarr" ? dict(item.series).title : dict(item.movie).title) || text(item.title) || "an unknown title";
+function summarizeArr(service, queuePayload, missingPayload, historyPayload, nowMs, progress, nextProgress) {
+    const label = service === "sonarr" ? "Sonarr" : "Radarr";
+    const items = records(queuePayload);
+    const findings = [];
+    let stalled = 0;
+    let importProblems = 0;
+    const inFlight = new Set();
+    for (const item of items) {
+        const queueId = num(item.id);
+        if (queueId === null)
+            continue;
+        const subjectId = num(service === "sonarr" ? item.seriesId : item.movieId);
+        if (subjectId !== null)
+            inFlight.add(subjectId);
+        const key = `${service}:${queueId}`;
+        const left = num(item.sizeleft) ?? 0;
+        const previous = dict(progress[key]);
+        const since = previous.sizeleft === left && Number.isFinite(Date.parse(text(previous.since))) ? text(previous.since) : new Date(nowMs).toISOString();
+        nextProgress[key] = { sizeleft: left, since };
+        const frozen = left > 0 && nowMs - Date.parse(since) >= exports.STALL_MIN_AGE_HOURS * HOUR_MS;
+        const problem = queueProblem(item, nowMs) ?? (frozen ? `no progress for ${Math.floor((nowMs - Date.parse(since)) / HOUR_MS)}h` : null);
+        const importState = lower(item.trackedDownloadState);
+        const importBlocked = importState === "importfailed" || importState === "importblocked";
+        if (problem === null && !importBlocked)
+            continue;
+        const size = num(item.size) ?? 0;
+        const percent = size > 0 ? Math.round(((size - left) / size) * 100) : 0;
+        const name = nameOf(service, item);
+        const release = (0, exports.clip)(text(item.title), 80);
+        const refs = { service, queueId };
+        if (importBlocked) {
+            importProblems += 1;
+            const id = `imports:${service}:${queueId}`;
+            findings.push({ id, area: "imports", severity: "warn", next: "owner", refs, summary: `${label} cannot import ${name} (${release}): ${problem ?? importState}`, fingerprint: fingerprintOf(id, importState) });
+            continue;
+        }
+        stalled += 1;
+        const id = `downloads:${service}:${queueId}`;
+        const series = service === "sonarr" && subjectId !== null;
+        findings.push({
+            id, area: "downloads", severity: "warn", refs,
+            next: series ? "fix" : "owner",
+            summary: `${label} download of ${name} is stuck at ${percent}% (${release}): ${problem}`,
+            fingerprint: fingerprintOf(id, problem.startsWith("no progress") ? "frozen" : problem),
+            ...(series ? { fix: { tool: "media_fill_missing", args: { service_id: subjectId }, note: "keeps the partial download; replaces it only when a seeded alternative is grabbed" } } : {}),
+        });
+    }
+    // Failed downloads Sonarr or Radarr recorded recently (the queue row is gone, the episode or movie may still be missing).
+    for (const event of records(historyPayload)) {
+        const when = Date.parse(text(event.date));
+        const eventId = num(event.id);
+        if (eventId === null || !Number.isFinite(when) || nowMs - when > exports.FAILED_HISTORY_DAYS * DAY_MS)
+            continue;
+        const subjectId = num(service === "sonarr" ? event.seriesId : event.movieId);
+        if (subjectId !== null && inFlight.has(subjectId))
+            continue;
+        const id = `downloads:${service}:failed:${eventId}`;
+        const series = service === "sonarr" && subjectId !== null;
+        findings.push({
+            id, area: "downloads", severity: "warn", next: series ? "fix" : "owner",
+            summary: `${label} recorded a failed download: ${(0, exports.clip)(text(event.sourceTitle), 90)}`,
+            fingerprint: fingerprintOf(id, "failed"),
+            ...(series ? { fix: { tool: "media_fill_missing", args: { service_id: subjectId }, note: "looks for another release" } } : {}),
+        });
+    }
+    // Monitored but missing, and not already on its way.
+    const cutoff = nowMs - exports.MISSING_GRACE_DAYS * DAY_MS;
+    const missingBySubject = new Map();
+    for (const row of records(missingPayload)) {
+        if (service === "radarr" && row.isAvailable === false)
+            continue;
+        const subjectId = service === "sonarr" ? num(row.seriesId) : num(row.id);
+        const stamp = Date.parse(text(service === "sonarr" ? row.airDateUtc : row.added));
+        if (subjectId === null || inFlight.has(subjectId) || row.monitored === false || !Number.isFinite(stamp) || stamp > cutoff)
+            continue;
+        const name = (service === "sonarr" ? text(dict(row.series).title) : text(row.title)) || "an unknown title";
+        const seen = missingBySubject.get(subjectId);
+        missingBySubject.set(subjectId, { name, count: (seen?.count ?? 0) + 1, oldest: Math.min(seen?.oldest ?? stamp, stamp) });
+    }
+    for (const [subjectId, entry] of [...missingBySubject].sort((a, b) => a[1].oldest - b[1].oldest)) {
+        const id = `missing:${service}:${subjectId}`;
+        const series = service === "sonarr";
+        const days = Math.floor((nowMs - entry.oldest) / DAY_MS);
+        findings.push({
+            id, area: "missing", severity: "info", next: "fix",
+            summary: series ? `${entry.name}: ${entry.count} monitored episode${entry.count === 1 ? "" : "s"} missing, the oldest aired ${days} days ago` : `${entry.name}: monitored movie still missing after ${days} days`,
+            fingerprint: fingerprintOf(id, String(entry.count)),
+            fix: series
+                ? { tool: "media_fill_missing", args: { service_id: subjectId }, note: "searches, grabs a seeded release, imports what finished" }
+                : { tool: "media_search_now", args: { kind: "movie", service_id: subjectId }, note: "triggers a Radarr search" },
+        });
+    }
+    return { queue: { total: items.length, stalled, importProblems }, findings };
+}
+// ---- the host, the policy and the grants -------------------------------------------------------------------------
+function okData(result) {
+    const value = dict(result);
+    return value.ok === true ? dict(value.data) : null;
+}
+async function sweepHost(sanctuary, policyStates, nowMs, findings) {
+    const [containersResult, storageResult, disksResult] = await Promise.all([sanctuary.listContainers(), sanctuary.getStorage(), sanctuary.getDisks()]);
+    const containers = okData(containersResult);
+    const storage = okData(storageResult);
+    const disks = okData(disksResult);
+    const unavailable = [containers ? "" : "containers", storage ? "" : "storage", disks ? "" : "disks"].filter(Boolean);
+    const summary = { array: null, arrayUsedPercent: null, parity: null, parityAgeDays: null, containers: 0 };
+    for (const container of list(containers?.containers).map(dict)) {
+        summary.containers += 1;
+        const name = text(container.name);
+        const state = text(container.state);
+        const desired = policyStates ? dict(policyStates[`container:${name}`]) : {};
+        const expires = Date.parse(text(desired.expiresAt));
+        const value = Object.keys(desired).length > 0 && !(Number.isFinite(expires) && expires <= nowMs) ? lower(desired.value) : "";
+        const wantedOn = ["on", "always_on", "expected_on"].includes(value);
+        const wantedOff = /^(?:off|disabled|paused|intentionally_off|intentionally_paused)$/u.test(value);
+        const running = state === "running";
+        const id = `containers:${name}`;
+        if (wantedOn && !running)
+            findings.push({ id, area: "containers", severity: "critical", next: "owner", summary: `${name} should be on by the steward policy but is ${state}`, fingerprint: fingerprintOf(id, `down:${state}`) });
+        else if (wantedOff && running)
+            findings.push({ id, area: "containers", severity: "warn", next: "owner", summary: `${name} should be off by the steward policy but is running`, fingerprint: fingerprintOf(id, "up") });
+        else if (!value && container.autostart === true && !running)
+            findings.push({ id, area: "containers", severity: "warn", next: "owner", summary: `${name} starts with the array but is ${state}, and the policy says nothing about it`, fingerprint: fingerprintOf(id, `down:${state}`) });
+    }
+    const arrayInfo = dict(storage?.array);
+    summary.array = text(arrayInfo.state) || null;
+    summary.arrayUsedPercent = num(arrayInfo.usedPercent);
+    const capacity = (id, label, percent) => {
+        if (percent === null || percent < exports.CAPACITY_PERCENT)
+            return;
+        findings.push({ id, area: "disk", severity: percent >= exports.CRITICAL_CAPACITY_PERCENT ? "critical" : "warn", next: "owner", summary: `${label} is ${percent}% full`, fingerprint: fingerprintOf(id, String(Math.floor(percent))) });
+    };
+    capacity("disk:array:capacity", "the array", summary.arrayUsedPercent);
+    for (const share of list(storage?.shares).map(dict))
+        capacity(`disk:share:${text(share.name)}:capacity`, `share ${text(share.name)}`, num(share.usedPercent));
+    if (storage && summary.array && summary.array.toUpperCase() !== "STARTED")
+        findings.push({ id: "disk:array:state", area: "disk", severity: "critical", next: "owner", summary: `the array is ${summary.array}`, fingerprint: fingerprintOf("disk:array:state", summary.array) });
+    for (const disk of list(disks?.disks).map(dict)) {
+        const id = `disk:${text(disk.id)}`;
+        if (disk.smart === "failed")
+            findings.push({ id: `${id}:smart`, area: "disk", severity: "critical", next: "owner", summary: `${text(disk.name)} reports a failed SMART status`, fingerprint: fingerprintOf(`${id}:smart`, "failed") });
+        const temperature = num(disk.temperatureC);
+        if (temperature !== null && temperature >= exports.TEMPERATURE_C)
+            findings.push({ id: `${id}:temperature`, area: "disk", severity: "warn", next: "owner", summary: `${text(disk.name)} is ${temperature}C`, fingerprint: fingerprintOf(`${id}:temperature`, String(Math.floor(temperature / 5))) });
+    }
+    const parity = dict(disks?.parity);
+    summary.parity = text(parity.result) || null;
+    const ageHours = num(parity.ageHours);
+    summary.parityAgeDays = ageHours === null ? null : Math.floor(ageHours / 24);
+    if (disks) {
+        const result = summary.parity;
+        if (result === "failed")
+            findings.push({ id: "parity:result", area: "parity", severity: "critical", next: "owner", summary: `the last parity check failed (${num(parity.errors) ?? "unknown"} errors)`, fingerprint: fingerprintOf("parity:result", `failed:${num(parity.errors)}`) });
+        else if (result !== "in_progress" && (summary.parityAgeDays === null || summary.parityAgeDays >= exports.PARITY_MAX_AGE_DAYS))
+            findings.push({ id: "parity:age", area: "parity", severity: "warn", next: "owner", summary: summary.parityAgeDays === null ? "parity check age is unknown" : `the last parity check was ${summary.parityAgeDays} days ago`, fingerprint: fingerprintOf("parity:age", summary.parityAgeDays === null ? "unknown" : "old") });
+    }
+    return { summary, problem: unavailable.length > 0 ? `${unavailable.join(", ")} unreadable` : null };
+}
+async function sweepGrants(agentRoot, policy, nowMs, findings) {
+    const expiry = (id, label, expiresAt) => {
+        const at = Date.parse(text(expiresAt));
+        if (!Number.isFinite(at) || at - nowMs > exports.GRANT_WARNING_DAYS * DAY_MS)
+            return;
+        const days = Math.floor((at - nowMs) / DAY_MS);
+        findings.push({ id, area: "grants", severity: at <= nowMs ? "warn" : "info", next: "owner", summary: at <= nowMs ? `${label} expired` : `${label} expires in ${days} days`, fingerprint: fingerprintOf(id, at <= nowMs ? "expired" : "soon") });
+    };
+    for (const [key, grant] of Object.entries(policy?.routineActionGrants ?? {}))
+        expiry(`grants:routine:${key}`, `the standing permission ${key}`, grant.expiresAt);
+    for (const [key, entry] of Object.entries(policy?.desiredStates ?? {}))
+        expiry(`grants:desired:${key}`, `the standing expectation ${key}`, entry.expiresAt);
+    try {
+        const friends = await new friends_1.FileFriendStore(path.join(agentRoot, "friends")).listAll();
+        const escalation = (0, escalation_grants_1.readEscalationGrants)(agentRoot);
+        // Delegated-command authority is the operator's trusted grant, so that is what is warned about; the old record field grants nothing.
+        const delegated = (0, delegated_command_grants_1.viewDelegatedCommandGrants)(agentRoot).grants;
+        const active = (friend) => friend.trustLevel === "family" && friend.admissionState === "active";
+        for (const friend of friends) {
+            const delegation = delegated[friend.id];
+            if (delegation) {
+                expiry(`grants:delegation:${friend.id}`, `${friend.name}'s delegation grant`, delegation.expiresAt);
+                if (!active(friend))
+                    findings.push({ id: `grants:delegation:${friend.id}:inert`, area: "grants", severity: "info", next: "owner", summary: `${friend.name} holds a delegation grant but is no longer an active family friend, so it does nothing`, fingerprint: fingerprintOf(`grants:delegation:${friend.id}:inert`, "inert") });
+            }
+            const held = escalation[friend.id];
+            if (held) {
+                expiry(`grants:escalation:${friend.id}`, `${friend.name}'s escalation grant`, held.expiresAt);
+                if (!active(friend))
+                    findings.push({ id: `grants:escalation:${friend.id}:inert`, area: "grants", severity: "info", next: "owner", summary: `${friend.name} holds an escalation grant but is no longer an active family friend, so reports cannot reach them`, fingerprint: fingerprintOf(`grants:escalation:${friend.id}:inert`, "inert") });
+            }
+        }
+        return "ok";
+    }
+    catch (error) {
+        return `friends unreadable: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+// ---- the sweep ---------------------------------------------------------------------------------------------------
+const SEVERITY_ORDER = { critical: 0, warn: 1, info: 2 };
+/** The sweep sources a ledger id depends on. */
+function sourcesFor(id) {
+    const [area, second] = id.split(":");
+    if (area === "downloads" || area === "imports" || area === "missing")
+        return second === "radarr" ? ["radarr"] : ["sonarr"];
+    if (area === "containers")
+        return ["host", "policy"];
+    if (area === "disk" || area === "parity")
+        return ["host"];
+    if (area === "grants")
+        return ["grants", "policy"];
+    return [];
+}
+async function runHouseSweep(deps) {
+    const now = deps.now ?? Date.now;
+    const nowMs = now();
+    const fetchImpl = deps.fetch ?? fetch;
+    const scope = deps.replay ? "replay" : "live";
+    const findings = [];
+    const sources = { sonarr: "ok", radarr: "ok", host: "ok", policy: "ok", grants: "ok" };
+    const queue = { sonarr: { unavailable: "not read" }, radarr: { unavailable: "not read" } };
+    const unavailable = (source, reason) => {
+        sources[source] = reason;
+        findings.push({ id: `sweep:${source}`, area: "sweep", severity: "warn", next: "owner", summary: `the sweep could not read ${source}: ${(0, exports.clip)(reason, 120)}`, fingerprint: fingerprintOf(`sweep:${source}`, "unavailable") });
+    };
+    const credentials = readCredentials(deps.credentialsPath ?? path.join(deps.agentRoot, "mcp", "media-credentials.json"));
+    const progress = dict(readJson((0, exports.progressPath)(deps.agentRoot)).items);
+    const nextProgress = {};
+    for (const service of ["sonarr", "radarr"]) {
+        const creds = credentials[service];
+        if (!creds) {
+            queue[service] = { unavailable: "no credentials" };
+            unavailable(service, "no credentials in the media credential file");
+            continue;
+        }
+        try {
+            const sonarr = service === "sonarr";
+            const [queuePayload, missingPayload, historyPayload] = await Promise.all([
+                arrGet(service, creds, sonarr ? "/queue?pageSize=200&includeSeries=true" : "/queue?pageSize=200&includeMovie=true", fetchImpl),
+                arrGet(service, creds, sonarr ? "/wanted/missing?pageSize=500&monitored=true&includeSeries=true&sortKey=airDateUtc&sortDirection=ascending" : "/wanted/missing?pageSize=500&monitored=true", fetchImpl),
+                arrGet(service, creds, "/history?pageSize=50&eventType=4&sortKey=date&sortDirection=descending", fetchImpl),
+            ]);
+            const summary = summarizeArr(service, queuePayload, missingPayload, historyPayload, nowMs, progress, nextProgress);
+            queue[service] = summary.queue;
+            findings.push(...summary.findings);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            queue[service] = { unavailable: (0, exports.clip)(reason, 120) };
+            unavailable(service, reason);
+        }
+    }
+    // A source that could not be read keeps its last known progress, so one bad morning does not reset every stall clock.
+    for (const service of ["sonarr", "radarr"]) {
+        if ("unavailable" in queue[service])
+            for (const [key, value] of Object.entries(progress))
+                if (key.startsWith(`${service}:`))
+                    nextProgress[key] = value;
+    }
+    writeJson((0, exports.progressPath)(deps.agentRoot), { schemaVersion: 1, items: nextProgress });
+    let policy = null;
+    try {
+        policy = (0, steward_policy_1.readStewardPolicy)(deps.agentRoot);
+    }
+    catch (error) {
+        unavailable("policy", error instanceof Error ? error.message : String(error));
+    }
+    let host;
+    if (!deps.sanctuary)
+        unavailable("host", "the Unraid read runtime is not attached to this turn");
+    else {
+        try {
+            const swept = await sweepHost(deps.sanctuary, policy ? policy.desiredStates : null, nowMs, findings);
+            host = swept.summary;
+            if (swept.problem)
+                unavailable("host", swept.problem);
+        }
+        catch (error) {
+            unavailable("host", error instanceof Error ? error.message : String(error));
+        }
+    }
+    const grantsStatus = await sweepGrants(deps.agentRoot, policy, nowMs, findings);
+    if (grantsStatus !== "ok")
+        unavailable("grants", grantsStatus);
+    // What the owner has already been told. A replay sweep reads and writes none of it.
+    const ledger = deps.replay ? {} : (0, exports.readLedger)(deps.agentRoot);
+    const ordered = findings
+        .map((finding) => {
+        const told = ledger[finding.id];
+        const recent = told !== undefined && told.fingerprint === finding.fingerprint && nowMs - Date.parse(told.reportedAt) < exports.REMIND_DAYS * DAY_MS;
+        return { ...finding, summary: (0, exports.clip)((0, exports.safe)(finding.summary), 220), alreadyReported: recent };
+    })
+        .sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] || a.id.localeCompare(b.id));
+    if (!deps.replay) {
+        // A finding that is gone is forgotten, so it is told again if it comes back.
+        // ...but only when its source was readable: an outage must not make every finding look new on recovery.
+        const present = new Set(ordered.map((finding) => finding.id));
+        const kept = Object.fromEntries(Object.entries(ledger).filter(([id]) => present.has(id) || sourcesFor(id).some((source) => sources[source] !== "ok")));
+        if (Object.keys(kept).length !== Object.keys(ledger).length)
+            (0, exports.writeLedger)(deps.agentRoot, kept);
+    }
+    const sentToday = !deps.replay && (0, exports.sameUtcDay)((0, exports.readLastDigestAt)(deps.agentRoot), new Date(nowMs).toISOString());
+    const fresh = ordered.filter((finding) => !finding.alreadyReported);
+    const shown = ordered.slice(0, exports.LIST_CAP * 3);
+    const shownIds = new Set(shown.map((finding) => finding.id));
+    const report = {
+        checkedAt: new Date(nowMs).toISOString(),
+        scope,
+        queue,
+        sources,
+        ...(host ? { host } : {}),
+        findings: shown,
+        omitted: ordered.length - shown.length,
+        fresh: fresh.filter((finding) => shownIds.has(finding.id)).map((finding) => finding.id),
+        digest_due: fresh.length > 0 && !sentToday,
+        digest_draft: draftDigest(fresh.filter((finding) => shownIds.has(finding.id))),
+        guidance: `${sentToday ? "A digest already went out today, so none is due. " : ""}Try every finding with a fix first (the fix never deletes a partial download). Anything still unsettled, and every finding without a fix, goes in ONE short digest with house_digest_send using the finding ids. If digest_due is false, say nothing to the owner. Never remove a download or delete anything.`,
+    };
+    (0, exports.rememberSweep)(deps.agentRoot, scope, shown);
+    (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.house_sweep_run", message: "house sweep gathered", meta: { scope, findings: ordered.length, fresh: fresh.length, digestDue: report.digest_due } });
+    return report;
+}
+function draftDigest(findings) {
+    if (findings.length === 0)
+        return "";
+    return findings.slice(0, exports.LIST_CAP).map((finding) => `- ${finding.summary}`).join("\n") + (findings.length > exports.LIST_CAP ? `\n- and ${findings.length - exports.LIST_CAP} more` : "");
+}

package/dist/repertoire/mcp-client.js

@@ -1,11 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.McpClient = void 0;
+exports.McpClient = exports.MCP_TOOL_TIMEOUT_META_KEY = void 0;
+exports.isMcpTransportError = isMcpTransportError;
 const child_process_1 = require("child_process");
 const readline_1 = require("readline");
 const runtime_1 = require("../nerves/runtime");
+const runtime_cwd_1 = require("../heart/runtime-cwd");
+/** Metadata key a server uses to declare how long one call to a tool may take. */
+exports.MCP_TOOL_TIMEOUT_META_KEY = "ouro.bot/timeoutMs";
+const MAX_TOOL_CALL_TIMEOUT = 600_000;
 const MCP_PROTOCOL_VERSION = "2024-11-05";
+const DEFAULT_REQUEST_TIMEOUT = 10_000;
 const DEFAULT_TOOL_CALL_TIMEOUT = 30_000;
+const MIN_TOOL_CALL_TIMEOUT = 1_000;
+function isMcpTransportError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    return normalized.includes("disconnected")
+        || normalized.includes("transport")
+        || normalized.includes("closed")
+        || normalized.includes("econnreset")
+        || normalized.includes("econnrefused")
+        || normalized.includes("enoent")
+        || normalized.includes("epipe")
+        || normalized.includes("broken pipe")
+        || normalized.includes("not writable");
+}
 class McpClient {
     config;
     process = null;
@@ -18,6 +38,9 @@ class McpClient {
         this.config = config;
     }
     async connect() {
+        if (this.connected)
+            return;
+        this.shutdownProcessOnly();
         (0, runtime_1.emitNervesEvent)({
             event: "mcp.connect_start",
             component: "repertoire",
@@ -25,9 +48,11 @@ class McpClient {
             meta: { command: this.config.command },
         });
         const env = { ...process.env, ...this.config.env };
+        const spawnCwd = this.config.cwd ?? (0, runtime_cwd_1.recoverRuntimeCwd)();
         this.process = (0, child_process_1.spawn)(this.config.command, this.config.args ?? [], {
             env,
             stdio: ["pipe", "pipe", "pipe"],
+            cwd: spawnCwd,
         });
         this.setupLineReader();
         this.setupProcessHandlers();
@@ -43,6 +68,7 @@ class McpClient {
         }
         catch (error) {
             this.connected = false;
+            this.shutdownProcessOnly();
             (0, runtime_1.emitNervesEvent)({
                 level: "error",
                 event: "mcp.connect_error",
@@ -75,7 +101,19 @@ class McpClient {
         this.cachedTools = allTools;
         return allTools;
     }
-    async callTool(name, args, timeout = DEFAULT_TOOL_CALL_TIMEOUT) {
+    /** A tool that searches slow services may declare a longer timeout; it is clamped to 1 s .. 10 min. */
+    declaredToolTimeout(name) {
+        const declared = this.cachedTools?.find((tool) => tool.name === name)?._meta?.[exports.MCP_TOOL_TIMEOUT_META_KEY];
+        if (typeof declared !== "number" || !Number.isFinite(declared))
+            return DEFAULT_TOOL_CALL_TIMEOUT;
+        return Math.min(Math.max(Math.round(declared), MIN_TOOL_CALL_TIMEOUT), MAX_TOOL_CALL_TIMEOUT);
+    }
+    async refreshTools() {
+        this.cachedTools = null;
+        return this.listTools();
+    }
+    async callTool(name, args, timeoutOverride) {
+        const timeout = timeoutOverride ?? this.declaredToolTimeout(name);
         (0, runtime_1.emitNervesEvent)({
             event: "mcp.tool_call_start",
             component: "repertoire",
@@ -138,7 +176,7 @@ class McpClient {
         });
         return result;
     }
-    sendRequest(method, params, timeout) {
+    sendRequest(method, params, timeout = DEFAULT_REQUEST_TIMEOUT) {
         return new Promise((resolve, reject) => {
             if (!this.process || !this.connected && method !== "initialize") {
                 reject(new Error("MCP client is disconnected"));
@@ -159,14 +197,21 @@ class McpClient {
                 method,
                 params,
             };
-            this.writeMessage(request);
+            if (!this.writeMessage(request)) {
+                this.pending.delete(id);
+                if (pending.timer) {
+                    clearTimeout(pending.timer);
+                }
+                reject(new Error(`MCP transport is not writable for request: ${method}`));
+            }
         });
     }
     writeMessage(message) {
-        /* v8 ignore next -- defensive: stdin always writable during active connection @preserve */
         if (this.process?.stdin?.writable) {
             this.process.stdin.write(JSON.stringify(message) + "\n");
+            return true;
         }
+        return false;
     }
     setupLineReader() {
         /* v8 ignore next -- defensive: stdout always exists after spawn @preserve */
@@ -250,5 +295,13 @@ class McpClient {
             this.pending.delete(id);
         }
     }
+    shutdownProcessOnly() {
+        this.rejectAllPending(new Error("MCP transport closed during reconnect"));
+        /* v8 ignore next -- defensive: process may already be absent @preserve */
+        if (this.process && !this.process.killed) {
+            this.process.kill();
+        }
+        this.process = null;
+    }
 }
 exports.McpClient = McpClient;