@mono-agent/agent-app 0.20.14 → 0.21.0

package/dist/doctor.js

@@ -1,3 +1,4 @@
+import { inspectWebControl } from "./web-request-coordinator.js";
 import { execFile as execFileCallback } from "node:child_process";
 import { constants } from "node:fs";
 import { access, lstat, mkdir, readdir, readFile, realpath, stat } from "node:fs/promises";
@@ -16,6 +17,7 @@ import { buildMonoAgentConfigView, EFFORT_LEVELS, findJsonSecretConfigWarnings,
 import { describeSandboxEffectiveState, MODEL_REFERENCE_ECHO_MAX_BYTES, MODEL_REFERENCE_REASON_MAX_BYTES, resolveSandboxEffectiveState, RuntimeAdapterError, sandboxEffectiveStateWarning, sanitizeModelReferenceText, } from "@mono-agent/runtime-adapter";
 import { isAppCoreConfigError, loadAppCoreConfig, } from "./app-config.js";
 import { isRememberToolAllowed, isRememberToolPolicyName } from "./memory-remember.js";
+import { isMemoryJournalToolAllowed, isMemoryJournalToolPolicyName } from "./memory-journal.js";
 import { adapterSendToolNames, isAdapterSendToolAllowed, resolveAdapterSendToolsSettings } from "./adapter-send-tools.js";
 import { canonicalToolName, isAllowAllTools, isKnownToolName, isMcpToolName, suggestToolName } from "./modules/known-tools.js";
 import { collectChannelConfigViews } from "./channel-config-view.js";
@@ -37,8 +39,9 @@ import { formatInteractionBridgeUrl, loadInteractionSettings } from "./interacti
 import { FIRST_RUN_MEMORY_INITIALIZING_MARKER } from "./first-run-managed-memory.js";
 import { DEFAULT_MEMORY_EMBEDDING_ENDPOINTS, probeMemoryEmbeddingSelection, } from "./memory-embedding-service.js";
 import { piAuthRecoveryCommand } from "./provider-setup.js";
+import { collectUsedProviderReferences } from "./provider-auth-status.js";
 import { inspectPiAuthStore } from "./pi-auth-store-inspection.js";
-import { checkManagedProjectSkills, managedProjectSkillsExist } from "./project-skills.js";
+import { activeProjectSkillSelections, checkManagedProjectSkills, isRetiredProjectSkillName, managedProjectSkillsExist, } from "./project-skills.js";
 import { runtimeProvenanceDetail } from "./runtime-provenance.js";
 import { resolveAdvertisedModelEffort } from "./model-effort-capabilities.js";
 import { loadSupermemoryPlugin } from "./supermemory-plugin.js";
@@ -51,6 +54,7 @@ const CONTINUATION_V2_ROLLBACK_GUARD = "UPGRADED-TO-RECORDS-V3";
 const CONTINUATION_V2_ROLLBACK_GUARD_CONTENT = "This state directory uses continuation records v3. Older runtimes must not open records-v2.\n";
 const DOCTOR_STATUS_TIMEOUT_MS = 5_000;
 const DOCTOR_STATUS_MAX_BUFFER_BYTES = 64 * 1024;
+const OLLAMA_WEB_SEARCH_PROBE_MAX_BYTES = 2 * 1024 * 1024;
 const defaultDoctorStatusExecFile = async (file, args, options) => {
     const { stdout } = await execFile(file, [...args], options);
     return { stdout };
@@ -78,7 +82,7 @@ export async function validateMonoAgentFolder(options) {
     }
     sections.push(await runtimeProvenanceSection(options.verifiedRuntimeProvenanceDetail));
     if (coreConfig !== undefined) {
-        const staticTriggerCredentialRefs = await collectStaticTriggerCredentialRefs(drivers, options);
+        const staticTriggerCredentialRefs = await collectStaticTriggerCredentialRefs(coreConfig, drivers, options);
         const jsonResult = await readMonoAgentConfigJson(options.configPath);
         // Channel secrets (bot tokens, API keys) live outside the core view, so the
         // placement check spans both: core sections + every channel's config view.
@@ -238,37 +242,10 @@ function staticTriggerConfigEntries(driverId, loaded) {
  * Collect static trigger model overrides for credential readiness. Dynamic
  * webhook request-body overrides are intentionally unavailable at validate time.
  */
-async function collectStaticTriggerCredentialRefs(drivers, input) {
-    const refs = [];
-    const seen = new Set();
-    for (const driver of drivers) {
-        if (driver.id !== "webhook" && driver.id !== "cron")
-            continue;
-        let loaded;
-        try {
-            loaded = await driver.loadConfig(input);
-        }
-        catch {
-            // The channel section owns malformed/unreadable config diagnostics.
-            continue;
-        }
-        for (const { entryPath, entry } of staticTriggerConfigEntries(driver.id, loaded)) {
-            if (typeof entry.model !== "string")
-                continue;
-            try {
-                const ref = parseMonoRuntimeModelReference(entry.model);
-                const key = `${entryPath}\u0000${modelReferenceKey(ref)}`;
-                if (seen.has(key))
-                    continue;
-                seen.add(key);
-                refs.push({ label: entryPath, ref });
-            }
-            catch {
-                // The channel section owns invalid model-reference syntax.
-            }
-        }
-    }
-    return refs;
+async function collectStaticTriggerCredentialRefs(config, drivers, input) {
+    return (await collectUsedProviderReferences(config, drivers, input))
+        .filter(({ usage }) => usage.kind === "cron" || usage.kind === "webhook")
+        .map(({ usage, ref }) => ({ label: usage.label, ref }));
 }
 async function applyRequestModelOverrideCompatibilityChecks(sections, config, drivers, input) {
     const piModelResolutionFailures = [];
@@ -697,6 +674,8 @@ function hasNonEmptyCredentialValue(value) {
 async function contextSection(config, cwd) {
     const details = [];
     let status = "ok";
+    const activeSelectedSkills = activeProjectSkillSelections(config.context.selectedSkills);
+    const retiredSelectedSkills = config.context.selectedSkills.filter(isRetiredProjectSkillName);
     if (await pathExists(config.context.identityPath)) {
         details.push(`Identity: ${config.context.identityPath}`);
     }
@@ -708,10 +687,19 @@ async function contextSection(config, cwd) {
         status = "error";
         details.push(`Soul file is missing: ${config.context.soulPath}`);
     }
-    if (config.context.skillsRoot !== undefined) {
+    for (const skill of retiredSelectedSkills) {
+        if (status === "ok")
+            status = "waiting";
+        details.push(`Skill \`${skill}\` is retired and ignored. Remove it from context.selectedSkills or ` +
+            "MONO_AGENT_SELECTED_SKILLS, then run `mono-agent install-skill --project --check`." +
+            (config.context.skillDisclosure === "index"
+                ? " Skill disclosure runs as `full` until the retired selector is removed."
+                : ""));
+    }
+    if (activeSelectedSkills.length > 0 && config.context.skillsRoot !== undefined) {
         if (await pathExists(config.context.skillsRoot)) {
             details.push(`Skills root: ${config.context.skillsRoot}`);
-            for (const skill of config.context.selectedSkills) {
+            for (const skill of activeSelectedSkills) {
                 const skillPath = join(config.context.skillsRoot, skill, "SKILL.md");
                 if (await pathExists(skillPath)) {
                     details.push(`Skill \`${skill}\`: ${skillPath}`);
@@ -727,7 +715,7 @@ async function contextSection(config, cwd) {
             details.push(`Skills root is missing: ${config.context.skillsRoot}`);
         }
     }
-    else if (config.context.selectedSkills.length > 0) {
+    else if (activeSelectedSkills.length > 0) {
         status = "error";
         details.push("Skills are selected but context.skillsRoot is not set.");
     }
@@ -762,7 +750,15 @@ function memoryConsolidationCronIssue(expression) {
 }
 async function memorySection(config, cwd, env, liveness, allowFilesystemWrites, preferAppPluginInstall) {
     if (config.memory === undefined) {
-        return { id: "memory", label: "Memory", status: "disabled", details: ["No memory configured."] };
+        return {
+            id: "memory",
+            label: "Memory",
+            status: "disabled",
+            details: [
+                "No memory configured.",
+                "Chronological journal: disabled because no local memory backend is configured.",
+            ],
+        };
     }
     // External backend (e.g. supermemory): mode/embeddings/llm are bujo-only and
     // ignored, so validate the plugin-owned shape before any soft liveness probe.
@@ -808,6 +804,9 @@ async function memorySection(config, cwd, env, liveness, allowFilesystemWrites,
             sm.apiKey === undefined
                 ? "Auth: no API key configured (keyless — works only if the instance allows it)."
                 : "Auth: API key configured.",
+            config.memory.recallTool?.enabled === false
+                ? "Explicit memory read tools are disabled by memory.recallTool.enabled. Chronological journal browsing is also unsupported by Supermemory."
+                : "Chronological journal: unsupported by Supermemory; MemoryJournal is not offered.",
         ];
         if (!liveness) {
             details.push("Supermemory liveness probe skipped; ingestion is async.");
@@ -825,6 +824,9 @@ async function memorySection(config, cwd, env, liveness, allowFilesystemWrites,
     }
     const details = [
         `Mode: ${config.memory.mode}, path: ${config.memory.path}, writeMode: ${config.memory.writeMode}.`,
+        config.memory.recallTool?.enabled === false
+            ? `Explicit memory read tools are disabled by memory.recallTool.enabled; the local ${config.memory.mode} tier supports chronology but MemoryJournal is not offered.`
+            : `Chronological journal: supported by the local ${config.memory.mode} tier when tool policy allows MemoryJournal.`,
     ];
     let status = "ok";
     if (config.memory.llm !== undefined) {
@@ -1237,6 +1239,27 @@ async function toolsSection(config, input) {
         details.push(`Allowed tools: ${allowedTools.join(", ")}.`);
         let mcpNoteAdded = false;
         for (const name of allowedTools) {
+            if (isMemoryJournalToolPolicyName(name)) {
+                // This app-owned MCP surface must be checked before the generic MCP
+                // branch, using the same deny-wins spellings as runtime composition.
+                if (!isMemoryJournalToolAllowed(config.tools)) {
+                    status = "waiting";
+                    details.push(`${name} is listed but tool policy still resolves to denied (deny wins, including the mcp__mono-agent-memory-journal__* spelling) - the tool will not be offered.`);
+                }
+                else if (config.memory === undefined) {
+                    status = "waiting";
+                    details.push(`${name} is in allowedTools but no memory block is configured - chronological journal browsing will not work.`);
+                }
+                else if (config.memory.recallTool?.enabled === false) {
+                    status = "waiting";
+                    details.push(`${name} is in allowedTools but memory.recallTool.enabled is off - explicit memory read tools will not work.`);
+                }
+                else if ((config.memory.backend ?? "bujo") === "supermemory") {
+                    status = "waiting";
+                    details.push(`${name} is in allowedTools but the Supermemory backend exposes no chronological journal surface - the tool will not be offered.`);
+                }
+                continue;
+            }
             if (isRememberToolPolicyName(name)) {
                 // Reconcile with the runtime's own resolution, which honours the
                 // `mcp__mono-agent-memory-write__*` spellings and deny-wins. This check
@@ -1440,31 +1463,61 @@ async function toolsSection(config, input) {
     return { id: "tools", label: "Tools & MCP", status, details };
 }
 const MIN_AGENT_BROWSER_VERSION = [0, 33, 1];
+function formatSearchBackendChain(backends) {
+    if (backends.length <= 1)
+        return backends[0] ?? "none";
+    return `${backends.slice(0, -1).join(", ")}, then ${backends.at(-1)}`;
+}
 async function webToolsSection(config, input, liveness) {
     const web = config.tools.web;
     const search = web?.search ?? {
         backend: "auto",
+        maxRequestsPerRun: 4,
         codex: { model: "gpt-5.6-luna" },
     };
     const fetchConfig = web?.fetch ?? { render: "never", browserCommand: "agent-browser" };
-    const details = [`WebSearch backend: ${search.backend}.`];
+    const details = [
+        `WebSearch backend: ${search.backend}.`,
+        `WebSearch request budget: ${search.maxRequestsPerRun ?? 4} per logical run.`,
+        `Web coordination: ${web?.coordination ?? "process"}.`,
+    ];
     let status = "ok";
-    if (search.endpoint === undefined) {
+    if (web?.coordination === "host") {
+        try {
+            const shared = await inspectWebControl();
+            details.push(shared.exists ? "Host web control state is valid." : "Host web control state will be initialized on first request.");
+        }
+        catch {
+            status = "waiting";
+            details.push("Host web control state is unavailable; web requests will fail closed. Inspect with mono-agent web-control status.");
+        }
+    }
+    const searxngEndpoint = search.searxng?.endpoint ?? search.endpoint;
+    const autoEligibleBackends = [
+        ...(search.ollama === undefined ? [] : ["configured Ollama"]),
+        ...(searxngEndpoint === undefined ? [] : ["configured SearXNG"]),
+        "Codex",
+        "keyless",
+    ];
+    const autoAfterOllama = formatSearchBackendChain(autoEligibleBackends.slice(1));
+    if (searxngEndpoint === undefined) {
         details.push(search.backend === "keyless"
             ? "SearXNG is not configured; keyless search is enabled."
             : search.backend === "codex"
                 ? "SearXNG is not configured; strict Codex subscription search is enabled."
                 : search.backend === "searxng"
                     ? "SearXNG is not configured."
-                    : "SearXNG is not configured; auto mode starts with Codex subscription search, then keyless search.");
+                    : search.ollama === undefined
+                        ? "SearXNG is not configured; auto mode starts with Codex subscription search, then keyless search."
+                        : "SearXNG is not configured; auto mode uses configured Ollama, then Codex subscription search, then keyless search.");
     }
     else {
-        details.push(`SearXNG endpoint: ${search.endpoint}.`);
+        details.push(`SearXNG endpoint: ${searxngEndpoint}.`);
         if (!liveness) {
             details.push("SearXNG liveness was not probed.");
         }
         else {
-            const probe = await probeSearxngEndpoint(search.endpoint);
+            const probe = await probeSearxngEndpoint(searxngEndpoint);
             if (probe.ok) {
                 details.push("SearXNG JSON search probe succeeded.");
             }
@@ -1472,14 +1525,42 @@ async function webToolsSection(config, input, liveness) {
                 status = "waiting";
                 details.push(`[WARN] SearXNG JSON search probe failed (${probe.reason}). ` +
                     (search.backend === "auto"
-                        ? "Start the local companion or fix tools.web.search.endpoint; auto mode can still fall back to Codex subscription search, then keyless search."
-                        : "Start the local companion or fix tools.web.search.endpoint; strict SearXNG mode has no fallback."));
+                        ? "Start the local companion or fix tools.web.search.searxng.endpoint; auto mode can still fall back to Codex subscription search, then keyless search."
+                        : "Start the local companion or fix tools.web.search.searxng.endpoint; strict SearXNG mode has no fallback."));
+            }
+        }
+    }
+    if (search.backend === "ollama" || (search.backend === "auto" && search.ollama !== undefined)) {
+        const ollama = search.ollama;
+        if (ollama === undefined) {
+            status = "waiting";
+            details.push("[WARN] Ollama Web Search is selected but its resolved configuration is missing.");
+        }
+        else if (!liveness) {
+            details.push(`Ollama Web Search origin: ${ollama.baseUrl}. ${search.backend === "ollama" ? "Strict Ollama mode has no fallback." : `Auto mode advances to ${autoAfterOllama} when Ollama is unavailable.`}`);
+            details.push("Ollama Web Search liveness was not probed.");
+        }
+        else {
+            details.push(`Ollama Web Search origin: ${ollama.baseUrl}. ${search.backend === "ollama" ? "Strict Ollama mode has no fallback." : `Auto mode advances to ${autoAfterOllama} when Ollama is unavailable.`}`);
+            const probe = await probeOllamaWebSearch(ollama);
+            if (probe.ok)
+                details.push("Ollama Web Search JSON probe succeeded.");
+            else {
+                status = "waiting";
+                details.push(`[WARN] Ollama Web Search probe failed (${probe.reason}). ${search.backend === "ollama" ? "Strict Ollama mode has no fallback." : `Auto mode can still advance to ${autoAfterOllama}.`}`);
             }
         }
     }
+    else if (search.ollama !== undefined) {
+        details.push(`Ollama Web Search is configured but inactive because backend ${search.backend} is strict.`);
+    }
     if (search.backend === "auto") {
         const codexModel = search.codex?.model ?? "gpt-5.6-luna";
-        details.push(`Codex subscription fallback model: ${codexModel}; readiness is checked lazily when auto mode reaches that fallback.`);
+        const beforeCodex = autoEligibleBackends.slice(0, autoEligibleBackends.indexOf("Codex"));
+        const codexPosition = beforeCodex.length === 0
+            ? "as the first eligible backend"
+            : `after ${formatSearchBackendChain(beforeCodex)}`;
+        details.push(`Codex subscription fallback model: ${codexModel}; readiness is checked lazily when auto mode reaches it ${codexPosition}.`);
     }
     else if (search.backend === "codex") {
         const codexModel = search.codex?.model ?? "gpt-5.6-luna";
@@ -1519,6 +1600,95 @@ async function webToolsSection(config, input, liveness) {
     }
     return { id: "web-tools", label: "Web search & fetch", status, details };
 }
+async function probeOllamaWebSearch(config) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => { ctrl.abort(); }, LIVENESS_PROBE_TIMEOUT_MS);
+    const official = config.baseUrl === "https://ollama.com";
+    const paths = official ? ["/api/web_search"] : ["/api/experimental/web_search", "/api/web_search"];
+    try {
+        for (let index = 0; index < paths.length; index += 1) {
+            const response = await fetch(`${config.baseUrl}${paths[index]}`, {
+                method: "POST",
+                headers: {
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                    ...(official ? { Authorization: `Bearer ${config.apiKey}` } : {}),
+                },
+                body: JSON.stringify({ query: "mono-agent doctor", max_results: 1 }),
+                redirect: "error",
+                signal: ctrl.signal,
+            });
+            if (!official && index === 0 && [404, 405].includes(response.status)) {
+                await response.body?.cancel();
+                continue;
+            }
+            if ([401, 403].includes(response.status)) {
+                await response.body?.cancel();
+                return { ok: false, reason: official
+                        ? `hosted authentication failed; check ${config.apiKeyEnv}`
+                        : "the local proxy requires sign-in; run ollama signin or repair its proxy authentication" };
+            }
+            if (!response.ok) {
+                await response.body?.cancel();
+                return { ok: false, reason: `HTTP ${response.status}` };
+            }
+            const declared = Number(response.headers.get("content-length"));
+            if (Number.isFinite(declared) && declared > OLLAMA_WEB_SEARCH_PROBE_MAX_BYTES) {
+                await response.body?.cancel();
+                return { ok: false, reason: `response exceeded ${OLLAMA_WEB_SEARCH_PROBE_MAX_BYTES} bytes` };
+            }
+            const bytes = await readBoundedProbeResponse(response, OLLAMA_WEB_SEARCH_PROBE_MAX_BYTES);
+            let body;
+            try {
+                body = JSON.parse(new TextDecoder().decode(bytes));
+            }
+            catch {
+                return { ok: false, reason: "response was not valid JSON" };
+            }
+            if (!body || typeof body !== "object" || !Array.isArray(body.results)) {
+                return { ok: false, reason: "response did not contain a results array" };
+            }
+            return { ok: true, reason: "" };
+        }
+        return { ok: false, reason: "this Ollama version supports neither local Web Search endpoint" };
+    }
+    catch (error) {
+        return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function readBoundedProbeResponse(response, maxBytes) {
+    const reader = response.body?.getReader();
+    if (reader === undefined)
+        throw new Error("response body could not be read safely");
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            total += next.value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel();
+                throw new Error(`response exceeded ${maxBytes} bytes`);
+            }
+            chunks.push(next.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const joined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        joined.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return joined;
+}
 async function probeSearxngEndpoint(endpoint) {
     const ctrl = new AbortController();
     const timer = setTimeout(() => { ctrl.abort(); }, LIVENESS_PROBE_TIMEOUT_MS);