@mono-agent/agent-app 0.2.2 → 0.4.0

package/dist/app.js

@@ -1,60 +1,23 @@
 import { resolve } from "node:path";
-import { startOperatorConsole } from "@mono-agent/operator-console";
-import { createConfiguredAgentResponder, createConfiguredAgentRuntime } from "@mono-agent/agent-host";
+import { createConfiguredAgentResponder, createConfiguredAgentRuntime, createConfiguredMemory, } from "@mono-agent/agent-host";
 import { registerTraceSource } from "@mono-agent/observability";
-import { isAppCoreConfigError, loadAppCoreConfig, MONO_AGENT_APP_FIELD_GROUPS, resolveAppArtifactDir, resolveAppConsoleSettings, resolveAppTraceHeartbeatMs, resolveAppTraceRegistryDir, resolveAppTraceSourceId, resolveAppTraceSourceLabel, resolveAppTraceStaleAfterMs, } from "./app-config.js";
+import { isAppCoreConfigError, loadAppCoreConfig, resolveAppArtifactDir, resolveAppObservabilityExporters, resolveAppTraceHeartbeatMs, resolveAppTraceRegistryDir, resolveAppTraceSourceId, resolveAppTraceSourceLabel, resolveAppTraceStaleAfterMs, } from "./app-config.js";
 import { defaultChannelDrivers } from "./channels.js";
+import { adapterSendToolNames, createAdapterSendToolsRuntimeExtension, resolveAdapterSendToolsSettings, } from "./adapter-send-tools.js";
+import { startMemoryRituals } from "./memory-rituals.js";
+import { createMemoryRecallRuntimeExtension, resolveMemoryRecallSettings, } from "./memory-recall.js";
 /**
- * Starts a config-first mono-agent host in `cwd`: operator console first (so
- * an incomplete config can be fixed in the browser), then traceability, then
- * every configured channel in parallel. Channels with incomplete config report
- * `waiting_for_config` instead of blocking the rest.
+ * Starts a config-first mono-agent host in `cwd`: traceability first, then every
+ * configured channel in parallel. Channels with incomplete config report
+ * `waiting_for_config` instead of blocking the rest. The host runs headless;
+ * config changes take effect on the next restart.
  */
 export async function startMonoAgentApp(options = {}) {
     const cwd = resolve(options.cwd ?? process.cwd());
     const configPath = resolve(cwd, options.configPath ?? "mono-agent.config.json");
     const env = options.env ?? process.env;
     const drivers = options.drivers ?? defaultChannelDrivers();
-    const input = { env, cwd, configPath };
-    let controller;
-    let consoleServer;
-    const consoleSettings = await resolveAppConsoleSettings(input);
-    const consolePort = options.operatorConsolePort ?? consoleSettings.port;
-    if (options.operatorConsole !== false && consoleSettings.enabled) {
-        const consoleFactory = options.operatorConsoleFactory ?? startOperatorConsole;
-        consoleServer = await consoleFactory({
-            configPath,
-            cwd,
-            fieldGroups: options.fieldGroups ?? MONO_AGENT_APP_FIELD_GROUPS,
-            observability: {
-                artifactDir: () => resolveAppArtifactDir(input),
-                maxRuns: 100,
-                maxEventsPerRun: 750,
-            },
-            traceability: {
-                registryDir: () => resolveAppTraceRegistryDir(input),
-                staleAfterMs: () => resolveAppTraceStaleAfterMs(input),
-                maxRuns: 100,
-                maxEventsPerRun: 750,
-            },
-            applyConfigWrite: async () => {
-                if (controller === undefined) {
-                    return {
-                        kind: "failed",
-                        message: "Mono agent app lifecycle is not ready to apply config changes.",
-                        transports: [],
-                    };
-                }
-                return await controller.applyConfigChange("operator-console-write");
-            },
-            ...(consolePort === undefined ? {} : { port: consolePort }),
-            log: (event) => {
-                logOperatorConsoleEvent(options.logger, event);
-            },
-        });
-    }
-    controller = new MonoAgentAppController({
-        consoleServer,
+    const controller = new MonoAgentAppController({
         cwd,
         configPath,
         env,
@@ -64,14 +27,14 @@ export async function startMonoAgentApp(options = {}) {
         ...(options.traceDefaults === undefined ? {} : { traceDefaults: options.traceDefaults }),
     });
     await controller.startTraceability("startup");
+    await controller.startExporters("startup");
     await Promise.all(drivers.map((driver) => controller?.startChannelIfConfigured(driver.id, "startup")));
+    await controller.startMemoryRitualsIfConfigured("startup");
     await controller.refreshTraceSource("startup-complete");
     return controller;
 }
 class MonoAgentAppController {
-    operatorConsole;
     configPath;
-    consoleServer;
     cwd;
     env;
     drivers;
@@ -87,11 +50,21 @@ class MonoAgentAppController {
         kind: "disabled",
         reason: "Traceability has not started yet.",
     };
+    exporterStatusValue = {
+        kind: "disabled",
+        reason: "No observability exporter configured.",
+    };
+    /** The exporter the responder threads into agent-host (first configured exporter). */
+    resolvedExporter;
     traceSource;
+    memoryRituals;
+    // 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;
+    sharedMemoryBuilt = false;
     configApplyTail = Promise.resolve();
     stopped = false;
     constructor(input) {
-        this.consoleServer = input.consoleServer;
         this.cwd = input.cwd;
         this.configPath = input.configPath;
         this.env = input.env;
@@ -106,18 +79,13 @@ class MonoAgentAppController {
                 reason: `${driver.label} has not been configured yet.`,
             });
         }
-        this.operatorConsole = input.consoleServer === undefined
-            ? undefined
-            : {
-                url: input.consoleServer.url,
-                appUrl: `${input.consoleServer.url}/?t=${input.consoleServer.token}`,
-                token: input.consoleServer.token,
-                configPath: input.configPath,
-            };
     }
     get traceabilityStatus() {
         return this.traceabilityStatusValue;
     }
+    get exporterStatus() {
+        return this.exporterStatusValue;
+    }
     channelStatus(id) {
         const status = this.statuses.get(id);
         if (status === undefined) {
@@ -140,9 +108,13 @@ class MonoAgentAppController {
             for (const driver of this.drivers) {
                 await this.stopChannel(driver.id, `${reason}:reload`);
             }
+            this.stopMemoryRituals();
+            await this.resetSharedMemory();
             await this.stopTraceSource(`${reason}:reload`);
             await this.startTraceability(reason);
+            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`);
             return this.applyResult();
         };
@@ -156,11 +128,6 @@ class MonoAgentAppController {
             return this.channelStatus(id);
         }
         if (this.running.has(id)) {
-            if (reason === "operator-console-write") {
-                this.logger?.info?.(`${driver.label} is already running; restart the app to apply later config changes.`, {
-                    status: "running",
-                });
-            }
             await this.refreshTraceSource(reason);
             return this.channelStatus(id);
         }
@@ -210,6 +177,63 @@ class MonoAgentAppController {
         }
         return this.traceabilityStatusValue;
     }
+    /**
+     * Resolve the configured observability exporter(s) and publish the export
+     * status. No reachability probe runs here — Phoenix may start after the agent,
+     * so an unreachable endpoint must not block startup (that probe runs in
+     * `validate`). A present-but-invalid exporter config surfaces as `failed`.
+     */
+    async startExporters(reason) {
+        if (this.stopped) {
+            return this.exporterStatusValue;
+        }
+        const input = { env: this.env, cwd: this.cwd, configPath: this.configPath };
+        let exporters;
+        try {
+            exporters = await resolveAppObservabilityExporters(input);
+        }
+        catch (error) {
+            this.resolvedExporter = undefined;
+            this.exporterStatusValue = { kind: "failed", reason: reasonOf(error) };
+            this.logger?.error?.("Observability exporter config is invalid.", { reason: reasonOf(error) });
+            return this.exporterStatusValue;
+        }
+        const exporter = exporters[0];
+        if (exporter === undefined) {
+            this.resolvedExporter = undefined;
+            this.exporterStatusValue = { kind: "disabled", reason: "No observability exporter configured." };
+            return this.exporterStatusValue;
+        }
+        this.resolvedExporter = exporter;
+        this.exporterStatusValue = {
+            kind: "configured",
+            endpoint: exporter.endpoint,
+            includeSensitiveData: exporter.includeSensitiveData ?? false,
+        };
+        this.logger?.info?.("Observability exporter configured.", {
+            reason,
+            endpoint: exporter.endpoint,
+            includeSensitiveData: exporter.includeSensitiveData ?? false,
+        });
+        return this.exporterStatusValue;
+    }
+    /** Record a best-effort export warning so `status` can surface it without failing the run. */
+    recordExporterWarning(warning) {
+        const current = this.exporterStatusValue;
+        if (current.kind !== "configured") {
+            return;
+        }
+        const message = `${warning.phase}: ${warning.message}`;
+        // The "fail" phase fires only when export fails on the run-failure path;
+        // surface it as lastError so operators can tell it apart from a transient
+        // best-effort warning. The run outcome is unchanged either way.
+        this.exporterStatusValue =
+            warning.phase === "fail" ? { ...current, lastError: message } : { ...current, lastWarning: message };
+        this.logger?.warn?.("Observability export warning.", { phase: warning.phase, message: warning.message });
+        // Persist to the trace-source manifest so the detached `mono-agent status`
+        // (which reads the manifest, not this live object) can surface it too.
+        void this.refreshTraceSource("exporter-warning").catch(() => undefined);
+    }
     async refreshTraceSource(reason) {
         if (this.traceSource === undefined) {
             return;
@@ -232,12 +256,74 @@ class MonoAgentAppController {
         for (const driver of this.drivers) {
             await this.stopChannel(driver.id, "stop");
         }
+        this.stopMemoryRituals();
+        await this.resetSharedMemory();
         await this.stopTraceSource("stop");
-        await this.consoleServer?.stop();
         for (const runtime of this.activeRuntimes.splice(0)) {
             await runtime.disposeAllSessions?.().catch(() => undefined);
         }
     }
+    async startMemoryRitualsIfConfigured(reason) {
+        if (this.stopped) {
+            return;
+        }
+        let coreConfig;
+        try {
+            const input = { env: this.env, cwd: this.cwd, configPath: this.configPath };
+            coreConfig = await loadAppCoreConfig(input);
+        }
+        catch {
+            // Config not ready yet — rituals will start on the next applyConfigChange.
+            return;
+        }
+        if (coreConfig.memory?.mode !== "bujo") {
+            return;
+        }
+        const runtime = this.runtime ?? createConfiguredAgentRuntime(coreConfig);
+        if (!this.activeRuntimes.includes(runtime)) {
+            this.activeRuntimes.push(runtime);
+        }
+        const store = this.memoryStore(coreConfig, runtime);
+        // Duck-type: only bujo-tier BujoMemoryStore has reflect/migrate.
+        // Cast through unknown to bypass the MemoryStore contract's type mismatch.
+        const storeAsAny = store;
+        if (store === undefined ||
+            typeof storeAsAny["reflect"] !== "function" ||
+            typeof storeAsAny["migrate"] !== "function" ||
+            typeof storeAsAny["tier"] !== "function") {
+            return;
+        }
+        const bujoStore = store;
+        // `memory.mode` is "bujo", but the store derives the runtime tier from its options: without a
+        // `memory.llm` it downgrades to "journal", where startMemoryRituals is a no-op. Don't claim the
+        // scheduler started in that case — log an accurate skip instead.
+        const tier = bujoStore.tier();
+        if (tier !== "bujo") {
+            this.logger?.info?.("Memory ritual scheduler skipped — store tier is not bujo (reflect/migrate need a chat LLM).", { reason, tier });
+            return;
+        }
+        this.memoryRituals = startMemoryRituals({
+            store: bujoStore,
+            ...(coreConfig.memory.reflection !== undefined && { reflection: coreConfig.memory.reflection }),
+            ...(coreConfig.memory.migration !== undefined && { migration: coreConfig.memory.migration }),
+            ...(this.logger !== undefined && {
+                logger: {
+                    info: (m) => this.logger?.info?.(m),
+                    warn: (m) => this.logger?.warn?.(m),
+                },
+            }),
+        });
+        this.logger?.info?.("Memory ritual scheduler started.", { reason, mode: "bujo" });
+    }
+    stopMemoryRituals() {
+        const rituals = this.memoryRituals;
+        if (rituals === undefined) {
+            return;
+        }
+        this.memoryRituals = undefined;
+        rituals.stop();
+        this.logger?.info?.("Memory ritual scheduler stopped.");
+    }
     async startChannel(driver, reason) {
         const input = { env: this.env, cwd: this.cwd, configPath: this.configPath };
         let config;
@@ -270,7 +356,16 @@ class MonoAgentAppController {
             throw error;
         }
         try {
-            const responder = this.buildResponder(coreConfig);
+            const responder = await this.buildResponder(coreConfig);
+            // The AgentResponder contract has no dispose(), but the configured responder
+            // (createAgentResponder) exposes one that tears down the harness + live-session
+            // manager. Read it LAZILY (at teardown time) off the `responder` so both the
+            // normal stop/reload path AND the onFailure (transport-death) path retire the
+            // per-channel harness rather than orphan it, and any wrapper applied to the
+            // responder is honored. Duck-typed, consistent with the resetSharedMemory /
+            // bujo-store patterns elsewhere in this file.
+            const disposeResponder = () => responder.dispose?.();
+            const hasDispose = typeof responder.dispose === "function";
             const runningChannel = await driver.start({
                 config,
                 coreConfig,
@@ -281,9 +376,23 @@ class MonoAgentAppController {
                     this.running.delete(driver.id);
                     this.setStatus(driver.id, { kind: "failed", reason: failureReason });
                     this.logger?.error?.(`${driver.label} channel stopped with an error.`, { reason: failureReason });
+                    // The running-channel entry (which holds the stop/reload dispose handle)
+                    // was just deleted, so dispose the responder here too — otherwise a
+                    // transport death orphans the per-channel harness/live-session manager
+                    // (the stop/reload path early-returns on the now-missing entry).
+                    void disposeResponder()?.catch((error) => {
+                        this.logger?.warn?.(`${driver.label} responder did not dispose cleanly after failure.`, {
+                            reason: failureReason,
+                            error: reasonOf(error),
+                        });
+                    });
                 },
             });
-            this.running.set(driver.id, runningChannel);
+            this.running.set(driver.id, {
+                ...runningChannel,
+                stop: () => runningChannel.stop(),
+                ...(hasDispose ? { dispose: () => disposeResponder() ?? Promise.resolve() } : {}),
+            });
             const status = this.setStatus(driver.id, { kind: "running", summary: runningChannel.summary });
             this.logger?.info?.(`${driver.label} channel is running.`, { reason, ...runningChannel.summary });
             return status;
@@ -304,6 +413,12 @@ class MonoAgentAppController {
         await runningChannel.stop().catch((error) => {
             this.logger?.warn?.(`${driver.label} channel did not stop cleanly.`, { reason, error: reasonOf(error) });
         });
+        // Stop the transport first (so no new turns arrive), then dispose the responder
+        // so the harness/live-session manager and warm provider sessions are retired
+        // rather than lingering against stale config across a reload.
+        await runningChannel.dispose?.().catch((error) => {
+            this.logger?.warn?.(`${driver.label} responder did not dispose cleanly.`, { reason, error: reasonOf(error) });
+        });
         if (!this.stopped) {
             this.setStatus(id, {
                 kind: "waiting_for_config",
@@ -311,12 +426,95 @@ class MonoAgentAppController {
             });
         }
     }
-    buildResponder(coreConfig) {
+    async buildResponder(coreConfig) {
         const runtime = this.runtime ?? createConfiguredAgentRuntime(coreConfig);
         if (!this.activeRuntimes.includes(runtime)) {
             this.activeRuntimes.push(runtime);
         }
-        return createConfiguredAgentResponder({ config: coreConfig, runtime });
+        const memory = this.memoryStore(coreConfig, runtime);
+        const memoryRecall = this.memoryRecallRuntimeOptions(coreConfig);
+        const adapterSendTools = await this.adapterSendToolsRuntimeOptions(coreConfig);
+        const runtimeOptionsForRequest = composeRuntimeOptionExtensions([memoryRecall, adapterSendTools]);
+        const observabilityContext = await this.observabilityContext();
+        const responder = createConfiguredAgentResponder({
+            config: coreConfig,
+            runtime,
+            ...(memory !== undefined && { memory }),
+            ...(runtimeOptionsForRequest === undefined ? {} : { runtimeOptionsForRequest }),
+            // 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).
+            observabilityContext,
+            exporterWarn: (warning) => this.recordExporterWarning(warning),
+        });
+        return responder;
+    }
+    /**
+     * Run-identifying context threaded onto exported spans (Phoenix shows the same
+     * source/run identifiers as the local trace-source registry, so local artifact
+     * lookup stays possible). Resolved with the same source-id/label resolvers the
+     * trace source uses.
+     */
+    async observabilityContext() {
+        const input = { env: this.env, cwd: this.cwd, configPath: this.configPath };
+        const [sourceId, sourceLabel] = await Promise.all([
+            resolveAppTraceSourceId(input, this.traceDefaults),
+            resolveAppTraceSourceLabel(input, this.traceDefaults),
+        ]);
+        return { sourceId, sourceLabel, configPath: this.configPath };
+    }
+    memoryRecallRuntimeOptions(coreConfig) {
+        const settings = resolveMemoryRecallSettings(coreConfig);
+        if (settings === undefined) {
+            return undefined;
+        }
+        this.logger?.info?.("Read-only memory_recall tool enabled.", {
+            provider: settings.embeddings?.provider ?? "fts-only",
+        });
+        return createMemoryRecallRuntimeExtension(settings, this.cwd);
+    }
+    async adapterSendToolsRuntimeOptions(coreConfig) {
+        const input = { env: this.env, cwd: this.cwd, configPath: this.configPath };
+        const settings = await resolveAdapterSendToolsSettings(input, {
+            allowedTools: coreConfig.tools.allowedTools,
+            disallowedTools: coreConfig.tools.disallowedTools,
+            logger: this.logger,
+        });
+        if (settings === undefined) {
+            return undefined;
+        }
+        const toolNames = adapterSendToolNames(settings);
+        this.logger?.info?.("Adapter send tools enabled.", { tools: toolNames });
+        return createAdapterSendToolsRuntimeExtension(this.configPath, this.cwd, toolNames);
+    }
+    /** Build the configured memory store once and share it across responders + the ritual scheduler. */
+    memoryStore(coreConfig, runtime) {
+        if (!this.sharedMemoryBuilt) {
+            const appLogger = this.logger;
+            const logger = appLogger?.warn !== undefined
+                ? { warn: (message) => { appLogger.warn?.(message); } }
+                : undefined;
+            this.sharedMemory = createConfiguredMemory(coreConfig, { ...(logger === undefined ? {} : { logger }), runtime });
+            this.sharedMemoryBuilt = true;
+        }
+        return this.sharedMemory;
+    }
+    /** Close + clear the shared memory store (on config reload or stop) so the next build is fresh. */
+    async resetSharedMemory() {
+        const mem = this.sharedMemory;
+        this.sharedMemory = undefined;
+        this.sharedMemoryBuilt = false;
+        if (mem?.flush !== undefined) {
+            await Promise.resolve(mem.flush()).catch(() => undefined);
+        }
+        if (mem?.close !== undefined) {
+            await Promise.resolve(mem.close()).catch(() => undefined);
+        }
+    }
+    /** @internal Test-only seam: seed the shared memory store without going through config. */
+    __setSharedMemoryForTest(store) {
+        this.sharedMemory = store;
+        this.sharedMemoryBuilt = true;
     }
     setStatus(id, status) {
         this.statuses.set(id, status);
@@ -370,9 +568,6 @@ class MonoAgentAppController {
     }
     activeTransports() {
         const transports = [];
-        if (this.consoleServer !== undefined) {
-            transports.push("operator-console");
-        }
         for (const driver of this.drivers) {
             if (this.statuses.get(driver.id)?.kind === "running") {
                 transports.push(driver.id);
@@ -393,29 +588,96 @@ class MonoAgentAppController {
         }
         return {
             reason,
-            ...(this.operatorConsole === undefined
-                ? {}
-                : {
-                    operatorConsole: {
-                        // Only the base loopback URL is persisted — never the per-boot
-                        // access token. A detached `status`/`start` reader surfaces this
-                        // URL and points at the logs for the tokenized link.
-                        url: this.operatorConsole.url,
-                        configPath: this.operatorConsole.configPath,
+            ...(this.exporterStatusValue.kind === "configured"
+                ? {
+                    observability: {
+                        // Persist only the endpoint + warning/error strings (never headers
+                        // or secrets) so the detached `status` reader can surface exporter
+                        // state. JSONL artifacts always remain local.
+                        endpoint: this.exporterStatusValue.endpoint,
+                        includeSensitiveData: this.exporterStatusValue.includeSensitiveData,
+                        jsonlArtifactsLocal: true,
+                        ...(this.exporterStatusValue.lastWarning === undefined
+                            ? {}
+                            : { lastWarning: this.exporterStatusValue.lastWarning }),
+                        ...(this.exporterStatusValue.lastError === undefined
+                            ? {}
+                            : { lastError: this.exporterStatusValue.lastError }),
                     },
-                }),
+                }
+                : {}),
             channels,
         };
     }
 }
-function logOperatorConsoleEvent(logger, event) {
-    if (event.kind === "validation_failed" || event.kind === "unauthorized") {
-        logger?.warn?.("Operator Console event.", { event });
+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;
     }
-    logger?.debug?.("Operator Console event.", { event });
+    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 reasonOf(error) {
-    return error instanceof Error ? error.message : String(error);
+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 isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //# sourceMappingURL=app.js.map