@mono-agent/agent-app 0.20.14 → 0.21.1

package/dist/configured-agent.js

@@ -1,4 +1,5 @@
-import { createAgentHarness, createAgentResponder, acquireToolHistoryWriter, createDurableHistoryStore, createToolPolicy, loadToolPolicyFromJsonFileSync, renderSkillIndexSection, ToolHistoryReader, toolHistoryLogicalConversationId, } from "@mono-agent/agent-harness";
+import { createHostWebRequestCoordinator } from "./web-request-coordinator.js";
+import { createAgentHarness, createSessionRuntimeResolver, createAgentResponder, acquireToolHistoryWriter, createDurableHistoryStore, createToolPolicy, loadToolPolicyFromJsonFileSync, renderSkillIndexSection, ToolHistoryReader, toolHistoryLogicalConversationId, } from "@mono-agent/agent-harness";
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve as resolvePath } from "node:path";
@@ -8,8 +9,10 @@ import { createCompositeRunRecorder, createJsonlRunRecorder } from "@mono-agent/
 import { createPhoenixRunExporter } from "@mono-agent/observability/otel";
 import { createMonoRuntime, createPiOAuthApiKeyResolver, createSrtSandboxEngine, describeMonoRuntimeSupport, modelReferenceKey, monoRuntimeSupportsSessionResume, parseMonoRuntimeModelReference, runtimeOptionsForLocalProvider, mergeSandboxPolicies, } from "@mono-agent/runtime-adapter";
 import { agentArtifactDerivedRoots } from "./agent-artifact-paths.js";
+import { createToolOutputArtifactsRuntimeExtension } from "./tool-output-artifacts.js";
 import { acquireAgentRootOwnership, assertAgentRootLeaseOutsideWorkspace, releaseAgentRootOwnershipWhenIdle, } from "./agent-root-coordinator.js";
 import { resolveMemoryRecallSettings } from "./memory-recall.js";
+import { createMemoryJournalRuntimeExtension, isMemoryJournalCapableStore, isMemoryJournalToolAllowed, } from "./memory-journal.js";
 import { BUILTIN_TOOL_NAMES, canonicalToolName, isAllowAllTools } from "./modules/known-tools.js";
 import { createSharedMemoryRecallRuntimeExtension, isSharedRecallStore, MemoryRetrievalService, } from "./memory-retrieval.js";
 import { createMemoryRememberRuntimeExtension, isRememberCapableStore, isRememberToolAllowed, } from "./memory-remember.js";
@@ -19,6 +22,7 @@ import { resolveProcessJobsProtectionPosture, } from "./process-jobs-protection.
 import { createMonitorsRuntimeExtension, monitorsAvailableForRequest } from "./monitors-runtime.js";
 import { createProcessJobsRuntimeExtension, processJobsAvailableForRequest, processJobsSandboxPolicy, PROCESS_JOBS_PI_NATIVE_REQUIRED_ERROR, PROCESS_JOBS_PROTECTION_UNAVAILABLE_ERROR, } from "./process-jobs-runtime.js";
 import { attestProcessJobsRootRegistrySnapshot, loadProcessJobsRootRegistryProtection, processJobsProtectionPolicyRoots, registerProcessJobsRoot, } from "./process-jobs-root-registry.js";
+import { activeProjectSkillSelections, isRetiredProjectSkillName } from "./project-skills.js";
 import { isReadSkillDenied } from "./skill-registry.js";
 import { loadSupermemoryPlugin } from "./supermemory-plugin.js";
 /**
@@ -83,12 +87,17 @@ function withArtifactCommitHook(recorder, onCommitted, args) {
         return recorder;
     }
     let terminalPromise;
-    const notify = (phase) => {
+    const notify = (phase, summary) => {
         try {
             // The cache invalidation used by the app is synchronous. Promise.resolve
             // also contains an async implementation without delaying
             // the JSONL/export pipeline or leaking an unhandled rejection.
-            void Promise.resolve(onCommitted({ phase, runId: args.runId, conversationId: args.conversationId }))
+            void Promise.resolve(onCommitted({
+                phase,
+                runId: args.runId,
+                conversationId: args.conversationId,
+                ...(summary === undefined ? {} : { summary }),
+            }))
                 .catch(() => undefined);
         }
         catch {
@@ -97,7 +106,7 @@ function withArtifactCommitHook(recorder, onCommitted, args) {
     };
     const commitTerminal = (operation) => {
         terminalPromise ??= operation().then((summary) => {
-            notify("finished");
+            notify("finished", summary);
             return summary;
         });
         return terminalPromise;
@@ -118,8 +127,10 @@ function withArtifactCommitHook(recorder, onCommitted, args) {
             await wrapped.prepareFinish?.(result);
             return await wrapped.commitFinish(result);
         },
-        async fail(error) {
-            return await commitTerminal(async () => await recorder.fail(error));
+        async fail(error, context) {
+            return await commitTerminal(async () => context === undefined
+                ? await recorder.fail(error)
+                : await recorder.fail(error, context));
         },
     };
     if (recorder.start !== undefined) {
@@ -456,6 +467,7 @@ function subagentsRuntimeOptions(config, deps) {
             // milliseconds. The parent keeps working, so the degradation is invisible
             // until you read the child's activity log.
             ...(config.tools.web?.search === undefined ? {} : { webSearchConfig: config.tools.web.search }),
+            ...(config.tools.web?.coordination === "host" ? { webRequestCoordinator: createHostWebRequestCoordinator() } : {}),
             ...(config.tools.web?.fetch === undefined ? {} : { webFetchConfig: config.tools.web.fetch }),
             // Both keys or neither: pi-bridge builds ReadSkill only when it has the
             // names AND the root, and a half-set pair fails by silently omitting the
@@ -508,9 +520,8 @@ function fallbackChainForConfig(config, options) {
         // and the router never runs — so same-model retries would silently do
         // nothing for every agent with no configured backups. Build a retry-only
         // single-entry chain instead whenever the primary asks for more than one
-        // attempt. `hasConfiguredFallback` deliberately stays false for this shape,
-        // keeping `sessionOptions.supportsResume` true: the router only drops the
-        // provider session on the retry itself (retryIndex > 0).
+        // attempt. Both retry-only and multi-entry chains keep sessions on the
+        // primary's first attempt; the router makes later attempts stateless.
         if (primaryAttempts <= 1) {
             return {};
         }
@@ -621,6 +632,11 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
         }, {
             suppressSandboxEngine: processJobsProtectionPosture.suppressSyntheticSandbox,
         });
+        const runtimeForSession = createSessionRuntimeResolver({ runtime, model,
+            ...(options.runtimeForModel === undefined ? {} : { runtimeForModel: options.runtimeForModel }),
+        });
+        const runtimeForModel = options.runtimeForModel === undefined ? undefined
+            : (target) => runtimeForSession(modelReferenceKey(target));
         const clearSessionsBoundaryOptions = {
             cwd: agentRoot,
             workspace: config.runtime.workspace,
@@ -651,7 +667,8 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
         // fallback-free runtime when no `memoryRuntime` is injected.
         const configuredMemory = options.memory ?? (await createConfiguredMemoryInternal(config, { cwd: agentRoot }, processJobsProtectionPosture));
         const memory = configuredMemoryForHarness(config, configuredMemory);
-        const memoryRecall = resolveMemoryRecallSettings(config) === undefined
+        const memoryReadToolsEnabled = resolveMemoryRecallSettings(config) !== undefined;
+        const memoryRecall = !memoryReadToolsEnabled
             || !(memory instanceof MemoryRetrievalService)
             ? undefined
             : createSharedMemoryRecallRuntimeExtension(memory, {
@@ -659,6 +676,20 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
                     ? {}
                     : { onUnavailable: options.onMemoryRecallUnavailable }),
             });
+        // Chronological enumeration shares the explicit memory-read switch with
+        // MemoryRecall, but additionally follows normal app-tool policy and requires
+        // an affirmative local capability. External search backends stay incapable.
+        const memoryJournal = !memoryReadToolsEnabled
+            || !(memory instanceof MemoryRetrievalService)
+            || !isMemoryJournalCapableStore(memory)
+            || !isMemoryJournalToolAllowed(config.tools)
+            ? undefined
+            : createMemoryJournalRuntimeExtension(memory, {
+                ...(options.env === undefined ? {} : { env: options.env }),
+                ...(options.onMemoryJournalUnavailable === undefined
+                    ? {}
+                    : { onUnavailable: options.onMemoryJournalUnavailable }),
+            });
         // The durable write surface is gated three ways: the store must affirm the
         // capability (a read-only or external backend never does), the operator must
         // not have disabled it, and tool policy must allow it. Unlike MemoryRecall it
@@ -676,6 +707,7 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
             });
         const composedRuntimeOptionsForRequest = composeRuntimeOptionExtensions([
             memoryRecall,
+            memoryJournal,
             memoryRemember,
             options.runtimeOptionsForRequest,
         ], {
@@ -699,7 +731,7 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
             routesOnlyPiNative: internalHooks.processJobs?.routesOnlyPiNative
                 ?? (() => configuredRoutesOnlyPiNative(config, model).ok),
         });
-        const runtimeOptionsForRequest = createMonitorsRuntimeExtension({
+        const monitoredRuntimeOptionsForRequest = createMonitorsRuntimeExtension({
             next: processJobsRuntimeOptionsForRequest,
             service: internalHooks.monitors?.service,
             coreConfig: config,
@@ -710,25 +742,28 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
                 ?? internalHooks.processJobs?.routesOnlyPiNative
                 ?? (() => configuredRoutesOnlyPiNative(config, model).ok),
         });
+        const toolOutputArtifactRoot = resolvePath(config.artifacts.dir, "tool-output");
+        const runtimeOptionsForRequest = createToolOutputArtifactsRuntimeExtension(monitoredRuntimeOptionsForRequest, toolOutputArtifactRoot);
         const subagents = subagentsRuntimeOptions(config, {
             runtime,
             baseModel: model,
-            ...(options.runtimeForModel === undefined ? {} : { runtimeForModel: options.runtimeForModel }),
+            ...(runtimeForModel === undefined ? {} : { runtimeForModel }),
         });
         const runtimeOptions = mergeStaticRuntimeOptions(runtimeOptionsForLocalProvider(model, config.providers?.local), configRuntimeFlags(config), sandboxEngine === undefined ? undefined : { sandboxEngine }, subagents, options.runtimeOptions);
         const sessionOptions = {
             mode: config.runtime.session.mode,
             idleTimeoutMs: config.runtime.session.idleTimeoutMs,
-            // Any fallback makes the logical run stateless. A provider-owned session
-            // cannot safely cross the route boundary, even when both bridges happen to
-            // expose resume support. History replay remains available to every attempt.
-            supportsResume: hasConfiguredFallback(config)
-                ? false
-                : supportsSessionResume(),
+            // Continuous sessions belong to the primary's first attempt. The router
+            // strips session state from retries and backups and withholds their resumable
+            // result id; an unsynchronized durable answer rotates the epoch before the next turn.
+            supportsResume: supportsSessionResume(),
             ...(config.runtime.session.isolateProactive === undefined
                 ? {}
                 : { isolateProactive: config.runtime.session.isolateProactive }),
             ...(options.onSessionEvent === undefined ? {} : { onSessionEvent: options.onSessionEvent }),
+            ...(options.terminalRecoverySettlementMs === undefined
+                ? {}
+                : { terminalRecoverySettlementMs: options.terminalRecoverySettlementMs }),
         };
         const piSessionsRoot = config.providers?.piNative?.piSessionsRoot;
         const retireDurableSession = runtime.retireDurableSession?.bind(runtime);
@@ -739,8 +774,18 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
             ...(piSessionsRoot === undefined || retireDurableSession === undefined
                 ? {}
                 : {
-                    retireProviderSession: async (providerSessionId) => {
-                        await retireDurableSession(providerSessionId, piSessionsRoot);
+                    retireProviderSession: async (providerSessionId, modelKey) => {
+                        const owner = runtimeForSession(modelKey);
+                        if (owner.retireDurableSession === undefined) {
+                            throw new Error("Session owner cannot retire durable provider state.");
+                        }
+                        // Durable retirement detaches an open Pi handle before unlinking;
+                        // ordinary invalidation alone rejects while a cancelled turn unwinds.
+                        await owner.retireDurableSession(providerSessionId, piSessionsRoot);
+                        if (owner.invalidateSession !== undefined)
+                            await owner.invalidateSession(providerSessionId);
+                        else
+                            await owner.disposeSession?.(providerSessionId);
                     },
                 }),
         });
@@ -753,7 +798,7 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
         // create either the sidecar or its owner database.
         const toolHistory = lazyConfiguredToolHistory({
             root: historyRoot,
-            artifactRoot: resolvePath(config.artifacts.dir, "tool-output"),
+            artifactRoot: toolOutputArtifactRoot,
             rollover,
             ...(options.onToolHistoryWarning === undefined
                 ? {}
@@ -765,8 +810,19 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
                 ...(config.context.soulPath === undefined ? {} : { soulPath: config.context.soulPath }),
                 ...(config.context.skillsRoot === undefined ? {} : { skillsRoot: config.context.skillsRoot }),
                 ...(config.context.skillMaxBytes === undefined ? {} : { skillMaxBytes: config.context.skillMaxBytes }),
-                ...(config.context.skillDisclosure === undefined ? {} : { skillDisclosure: config.context.skillDisclosure }),
-                selectedSkills: config.context.selectedSkills,
+                ...(config.context.skillDisclosure === undefined
+                    ? {}
+                    : {
+                        // Index disclosure inventories every installed skill, not only selected
+                        // ones. Until the explicit updater retires the legacy file, fall back
+                        // to selected-body loading so that stale configure instructions cannot
+                        // re-enter through ReadSkill.
+                        skillDisclosure: config.context.skillDisclosure === "index"
+                            && config.context.selectedSkills.some(isRetiredProjectSkillName)
+                            ? "full"
+                            : config.context.skillDisclosure,
+                    }),
+                selectedSkills: activeProjectSkillSelections(config.context.selectedSkills),
                 runtime,
                 model,
                 cwd: config.runtime.workspace,
@@ -832,7 +888,7 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
                             capabilityIssuer: options.continuationCapabilityIssuer,
                         },
                     }),
-                ...(options.runtimeForModel === undefined ? {} : { runtimeForModel: options.runtimeForModel }),
+                ...(runtimeForModel === undefined ? {} : { runtimeForModel }),
                 ...(memory === undefined ? {} : { memory }),
                 memoryWriteMode: config.memory?.writeMode ?? "disabled",
                 ...(options.onMemoryWarning === undefined ? {} : { onMemoryWarning: options.onMemoryWarning }),
@@ -873,6 +929,7 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
 function harnessWithAgentRootOwnership(harness, ownership) {
     let disposePromise;
     return {
+        ...(harness.liveInputOwnership === undefined ? {} : { liveInputOwnership: harness.liveInputOwnership }),
         run: harness.run.bind(harness),
         ...(harness.submit === undefined ? {} : { submit: harness.submit.bind(harness) }),
         ...(harness.offerLiveInput === undefined
@@ -885,6 +942,9 @@ function harnessWithAgentRootOwnership(harness, ownership) {
         ...(harness.appendVerbatimTurn === undefined
             ? {}
             : { appendVerbatimTurn: harness.appendVerbatimTurn.bind(harness) }),
+        ...(harness.importContext === undefined
+            ? {}
+            : { importContext: harness.importContext.bind(harness) }),
         dispose: () => {
             disposePromise ??= Promise.resolve()
                 .then(async () => await harness.dispose?.())
@@ -1079,7 +1139,7 @@ export function lazyConfiguredToolHistory(options) {
                 }
             };
         },
-        async finishRun(binding, status, failureKind) {
+        async finishRun(binding, status, failureKind, cancellationReasonCode) {
             const key = turnKey(binding.conversationId, binding.runId);
             const state = turnStates.get(key);
             try {
@@ -1087,7 +1147,7 @@ export function lazyConfiguredToolHistory(options) {
                     return;
                 const handle = await state.attempt.promise.catch(() => undefined);
                 try {
-                    await handle?.writer.finishRun(binding, status, failureKind);
+                    await handle?.writer.finishRun(binding, status, failureKind, cancellationReasonCode);
                 }
                 catch (error) {
                     if (handle === undefined)
@@ -1223,9 +1283,6 @@ async function createConfiguredAgentResponderInternal(options, internalHooks = {
 }
 /** @internal Shared only with app-local history decorators; absent from the package root. */
 export const DEFAULT_HISTORY_MAX_MESSAGES = 64;
-function hasConfiguredFallback(config) {
-    return (config.runtime.fallbacks?.length ?? 0) > 0;
-}
 function supportsSessionResume() {
     try {
         return monoRuntimeSupportsSessionResume();
@@ -1354,6 +1411,12 @@ async function createConfiguredMemoryInternal(config, deps, protectionPosture) {
 function runtimeHostOptionsForConfig(config) {
     return {
         workspace: config.runtime.workspace,
+        ...(config.tools.filesystem === undefined
+            ? {}
+            : {
+                additionalReadRoots: config.tools.filesystem.readableRoots,
+                additionalWriteRoots: config.tools.filesystem.writableRoots,
+            }),
         qaOutputDir: config.artifacts.dir,
         ...(config.providers?.piAuthPath === undefined
             ? {}
@@ -1736,6 +1799,7 @@ function configRuntimeFlags(config) {
         };
     if (permissionMode === undefined
         && piNative?.transport === undefined
+        && piNative?.promptCacheDiagnostics === undefined
         && piNative?.piMaxRetries === undefined
         && piNative?.maxRetryDelayMs === undefined
         && compaction === undefined
@@ -1747,12 +1811,14 @@ function configRuntimeFlags(config) {
     return {
         ...(permissionMode === undefined ? {} : { permissionMode }),
         ...(piNative?.transport === undefined ? {} : { piTransport: piNative.transport }),
+        ...(piNative?.promptCacheDiagnostics === undefined ? {} : { promptCacheDiagnostics: piNative.promptCacheDiagnostics }),
         ...(piNative?.piMaxRetries === undefined ? {} : { piMaxRetries: piNative.piMaxRetries }),
         ...(piNative?.maxRetryDelayMs === undefined ? {} : { maxRetryDelayMs: piNative.maxRetryDelayMs }),
         ...(compaction === undefined ? {} : { compaction }),
         ...(settings === undefined ? {} : { settings }),
         ...(webSearchConfig === undefined ? {} : { webSearchConfig }),
         ...(webFetchConfig === undefined ? {} : { webFetchConfig }),
+        ...(config.tools.web?.coordination === "host" ? { webRequestCoordinator: createHostWebRequestCoordinator() } : {}),
     };
 }
 function isRuntimeOptions(value) {