@mono-agent/agent-app 0.6.2 → 0.8.0

package/dist/app.js

@@ -1,4 +1,5 @@
 import { resolve } from "node:path";
+import { loadToolPolicyFromJsonFileSync } from "@mono-agent/agent-harness";
 import { createLiveEventBus } from "@mono-agent/agent-contracts";
 import { pruneTraceSources, reconcileStaleRunArtifacts, registerTraceSource } from "@mono-agent/observability";
 import { modelReferenceKey } from "@mono-agent/runtime-adapter";
@@ -11,10 +12,14 @@ import { adapterSendToolNames, createAdapterSendToolsRuntimeExtension, isAdapter
 import { loadInteractionSettings, startInteractionBridge } from "./interaction-bridge.js";
 import { startMemoryRituals } from "./memory-rituals.js";
 import { startArtifactRetentionScheduler } from "./artifact-retention.js";
-import { createMemoryRecallRuntimeExtension, resolveMemoryRecallSettings, } from "./memory-recall.js";
-import { createRequestModelOverrideRuntimeExtension } from "./request-model-override.js";
+import { resolveMemoryRecallSettings, } from "./memory-recall.js";
+import { isSharedRecallStore, MemoryRetrievalService, } from "./memory-retrieval.js";
+import { composeRuntimeOptionExtensions, } from "./runtime-option-extensions.js";
+import { createRunHistoryRuntimeExtension, isRunHistoryToolAllowed, } from "./run-history.js";
+import { createRequestModelOverrideRuntimeExtension, requestModelOverrideTargetsDirectOpenCode, } from "./request-model-override.js";
 import { resolveNotifyDestinations } from "./notify-destinations.js";
 import { resolvePostedMessageIndexPath } from "./posted-message-index.js";
+import { configuredRuntimeFallbackModels, configuredRuntimeModels, hasConfiguredRuntimeFallbacks, } from "./runtime-routes.js";
 /**
  * Starts a config-first mono-agent host in `cwd`: traceability first, then every
  * configured channel in parallel. Channels with incomplete config report
@@ -41,7 +46,7 @@ export async function startMonoAgentApp(options = {}) {
     await controller.startExporters("startup");
     await Promise.all(drivers.map((driver) => controller?.startChannelIfConfigured(driver.id, "startup")));
     await controller.startMemoryRitualsIfConfigured("startup");
-    await controller.refreshTraceSource("startup-complete");
+    await controller.refreshMemoryHealthAfterLifecycle("startup-complete");
     return controller;
 }
 const DEFAULT_SANDBOX_STATUS = sandboxStatusFromState({
@@ -54,6 +59,8 @@ const DEFAULT_SANDBOX_STATUS = sandboxStatusFromState({
     fallbackActive: false,
     unsafeAllowHostProcess: false,
 });
+/** Strict memory audits scan durable state; never run them at sub-second trace-heartbeat cadence. */
+const MIN_MEMORY_HEALTH_REFRESH_INTERVAL_MS = 30_000;
 class MonoAgentAppController {
     configPath;
     cwd;
@@ -80,12 +87,32 @@ class MonoAgentAppController {
         reason: "No observability exporter configured.",
     };
     sandboxStatusValue = DEFAULT_SANDBOX_STATUS;
+    memoryHealthValue = {
+        backend: "none",
+        status: "unknown",
+        checkedAt: new Date().toISOString(),
+    };
+    memoryHealthRefreshInFlight;
+    memoryHealthRefreshTimer;
+    memoryHealthRefreshLoopActive = false;
+    memoryHealthRefreshIntervalMs = MIN_MEMORY_HEALTH_REFRESH_INTERVAL_MS;
+    /** Monotonic completion time for the current generation's cached full audit. */
+    memoryHealthLastCompletedAtMs;
+    /** One bounded forced refresh reserved by a due timer tick. */
+    memoryHealthRefreshDue = false;
+    memoryHealthGeneration = 0;
     selectedSkillsValue;
     sessionMetadataValue;
     /** The exporter the responder threads into agent-host (first configured exporter). */
     resolvedExporter;
     traceSource;
-    traceRefreshTail = Promise.resolve();
+    /**
+     * Whole-publication single flight. A slow health probe must not let periodic
+     * heartbeat ticks build an unbounded promise tail behind it.
+     */
+    traceRefreshInFlight;
+    traceRefreshDirty = false;
+    traceRefreshLatestReason;
     // Best-effort mirror of `traceSource` into the machine-wide global registry,
     // present only when `shouldMirrorTraceSourceGlobally` gates it on (see
     // `startTraceability`). Kept in lockstep with `traceSource` on every
@@ -97,15 +124,16 @@ class MonoAgentAppController {
     // One shared memory store across all channel responders + the ritual scheduler, so there is a single
     // memory.db handle (not one per channel plus one for rituals). Rebuilt on config reload, closed on stop.
     sharedMemory = undefined;
+    sharedMemoryRetrieval;
     sharedMemoryBuilt = false;
     sharedMemoryBuild;
     configApplyTail = Promise.resolve();
     stopped = false;
-    // Interaction bridge (AskUser + tool progress): lazily started once, shared
-    // by every channel; the exported env keys are tracked for cleanup on stop.
+    // Interaction bridge (AskUser + tool progress): lazily started once and shared
+    // by every channel. Its master bearer stays app-owned and is never exported
+    // through the generic host/process environment.
     interactionBridge;
     interactionBridgeStart;
-    interactionBridgeEnvKeys = [];
     // Shared in-process run-event bus: every run's recorder publishes to it (via the
     // broadcast recorder threaded as `runEventSink`), and the `live` channel relays
     // it over SSE. One instance for the app's lifetime — cheap, bounded ring buffer,
@@ -137,6 +165,9 @@ class MonoAgentAppController {
     get sandboxStatus() {
         return this.sandboxStatusValue;
     }
+    get memoryHealth() {
+        return this.memoryHealthValue;
+    }
     get selectedSkills() {
         return this.selectedSkillsValue;
     }
@@ -159,9 +190,17 @@ class MonoAgentAppController {
                     transports: [],
                 };
             }
+            // Freeze periodic memory work before any channel/store teardown. A probe
+            // that already entered is generation-fenced and is deliberately not
+            // awaited, so config reload cannot hang behind native/filesystem work.
+            this.invalidateMemoryHealthRefresh();
             for (const driver of this.drivers) {
                 await this.stopChannel(driver.id, `${reason}:reload`);
             }
+            // Tool policy/runtime-family changes must re-evaluate implicit AskUser.
+            // Clearing the cached promise also prevents stale bridge env from a Pi
+            // config leaking into a reloaded direct-OpenCode responder.
+            await this.stopInteractionBridge();
             this.stopMemoryRituals();
             this.stopArtifactRetentionScheduler();
             await this.resetSharedMemory();
@@ -171,7 +210,7 @@ class MonoAgentAppController {
             await this.startExporters(reason);
             await Promise.all(this.drivers.map((driver) => this.startChannelIfConfigured(driver.id, reason)));
             await this.startMemoryRitualsIfConfigured(reason);
-            await this.refreshTraceSource(`${reason}:complete`);
+            await this.refreshMemoryHealthAfterLifecycle(`${reason}:complete`);
             return this.applyResult();
         };
         const next = this.configApplyTail.then(run, run);
@@ -207,6 +246,7 @@ class MonoAgentAppController {
         try {
             const input = { env: this.env, cwd: this.cwd, configPath: this.configPath };
             await this.refreshSelectedSkillsSnapshot(reason);
+            await this.refreshMemoryHealthSnapshot(reason);
             const [registryDir, artifactDir, sourceId, label, heartbeatMs, globalDiscovery] = await Promise.all([
                 resolveAppTraceRegistryDir(input),
                 resolveAppArtifactDir(input),
@@ -225,6 +265,7 @@ class MonoAgentAppController {
                 transports: this.activeTransports(),
                 configPath: this.configPath,
                 metadata: this.traceMetadata(reason),
+                memoryHealth: this.memoryHealthValue,
                 heartbeatMs,
             };
             this.traceSource = await registerTraceSource(registerOptions);
@@ -250,8 +291,10 @@ class MonoAgentAppController {
             else {
                 this.globalTraceSource = undefined;
             }
+            this.startMemoryHealthRefreshLoop(MIN_MEMORY_HEALTH_REFRESH_INTERVAL_MS);
         }
         catch (error) {
+            this.clearMemoryHealthRefreshTimer();
             const failure = reasonOf(error);
             this.traceabilityStatusValue = { kind: "failed", reason: failure };
             this.logger?.error?.("Traceability source registration failed.", { reason: failure });
@@ -379,49 +422,271 @@ class MonoAgentAppController {
         // (which reads the manifest, not this live object) can surface it too.
         void this.refreshTraceSource("exporter-warning").catch(() => undefined);
     }
-    async refreshTraceSource(reason) {
-        const run = async () => {
-            if (this.traceSource === undefined) {
-                return;
-            }
-            const patch = { transports: this.activeTransports(), metadata: this.traceMetadata(reason) };
-            try {
-                await this.traceSource.update(patch);
-            }
-            catch (error) {
-                this.logger?.warn?.("Traceability source update failed.", { reason: reasonOf(error) });
-            }
-            if (this.globalTraceSource !== undefined) {
+    refreshTraceSource(reason) {
+        const existing = this.traceRefreshInFlight;
+        if (existing !== undefined) {
+            // Keep one bounded replay slot. Concurrent explicit callers share the
+            // exact owner promise; the owner publishes the latest state/reason once
+            // more after its current write. Requests arriving during that replay set
+            // the same bit again, without growing a callback queue.
+            this.traceRefreshDirty = true;
+            this.traceRefreshLatestReason = reason;
+            return existing;
+        }
+        const traceSource = this.traceSource;
+        const globalTraceSource = this.globalTraceSource;
+        if (traceSource === undefined) {
+            return Promise.resolve();
+        }
+        const generation = this.memoryHealthGeneration;
+        let pending;
+        pending = (async () => {
+            let publishReason = reason;
+            for (;;) {
+                this.traceRefreshDirty = false;
+                this.traceRefreshLatestReason = undefined;
+                const health = await this.refreshMemoryHealthSnapshot(publishReason);
+                if (generation !== this.memoryHealthGeneration || this.traceSource !== traceSource) {
+                    return;
+                }
+                const patch = {
+                    transports: this.activeTransports(),
+                    metadata: this.traceMetadata(publishReason),
+                    memoryHealth: health,
+                };
                 try {
-                    await this.globalTraceSource.update(patch);
+                    await traceSource.update(patch);
                 }
                 catch (error) {
-                    this.logger?.warn?.("Global trace-source mirror update failed.", { reason: reasonOf(error) });
+                    this.logger?.warn?.("Traceability source update failed.", { reason: reasonOf(error) });
+                }
+                if (globalTraceSource !== undefined && generation === this.memoryHealthGeneration
+                    && this.globalTraceSource === globalTraceSource) {
+                    try {
+                        await globalTraceSource.update(patch);
+                    }
+                    catch (error) {
+                        this.logger?.warn?.("Global trace-source mirror update failed.", { reason: reasonOf(error) });
+                    }
+                }
+                if (!this.traceRefreshDirty || generation !== this.memoryHealthGeneration
+                    || this.traceSource !== traceSource) {
+                    return;
                 }
+                publishReason = this.traceRefreshLatestReason ?? publishReason;
             }
-        };
-        const next = this.traceRefreshTail.then(run, run);
-        this.traceRefreshTail = next.then(() => undefined, () => undefined);
-        await next;
+        })().catch(() => {
+            // Health computation and trace handles already sanitize/log their own
+            // failures. Keep this final boundary closed so background refreshes never
+            // become unhandled rejections or leak raw provider/native errors.
+        }).finally(() => {
+            if (this.traceRefreshInFlight === pending) {
+                this.traceRefreshInFlight = undefined;
+                const replayDue = this.memoryHealthRefreshDue
+                    && !this.stopped
+                    && generation === this.memoryHealthGeneration
+                    && this.traceSource === traceSource;
+                this.traceRefreshDirty = false;
+                this.traceRefreshLatestReason = undefined;
+                // A timer can fire after the loop's final dirty check but before this
+                // owner settles. Preserve exactly one due replay across that seam.
+                if (replayDue) {
+                    void this.refreshTraceSource("memory-health-periodic").catch(() => undefined);
+                }
+            }
+        });
+        this.traceRefreshInFlight = pending;
+        return pending;
+    }
+    /**
+     * Refresh the content-free memory snapshot once for all concurrent trace
+     * publishers. The cached value is the only memory state read by synchronous
+     * manifest composition; provider/native errors collapse to a closed unknown
+     * shape and never escape into registry metadata.
+     */
+    refreshMemoryHealthSnapshot(reason, lifecycleForce = false) {
+        if (this.stopped) {
+            return Promise.resolve(this.memoryHealthValue);
+        }
+        if (this.memoryHealthRefreshInFlight !== undefined) {
+            return this.memoryHealthRefreshInFlight;
+        }
+        const forced = lifecycleForce || this.memoryHealthRefreshDue;
+        if (!forced && this.memoryHealthLastCompletedAtMs !== undefined
+            && performance.now() - this.memoryHealthLastCompletedAtMs < MIN_MEMORY_HEALTH_REFRESH_INTERVAL_MS) {
+            return Promise.resolve(this.memoryHealthValue);
+        }
+        const generation = this.memoryHealthGeneration;
+        let pending;
+        pending = this.computeMemoryHealth().then((health) => {
+            if (!this.stopped && generation === this.memoryHealthGeneration) {
+                this.memoryHealthValue = health;
+                this.recordMemoryHealthCompletion(generation);
+                return health;
+            }
+            return this.memoryHealthValue;
+        }).catch(() => {
+            const health = this.memoryHealthValue.backend === "bujo"
+                ? unknownBujoMemoryHealth(this.memoryHealthValue.mode)
+                : this.memoryHealthValue.backend === "supermemory"
+                    ? {
+                        backend: "supermemory",
+                        status: "unknown",
+                        checkedAt: new Date().toISOString(),
+                    }
+                    : unknownNoMemoryHealth();
+            if (!this.stopped && generation === this.memoryHealthGeneration) {
+                this.memoryHealthValue = health;
+                this.recordMemoryHealthCompletion(generation);
+            }
+            this.logger?.warn?.("Memory health refresh failed; publishing sanitized unknown health.", { reason });
+            return health;
+        }).finally(() => {
+            if (this.memoryHealthRefreshInFlight === pending) {
+                this.memoryHealthRefreshInFlight = undefined;
+            }
+        });
+        this.memoryHealthRefreshInFlight = pending;
+        return pending;
+    }
+    async computeMemoryHealth() {
+        let config;
+        try {
+            config = await loadAppCoreConfig({ env: this.env, cwd: this.cwd, configPath: this.configPath });
+        }
+        catch {
+            return unknownNoMemoryHealth();
+        }
+        const memory = config.memory;
+        if (memory === undefined) {
+            return {
+                backend: "none",
+                status: "not_configured",
+                checkedAt: new Date().toISOString(),
+            };
+        }
+        if ((memory.backend ?? "bujo") === "supermemory") {
+            return {
+                backend: "supermemory",
+                status: "unknown",
+                checkedAt: new Date().toISOString(),
+            };
+        }
+        try {
+            const { auditBujoMemoryHealth } = await import("@mono-agent/memory/bujo");
+            return traceMemoryHealthFromBujo(auditBujoMemoryHealth({
+                root: memory.path,
+                mode: memory.mode,
+                ...(memory.embeddings === undefined
+                    ? {}
+                    : {
+                        configuredEmbeddingModel: `${memory.embeddings.provider}:${memory.embeddings.model}`,
+                        configuredDimension: memory.embeddings.dim ?? 768,
+                    }),
+            }));
+        }
+        catch {
+            return unknownBujoMemoryHealth(memory.mode);
+        }
+    }
+    startMemoryHealthRefreshLoop(intervalMs) {
+        this.memoryHealthRefreshLoopActive = true;
+        this.memoryHealthRefreshIntervalMs = intervalMs;
+        this.scheduleMemoryHealthRefresh();
+    }
+    scheduleMemoryHealthRefresh(delayOverrideMs) {
+        this.clearMemoryHealthRefreshTimer();
+        if (!this.memoryHealthRefreshLoopActive || this.stopped || this.traceSource === undefined)
+            return;
+        const elapsed = this.memoryHealthLastCompletedAtMs === undefined
+            ? this.memoryHealthRefreshIntervalMs
+            : Math.max(0, performance.now() - this.memoryHealthLastCompletedAtMs);
+        const delay = delayOverrideMs ?? Math.max(0, this.memoryHealthRefreshIntervalMs - elapsed);
+        this.memoryHealthRefreshTimer = setTimeout(() => {
+            this.memoryHealthRefreshTimer = undefined;
+            this.refreshMemoryHealthOnTimer();
+        }, delay);
+        this.memoryHealthRefreshTimer.unref?.();
+    }
+    recordMemoryHealthCompletion(generation) {
+        if (this.stopped || generation !== this.memoryHealthGeneration)
+            return;
+        this.memoryHealthLastCompletedAtMs = performance.now();
+        // Any full audit that was already running when the timer became due
+        // satisfies that due tick; never queue an immediate second audit.
+        this.memoryHealthRefreshDue = false;
+        this.scheduleMemoryHealthRefresh(this.memoryHealthRefreshIntervalMs);
+    }
+    refreshMemoryHealthOnTimer() {
+        if (this.stopped)
+            return;
+        if (this.memoryHealthLastCompletedAtMs !== undefined) {
+            const elapsed = performance.now() - this.memoryHealthLastCompletedAtMs;
+            if (elapsed < this.memoryHealthRefreshIntervalMs) {
+                this.scheduleMemoryHealthRefresh();
+                return;
+            }
+        }
+        // Set the due bit before joining the trace single-flight. If a publication
+        // is already active it consumes one bounded trailing replay rather than
+        // dropping this tick and waiting another full interval.
+        this.memoryHealthRefreshDue = true;
+        void this.refreshTraceSource("memory-health-periodic").catch(() => undefined);
+    }
+    /**
+     * Re-audit after channel responders and the shared memory store have started.
+     * The trace source is registered first, so its registration audit can only
+     * observe the previous/stopped runtime snapshot. This one lifecycle force is
+     * generation-fenced and uses the same health/trace single-flights as timer
+     * work; ordinary session and trace events continue to reuse the 30s cache.
+     */
+    async refreshMemoryHealthAfterLifecycle(reason) {
+        if (this.stopped)
+            return;
+        const generation = this.memoryHealthGeneration;
+        const joinedExistingAudit = this.memoryHealthRefreshInFlight !== undefined;
+        await this.refreshMemoryHealthSnapshot(reason, true);
+        if (joinedExistingAudit && !this.stopped && generation === this.memoryHealthGeneration) {
+            await this.refreshMemoryHealthSnapshot(reason, true);
+        }
+        if (this.stopped || generation !== this.memoryHealthGeneration)
+            return;
+        await this.refreshTraceSource(reason);
+    }
+    clearMemoryHealthRefreshTimer() {
+        if (this.memoryHealthRefreshTimer !== undefined) {
+            clearTimeout(this.memoryHealthRefreshTimer);
+            this.memoryHealthRefreshTimer = undefined;
+        }
+    }
+    invalidateMemoryHealthRefresh() {
+        this.memoryHealthRefreshLoopActive = false;
+        this.clearMemoryHealthRefreshTimer();
+        this.memoryHealthGeneration += 1;
+        this.memoryHealthRefreshInFlight = undefined;
+        this.memoryHealthLastCompletedAtMs = undefined;
+        this.memoryHealthRefreshDue = false;
     }
     /**
      * Start the interaction bridge once, when a blocking ask tool is allowed by
-     * the tool policy or the operator configured the `interaction` block. Exports the
-     * bridge env into the app env AND process env so settings resolution and
-     * spawned stdio tool children (which inherit process.env) can reach it.
+     * the tool policy, a request-context MCP needs scoped progress, or the operator
+     * configured the `interaction` block. The master bearer remains app-owned.
      */
     ensureInteractionBridge(coreConfig) {
         this.interactionBridgeStart ??= (async () => {
-            const askUserAllowed = isAdapterSendToolAllowed("AskUser", {
+            const directOpenCodeRoute = runtimeRouteContainsDirectOpenCode(coreConfig);
+            const settings = await loadInteractionSettings({ env: this.env, configPath: this.configPath });
+            const askUserAllowed = !directOpenCodeRoute && isAdapterSendToolAllowed("AskUser", {
                 allowedTools: coreConfig.tools.allowedTools,
                 disallowedTools: coreConfig.tools.disallowedTools,
             });
-            const telegramAskAllowed = isAdapterSendToolAllowed("TelegramAskButtons", {
+            const telegramAskAllowed = !directOpenCodeRoute && isAdapterSendToolAllowed("TelegramAskButtons", {
                 allowedTools: coreConfig.tools.allowedTools,
                 disallowedTools: coreConfig.tools.disallowedTools,
             });
-            const settings = await loadInteractionSettings({ env: this.env, configPath: this.configPath });
-            if (!askUserAllowed && !telegramAskAllowed && !settings.configured) {
+            const scopedProgressNeeded = settings.progressEnabled
+                && (coreConfig.tools.mcpRequestContextServers?.length ?? 0) > 0;
+            if (!askUserAllowed && !telegramAskAllowed && !scopedProgressNeeded && !settings.configured) {
                 return undefined;
             }
             try {
@@ -431,12 +696,6 @@ class MonoAgentAppController {
                     askTimeoutMs: settings.askTimeoutMs,
                     ...(this.logger === undefined ? {} : { logger: this.logger }),
                 });
-                const bridgeEnv = bridge.env();
-                this.interactionBridgeEnvKeys = Object.keys(bridgeEnv);
-                Object.assign(this.env, bridgeEnv);
-                if (this.env !== process.env) {
-                    Object.assign(process.env, bridgeEnv);
-                }
                 this.interactionBridge = bridge;
                 this.logger?.info?.("Interaction bridge started.", { url: bridge.url });
                 return bridge;
@@ -454,13 +713,6 @@ class MonoAgentAppController {
         const bridge = this.interactionBridge;
         this.interactionBridge = undefined;
         this.interactionBridgeStart = undefined;
-        for (const key of this.interactionBridgeEnvKeys) {
-            delete this.env[key];
-            if (this.env !== process.env) {
-                delete process.env[key];
-            }
-        }
-        this.interactionBridgeEnvKeys = [];
         await bridge?.stop().catch(() => undefined);
     }
     async stop() {
@@ -468,6 +720,9 @@ class MonoAgentAppController {
             return;
         }
         this.stopped = true;
+        // Stop the periodic audit before the first teardown await. Already-entered
+        // computation is generation-fenced and must never delay shutdown.
+        this.invalidateMemoryHealthRefresh();
         for (const driver of this.drivers) {
             await this.stopChannel(driver.id, "stop");
         }
@@ -783,35 +1038,85 @@ class MonoAgentAppController {
         if (!this.activeRuntimes.includes(runtime)) {
             this.activeRuntimes.push(runtime);
         }
-        const memory = await this.memoryStore(coreConfig);
-        const memoryRecall = this.memoryRecallRuntimeOptions(coreConfig);
+        const memoryBackend = await this.memoryStore(coreConfig);
+        const memoryRetrieval = this.ensureSharedMemoryRetrieval(coreConfig, memoryBackend);
+        const memory = memoryRetrieval ?? memoryBackend;
+        const memoryRecallEnabled = this.reportMemoryRecallStatus(coreConfig, memoryRetrieval);
         const supermemoryMcp = this.supermemoryMcpRuntimeOptions(coreConfig);
         const adapterSendTools = await this.adapterSendToolsRuntimeOptions(coreConfig);
+        const runHistoryBase = isRunHistoryToolAllowed(coreConfig.tools)
+            && !runtimeRouteContainsDirectOpenCode(coreConfig)
+            ? createRunHistoryRuntimeExtension({
+                artifactDir: coreConfig.artifacts.dir,
+                onUnavailable: (error) => {
+                    this.logger?.warn?.("RunHistory tool endpoint could not start; continuing without prior-run inspection.", {
+                        reason: reasonOf(error),
+                    });
+                },
+            })
+            : undefined;
         // Always active: a no-op for interactive turns (which carry no cron/webhook
         // metadata), it applies the per-trigger model/effort override otherwise.
-        const requestModelOverride = this.requestModelOverrideRuntimeOptions(coreConfig);
+        const mcpSources = [];
+        if (coreConfig.tools.mcpConfigPath !== undefined) {
+            try {
+                const names = Object.keys(loadToolPolicyFromJsonFileSync(coreConfig.tools.mcpConfigPath).mcpServers ?? {});
+                if (names.length > 0)
+                    mcpSources.push(`tools.mcpConfigPath (${names.join(", ")})`);
+            }
+            catch {
+                // Responder construction owns the missing/malformed policy error.
+            }
+        }
+        if (memoryRecallEnabled)
+            mcpSources.push("memory.recallTool");
+        if (supermemoryMcp !== undefined)
+            mcpSources.push("memory.supermemory.exposeMcpServer");
+        if (adapterSendTools.blockingToolNames.length > 0) {
+            mcpSources.push(`adapter send tools (${adapterSendTools.blockingToolNames.join(", ")})`);
+        }
+        const requestModelOverride = this.requestModelOverrideRuntimeOptions(coreConfig, {
+            mcpSources,
+            indexSkillsActive: coreConfig.context.skillDisclosure === "index"
+                && coreConfig.context.skillsRoot !== undefined,
+        });
+        const adapterSendToolsExtension = adapterSendTools.createExtension?.(requestModelOverride.targetsDirectOpenCode);
+        const runHistoryExtension = runHistoryBase === undefined
+            ? undefined
+            : async (requestInput) => requestModelOverride.targetsDirectOpenCode(requestInput.request.metadata)
+                ? { runtimeOptions: {}, cleanup: async () => { } }
+                : await runHistoryBase(requestInput);
         const runtimeOptionsForRequest = composeRuntimeOptionExtensions([
-            memoryRecall,
             supermemoryMcp,
-            adapterSendTools,
-            requestModelOverride,
+            runHistoryExtension,
+            adapterSendToolsExtension,
+            requestModelOverride.extension,
         ]);
         // The override factory is only needed when fallbacks are configured: the
         // fallback router freezes the model chain, so an override must run on a runtime
         // whose chain has it as primary. With no fallbacks the shared (plain) runtime
         // honors the per-run model directly, so building a separate runtime would be
         // redundant. Omit the factory there and the harness uses the shared runtime.
-        const runtimeForModel = (coreConfig.runtime.fallbackModels?.length ?? 0) > 0
+        const runtimeForModel = hasConfiguredRuntimeFallbacks(coreConfig.runtime)
             ? this.buildRuntimeForModel(coreConfig)
             : undefined;
         const observabilityContext = await this.observabilityContext();
         const responder = await createConfiguredAgentResponder({
             config: coreConfig,
+            cwd: this.cwd,
             runtime,
             ...(runtimeForModel === undefined ? {} : { runtimeForModel }),
             ...(this.sandboxEngine === undefined ? {} : { sandboxEngine: this.sandboxEngine }),
             ...(memory !== undefined && { memory }),
+            ...(this.interactionBridge === undefined ? {} : { turnHistoryEnricher: this.interactionBridge }),
+            ...(this.interactionBridge === undefined ? {} : { progressCapabilityIssuer: this.interactionBridge }),
             ...(runtimeOptionsForRequest === undefined ? {} : { runtimeOptionsForRequest }),
+            onMemoryRecallUnavailable: (error) => {
+                this.logger?.warn?.("MemoryRecall tool endpoint could not start; continuing without the explicit tool.", { error: reasonOf(error) });
+            },
+            onMemoryWarning: (message) => {
+                this.logger?.warn?.(message);
+            },
             // Thread run-identifying context onto exported spans and surface per-run
             // export warnings to `exporterStatus` (agent-host only builds the exporter
             // when config.observability.exporters is non-empty).
@@ -831,12 +1136,26 @@ class MonoAgentAppController {
      * block for the OVERRIDE model (see request-model-override doc). Composed
      * alongside the memory/adapter extensions.
      */
-    requestModelOverrideRuntimeOptions(coreConfig) {
-        const extension = createRequestModelOverrideRuntimeExtension({
+    requestModelOverrideRuntimeOptions(coreConfig, compatibility) {
+        const options = {
             ...(this.logger === undefined ? {} : { logger: this.logger }),
+            baseModel: coreConfig.runtime.model,
+            ...(configuredRuntimeFallbackModels(coreConfig.runtime).length === 0
+                ? {}
+                : { fallbackModels: configuredRuntimeFallbackModels(coreConfig.runtime) }),
+            ...(coreConfig.runtime.effort === undefined ? {} : { baseEffort: coreConfig.runtime.effort }),
+            ...(coreConfig.runtime.maxTurns === undefined ? {} : { baseMaxTurns: coreConfig.runtime.maxTurns }),
+            ...(compatibility.mcpSources.length === 0 ? {} : { mcpSources: compatibility.mcpSources }),
+            ...(compatibility.indexSkillsActive ? { indexSkillsActive: true } : {}),
+            ...(coreConfig.sandbox === undefined ? {} : { sandboxPolicy: coreConfig.sandbox }),
+            toolPolicy: coreConfig.tools,
             ...(coreConfig.providers?.local === undefined ? {} : { localProviders: coreConfig.providers.local }),
-        });
-        return async (input) => extension({ request: input.request });
+        };
+        const extension = createRequestModelOverrideRuntimeExtension(options);
+        return {
+            extension: async (input) => extension({ request: input.request }),
+            targetsDirectOpenCode: (metadata) => requestModelOverrideTargetsDirectOpenCode(metadata, options),
+        };
     }
     /**
      * Memoized factory for runtimes bound to a per-request override model. Reuses
@@ -879,15 +1198,19 @@ class MonoAgentAppController {
         ]);
         return { sourceId, sourceLabel, configPath: this.configPath };
     }
-    memoryRecallRuntimeOptions(coreConfig) {
+    reportMemoryRecallStatus(coreConfig, service) {
         const settings = resolveMemoryRecallSettings(coreConfig);
         if (settings === undefined) {
-            return undefined;
+            return false;
+        }
+        if (service === undefined) {
+            this.logger?.warn?.("MemoryRecall could not be enabled because the configured store has no recall surface.");
+            return false;
         }
         this.logger?.info?.("Read-only MemoryRecall tool enabled.", {
             provider: "supermemory" in settings ? "supermemory" : settings.embeddings?.provider ?? "fts-only",
         });
-        return createMemoryRecallRuntimeExtension(settings, this.cwd);
+        return true;
     }
     /**
      * Optional CLOUD-ONLY escape hatch: when `memory.supermemory.exposeMcpServer` is on, ALSO inject
@@ -918,21 +1241,47 @@ class MonoAgentAppController {
     }
     async adapterSendToolsRuntimeOptions(coreConfig) {
         const input = { env: this.env, cwd: this.cwd, configPath: this.configPath };
+        const bridgeEnv = this.interactionBridge?.env();
+        const appOwnedInteraction = this.interactionBridge === undefined || bridgeEnv === undefined
+            ? undefined
+            : {
+                bridgeUrl: this.interactionBridge.url,
+                bridgeToken: this.interactionBridge.token,
+                timeoutMs: Number(bridgeEnv.MONO_AGENT_ASK_USER_TIMEOUT_MS),
+            };
         const settings = await resolveAdapterSendToolsSettings(input, {
             allowedTools: coreConfig.tools.allowedTools,
             disallowedTools: coreConfig.tools.disallowedTools,
             logger: this.logger,
+            suppressInteractionTools: runtimeRouteContainsDirectOpenCode(coreConfig),
+            ...(appOwnedInteraction === undefined ? {} : { interaction: appOwnedInteraction }),
         });
         if (settings === undefined) {
-            return undefined;
+            return { blockingToolNames: [] };
         }
         const toolNames = adapterSendToolNames(settings);
+        const blockingToolNames = toolNames.filter((name) => !isInteractionToolName(name));
         this.logger?.info?.("Adapter send tools enabled.", { tools: toolNames });
         // Forward the posted-message index path so `SlackSendMessage` links each post
         // back to the producing conversation (so a later in-thread reply resumes it).
         const indexPath = resolvePostedMessageIndexPath(await resolveAppArtifactDir(input));
-        const interaction = settings.askUser ?? settings.telegram?.askBridge;
-        return createAdapterSendToolsRuntimeExtension(this.configPath, this.cwd, toolNames, indexPath, interaction);
+        const interactionForChild = settings.askUser ?? settings.telegram?.askBridge;
+        const runOutputRoot = settings.telegram?.sendTools?.pathScope === "run-output"
+            ? resolve(coreConfig.artifacts.dir, "outbound")
+            : undefined;
+        const createExtension = (targetsDirectOpenCode) => async (requestInput) => {
+            const effectiveToolNames = targetsDirectOpenCode(requestInput.request.metadata)
+                ? toolNames.filter((name) => !isInteractionToolName(name))
+                : toolNames;
+            if (effectiveToolNames.length === 0) {
+                return { runtimeOptions: {}, cleanup: async () => { } };
+            }
+            const effectiveInteraction = effectiveToolNames.some(isInteractionToolName)
+                ? interactionForChild
+                : undefined;
+            return await createAdapterSendToolsRuntimeExtension(this.configPath, this.cwd, effectiveToolNames, indexPath, effectiveInteraction, runOutputRoot)(requestInput);
+        };
+        return { createExtension, blockingToolNames };
     }
     /** Build the configured memory store once and share it across responders + the ritual scheduler. */
     async memoryStore(coreConfig) {
@@ -964,9 +1313,11 @@ class MonoAgentAppController {
                 runEventSink: this.liveEventBus,
             };
             this.sharedMemory = await createConfiguredMemory(coreConfig, {
+                cwd: this.cwd,
                 ...(logger === undefined ? {} : { logger }),
                 observability,
             });
+            this.ensureSharedMemoryRetrieval(coreConfig, this.sharedMemory);
             this.sharedMemoryBuilt = true;
             return this.sharedMemory;
         })();
@@ -981,20 +1332,36 @@ class MonoAgentAppController {
     async resetSharedMemory() {
         const mem = this.sharedMemory;
         this.sharedMemory = undefined;
+        this.sharedMemoryRetrieval?.releaseAllTurns();
+        this.sharedMemoryRetrieval = undefined;
         this.sharedMemoryBuilt = false;
         this.sharedMemoryBuild = undefined;
-        if (mem?.flush !== undefined) {
-            await Promise.resolve(mem.flush()).catch(() => undefined);
-        }
         if (mem?.close !== undefined) {
             await Promise.resolve(mem.close()).catch(() => undefined);
         }
+        else if (mem?.flush !== undefined) {
+            // Stores without a lifecycle-aware close retain the legacy best-effort
+            // drain. BuJo close owns its bounded shutdown deadline itself.
+            await Promise.resolve(mem.flush()).catch(() => undefined);
+        }
     }
     /** @internal Test-only seam: seed the shared memory store without going through config. */
     __setSharedMemoryForTest(store) {
         this.sharedMemory = store;
+        this.sharedMemoryRetrieval = undefined;
         this.sharedMemoryBuilt = true;
     }
+    ensureSharedMemoryRetrieval(coreConfig, store) {
+        if (this.sharedMemoryRetrieval !== undefined)
+            return this.sharedMemoryRetrieval;
+        if (coreConfig.memory === undefined || !isSharedRecallStore(store))
+            return undefined;
+        this.sharedMemoryRetrieval = new MemoryRetrievalService(store, {
+            maxBytes: coreConfig.memory.maxBytes,
+            source: (coreConfig.memory.backend ?? "bujo") === "supermemory" ? "supermemory" : "memory-bujo",
+        });
+        return this.sharedMemoryRetrieval;
+    }
     setStatus(id, status) {
         this.statuses.set(id, status);
         return status;
@@ -1033,14 +1400,25 @@ class MonoAgentAppController {
         };
     }
     async stopTraceSource(reason) {
+        this.invalidateMemoryHealthRefresh();
         const traceSource = this.traceSource;
         const globalTraceSource = this.globalTraceSource;
+        // Detach before stopping. A health probe may be stalled indefinitely; its
+        // generation/handle checks fence any late result, while a reload is free to
+        // register and refresh a new source without waiting for the old probe.
+        this.traceSource = undefined;
+        this.globalTraceSource = undefined;
+        this.traceRefreshInFlight = undefined;
+        this.traceRefreshDirty = false;
+        this.traceRefreshLatestReason = undefined;
         if (traceSource === undefined && globalTraceSource === undefined) {
             return;
         }
-        this.traceSource = undefined;
-        this.globalTraceSource = undefined;
-        const patch = { metadata: this.traceMetadata(reason), transports: this.activeTransports() };
+        const patch = {
+            metadata: this.traceMetadata(reason),
+            transports: this.activeTransports(),
+            memoryHealth: this.memoryHealthValue,
+        };
         await traceSource?.stop(patch).catch((error) => {
             this.logger?.warn?.("Traceability source stop update failed.", { reason: reasonOf(error) });
         });
@@ -1163,6 +1541,81 @@ class MonoAgentAppController {
         };
     }
 }
+function traceMemoryHealthFromBujo(report) {
+    return {
+        backend: "bujo",
+        mode: report.mode,
+        status: traceMemoryStatus(report.status),
+        checkedAt: report.checkedAt,
+        issues: report.issues.map(traceMemoryIssue),
+        counts: {
+            pending: report.counts.pending,
+            due: report.counts.due,
+            dead: report.counts.dead,
+            outbox: report.counts.outbox,
+            temporary: report.counts.temporary,
+            memories: report.counts.memories,
+            vectors: report.counts.vectors,
+            missingVectors: report.counts.missingVectors,
+        },
+    };
+}
+function traceMemoryStatus(status) {
+    switch (status) {
+        case "healthy":
+        case "in_progress":
+        case "degraded":
+        case "unhealthy":
+        case "unknown":
+            return status;
+    }
+}
+function traceMemoryIssue(issue) {
+    switch (issue) {
+        case "manifest_missing":
+        case "manifest_invalid":
+        case "configured_identity_mismatch":
+        case "database_missing":
+        case "database_unavailable":
+        case "native_module_unavailable":
+        case "health_check_failed":
+        case "sqlite_integrity_failed":
+        case "metadata_mismatch":
+        case "fts_mismatch":
+        case "vector_mismatch":
+        case "orphaned_rows":
+        case "canonical_mismatch":
+        case "canonical_invalid":
+        case "mutation_in_progress":
+        case "intake_invalid":
+        case "intake_pending":
+        case "dead_letters":
+        case "outbox_invalid":
+        case "outbox_pending":
+        case "work_stalled":
+        case "temporary_artifacts":
+        case "runtime_missing":
+        case "runtime_stale":
+        case "runtime_invalid":
+            return issue;
+    }
+}
+function unknownNoMemoryHealth() {
+    return {
+        backend: "none",
+        status: "unknown",
+        checkedAt: new Date().toISOString(),
+    };
+}
+function unknownBujoMemoryHealth(mode) {
+    return {
+        backend: "bujo",
+        mode,
+        status: "unknown",
+        checkedAt: new Date().toISOString(),
+        issues: ["health_check_failed"],
+    };
+}
 function nextDailyRolloverAt(now, timezone) {
     if (timezone === undefined || timezone.trim().length === 0) {
         const next = new Date(now);
@@ -1229,71 +1682,11 @@ function sandboxStatusFromState(state) {
 function reasonOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
-/**
- * Compose several per-request runtime-options extensions into one. Each extension is invoked per
- * request; mergeable runtime option maps/lists are unioned and their cleanups are chained. Returns
- * `undefined` when no extension is active, so the host omits `runtimeOptionsForRequest` entirely.
- */
-function composeRuntimeOptionExtensions(extensions) {
-    const active = extensions.filter((extension) => extension !== undefined);
-    if (active.length === 0) {
-        return undefined;
-    }
-    if (active.length === 1) {
-        return active[0];
-    }
-    return async (input) => {
-        const results = await Promise.all(active.map((extension) => extension(input)));
-        const runtimeOptions = {};
-        for (const result of results) {
-            mergeRuntimeOptions(runtimeOptions, result.runtimeOptions);
-        }
-        return {
-            runtimeOptions,
-            cleanup: async () => {
-                // Chain every cleanup; run them all even if one rejects so no extension leaks resources.
-                await Promise.all(results.map(async (result) => result.cleanup?.()));
-            },
-        };
-    };
-}
-function mergeRuntimeOptions(target, next) {
-    if (next === undefined) {
-        return;
-    }
-    for (const [key, value] of Object.entries(next)) {
-        if (value === undefined) {
-            continue;
-        }
-        if (key === "allowedTools" || key === "disallowedTools") {
-            target[key] = mergeStringLists(target[key], value);
-            continue;
-        }
-        if (key === "mcpServers") {
-            target[key] = {
-                ...(isRecord(target[key]) ? target[key] : {}),
-                ...(isRecord(value) ? value : {}),
-            };
-            continue;
-        }
-        target[key] = value;
-    }
-}
-function mergeStringLists(current, next) {
-    const out = [];
-    for (const list of [current, next]) {
-        if (!Array.isArray(list)) {
-            continue;
-        }
-        for (const item of list) {
-            if (typeof item === "string" && !out.includes(item)) {
-                out.push(item);
-            }
-        }
-    }
-    return out;
+function runtimeRouteContainsDirectOpenCode(config) {
+    return configuredRuntimeModels(config.runtime)
+        .some((model) => model.sdk === "opencode");
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+function isInteractionToolName(name) {
+    return name === "AskUser" || name === "TelegramAskButtons";
 }
 //# sourceMappingURL=app.js.map