@mono-agent/agent-app 0.20.11 → 0.21.0

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";
@@ -6,17 +7,22 @@ import { setToolActivityPathRoots } from "@mono-agent/agent-contracts";
 import { resolveSupermemoryContainer } from "@mono-agent/config";
 import { createCompositeRunRecorder, createJsonlRunRecorder } from "@mono-agent/observability";
 import { createPhoenixRunExporter } from "@mono-agent/observability/otel";
-import { assertExecutionModeCompatible, createMonoRuntime, createPiOAuthApiKeyResolver, createSrtSandboxEngine, defaultExecutionModeForModel, describeMonoRuntimeSupport, modelReferenceKey, monoRuntimeSupportsSessionResume, parseMonoRuntimeModelReference, runtimeOptionsForLocalProvider, mergeSandboxPolicies, } from "@mono-agent/runtime-adapter";
+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";
 import { clearSessionsSandboxPolicy, composeRuntimeOptionExtensions, createClearSessionsRuntimeExtension, } from "./runtime-option-extensions.js";
 import { configuredRuntimeFallbackModels, runtimeUsesFallbackRouter, } from "./runtime-routes.js";
 import { resolveProcessJobsProtectionPosture, } from "./process-jobs-protection.js";
+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";
 /**
@@ -81,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 {
@@ -95,7 +106,7 @@ function withArtifactCommitHook(recorder, onCommitted, args) {
     };
     const commitTerminal = (operation) => {
         terminalPromise ??= operation().then((summary) => {
-            notify("finished");
+            notify("finished", summary);
             return summary;
         });
         return terminalPromise;
@@ -116,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) {
@@ -166,7 +179,7 @@ function createConfiguredAgentRuntimeBase(config, options, suppressSandboxEngine
     const fallback = fallbackChainForConfig(config, options);
     const sandboxEngine = suppressSandboxEngine
         ? undefined
-        : configuredSandboxEngine(config, options?.model ?? config.runtime.model, options?.sandboxEngine);
+        : configuredSandboxEngine(options?.sandboxEngine);
     const runtimeOptions = {
         ...runtimeHostOptionsForConfig(config),
         ...(sandboxEngine === undefined ? {} : { sandboxEngine }),
@@ -174,7 +187,6 @@ function createConfiguredAgentRuntimeBase(config, options, suppressSandboxEngine
         ...(fallback.fallbackChain === undefined
             ? {}
             : {
-                routeSafety: config.runtime.routeSafety ?? "uniform",
                 ...(config.runtime.retry === undefined
                     ? {}
                     : {
@@ -193,13 +205,8 @@ function createConfiguredAgentRuntimeBase(config, options, suppressSandboxEngine
     };
     return createMonoRuntime(runtimeOptions);
 }
-function configuredSandboxEngine(config, primaryModel, explicit) {
-    if (explicit !== undefined)
-        return explicit;
-    return [primaryModel, ...configuredRuntimeFallbackModels(config.runtime)]
-        .some((model) => model.sdk === "pi")
-        ? createSrtSandboxEngine()
-        : undefined;
+function configuredSandboxEngine(explicit) {
+    return explicit ?? createSrtSandboxEngine();
 }
 function wrapOwnedConfiguredRuntime(runtime, config, agentRoot, configuredSandboxEngine) {
     let security;
@@ -246,9 +253,6 @@ function wrapOwnedConfiguredRuntime(runtime, config, agentRoot, configuredSandbo
                     if (!verdict.ok) {
                         throw new Error(`${PROCESS_JOBS_PI_NATIVE_REQUIRED_ERROR} Rejected the configured runtime chain: ${verdict.reason}.`);
                     }
-                    if (runOptions.model.sdk !== "pi") {
-                        throw new Error(`${PROCESS_JOBS_PI_NATIVE_REQUIRED_ERROR} The configured runtime route ${modelReferenceKey(runOptions.model)} is not Pi-native.`);
-                    }
                     const sandboxEngine = runOptions.sandboxEngine
                         ?? configuredSandboxEngine
                         ?? createSrtSandboxEngine();
@@ -362,9 +366,9 @@ function inlineSubagentCeiling(config) {
  * Fails closed: an unparseable or incompatible route means no skills, never a
  * throw from what is otherwise a plain forwarding decision.
  */
-function childRuntimeSupportsSkills(model, executionMode) {
+function childRuntimeSupportsSkills(model) {
     try {
-        const support = describeMonoRuntimeSupport(model, executionMode);
+        const support = describeMonoRuntimeSupport(model);
         return support.backend?.capabilities.supports_skills !== false;
     }
     catch {
@@ -422,11 +426,8 @@ function subagentsRuntimeOptions(config, deps) {
         const childModel = overrides
             ? request.definition.model
             : deps.baseModel;
-        const childExecutionMode = overrides
-            ? defaultExecutionModeForModel(childModel)
-            : deps.baseExecutionMode;
         const runtime = overrides && deps.runtimeForModel !== undefined
-            ? deps.runtimeForModel(childModel, childExecutionMode)
+            ? deps.runtimeForModel(childModel)
             : deps.runtime;
         // Whether this child may inherit the parent's skill index. Decided here
         // because this is the only layer holding all four inputs: the offered
@@ -438,7 +439,7 @@ function subagentsRuntimeOptions(config, deps) {
             && (request.skills?.length ?? 0) > 0
             && !skillsDeniedGlobally
             && !profileDeniesSkills
-            && childRuntimeSupportsSkills(childModel, childExecutionMode)
+            && childRuntimeSupportsSkills(childModel)
             ? request.skills
             : undefined;
         // Appended, not prepended: the parent's own context orders these as
@@ -448,14 +449,8 @@ function subagentsRuntimeOptions(config, deps) {
         const childSystemPrompt = childSkills === undefined
             ? request.systemPrompt
             : `${request.systemPrompt}\n\n${renderSkillIndexSection(childSkills)}`;
-        if (childModel.sdk !== "pi"
-            && (deps.processJobsProtectionPosture.requiresPiNative
-                || sandboxPolicyCarriesProtectedRoots(request.sandboxPolicy))) {
-            throw new Error(`${PROCESS_JOBS_PI_NATIVE_REQUIRED_ERROR} The Agent child route ${modelReferenceKey(childModel)} is not Pi-native.`);
-        }
         return await runtime.run(childSystemPrompt, {
             model: childModel,
-            executionMode: childExecutionMode,
             messages: [{ role: "user", content: request.prompt }],
             maxTurns: request.maxTurns,
             ...(request.cwd === undefined ? {} : { cwd: request.cwd }),
@@ -472,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
@@ -511,61 +507,49 @@ function subagentsRuntimeOptions(config, deps) {
 }
 /**
  * When backup models are configured, runs go through the agent-runtime fallback
- * router with the effective primary model first. Fallback entries use their
- * default execution mode.
+ * router with the effective primary model first.
  */
 function fallbackChainForConfig(config, options) {
     const canonicalFallbacks = config.runtime.fallbacks;
-    const legacyFallbackModels = config.runtime.fallbackModels;
     // The loader always materializes `retry`, but this package is published and
     // `createConfiguredAgentRuntime` accepts a caller-built MonoAgentConfig — an
     // older hand-built object must degrade to single-shot, not crash.
     const primaryAttempts = config.runtime.retry?.primaryAttempts ?? 1;
-    if ((canonicalFallbacks?.length ?? 0) === 0 && (legacyFallbackModels?.length ?? 0) === 0) {
+    if ((canonicalFallbacks?.length ?? 0) === 0) {
         // Without a chain `createMonoRuntime` takes the plain `createRuntime` path
         // 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 {};
         }
         return {
             fallbackChain: [{
                     model: options?.model ?? config.runtime.model,
-                    executionMode: (options?.executionMode ?? config.runtime.executionMode),
                     attempts: primaryAttempts,
                 }],
         };
     }
     const primaryModel = options?.model ?? config.runtime.model;
-    const primaryExecutionMode = options?.executionMode ?? config.runtime.executionMode;
     // Drop any fallback equal to the primary so a per-trigger override that happens
     // to match a configured backup is not retried against itself before advancing.
     const primaryKey = modelReferenceKey(primaryModel);
-    const canonicalFallbackEntries = canonicalFallbacks ?? [];
-    const fallbackEntries = canonicalFallbackEntries.length > 0
-        ? canonicalFallbackEntries
-            .filter((entry) => modelReferenceKey(entry.model) !== primaryKey)
-            .map((entry) => ({
-            model: entry.model,
-            // Canonical omission means provider default. Legacy fallbackModels
-            // omit this field and therefore continue inheriting runtime.effort.
-            effort: entry.effort ?? null,
-            // Omitted per-route attempts stay single-shot: only the primary
-            // retries unless a backup opts in explicitly.
-            ...(entry.attempts === undefined ? {} : { attempts: entry.attempts }),
-        }))
-        : (legacyFallbackModels ?? [])
-            .filter((model) => modelReferenceKey(model) !== primaryKey)
-            .map((model) => ({ model }));
+    const fallbackEntries = (canonicalFallbacks ?? [])
+        .filter((entry) => modelReferenceKey(entry.model) !== primaryKey)
+        .map((entry) => ({
+        model: entry.model,
+        // Canonical omission means provider default.
+        effort: entry.effort ?? null,
+        // Omitted per-route attempts stay single-shot: only the primary
+        // retries unless a backup opts in explicitly.
+        ...(entry.attempts === undefined ? {} : { attempts: entry.attempts }),
+    }));
     return {
         fallbackChain: [
             {
                 model: primaryModel,
-                executionMode: primaryExecutionMode,
                 ...(primaryAttempts > 1 ? { attempts: primaryAttempts } : {}),
             },
             ...fallbackEntries,
@@ -587,21 +571,7 @@ function configuredRoutesOnlyPiNative(config, primary) {
     if (routes.length === 0) {
         return { ok: false, reason: "the configured route chain is empty" };
     }
-    const nonPi = routes.filter((model) => model.sdk !== "pi");
-    return nonPi.length === 0
-        ? { ok: true }
-        : { ok: false, reason: `non-Pi routes are reachable: ${nonPi.map(modelReferenceKey).join(", ")}` };
-}
-function sandboxPolicyCarriesProtectedRoots(policy) {
-    if (policy === undefined || policy === null || typeof policy !== "object")
-        return false;
-    try {
-        const roots = policy.protectedRoots;
-        return roots !== undefined && (!Array.isArray(roots) || roots.length > 0);
-    }
-    catch {
-        return true;
-    }
+    return { ok: true };
 }
 let memoryBujoModule;
 let memorySearchModule;
@@ -645,11 +615,10 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
         // supervisor started it in — and tool previews expose the full machine layout.
         setToolActivityPathRoots({ workspaceRoot: config.runtime.workspace, homeDir: homedir() });
         const model = options.model ?? config.runtime.model;
-        const executionMode = options.executionMode ?? config.runtime.executionMode;
         const fallbackModels = configuredRuntimeFallbackModels(config.runtime);
         const sandboxEngine = processJobsProtectionPosture.suppressSyntheticSandbox
             ? undefined
-            : configuredSandboxEngine(config, model, options.sandboxEngine);
+            : configuredSandboxEngine(options.sandboxEngine);
         const harnessSandboxPolicy = processJobsProtectionPosture.suppressSyntheticSandbox
             ? config.sandbox
             : processJobsProtectedRoots.length === 0
@@ -659,11 +628,15 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
             config,
             cwd: agentRoot,
             model,
-            executionMode,
             ...(sandboxEngine === undefined ? {} : { sandboxEngine }),
         }, {
             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,
@@ -694,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, {
@@ -702,8 +676,39 @@ 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
+        // is allowlist-gated, so an operator can withhold writes while keeping recall.
+        const memoryRemember = config.memory?.rememberTool?.enabled === false
+            || !(memory instanceof MemoryRetrievalService)
+            || !isRememberCapableStore(memory)
+            || !isRememberToolAllowed(config.tools)
+            ? undefined
+            : createMemoryRememberRuntimeExtension(memory, {
+                ...(options.env === undefined ? {} : { env: options.env }),
+                ...(options.onMemoryRememberUnavailable === undefined
+                    ? {}
+                    : { onUnavailable: options.onMemoryRememberUnavailable }),
+            });
         const composedRuntimeOptionsForRequest = composeRuntimeOptionExtensions([
             memoryRecall,
+            memoryJournal,
+            memoryRemember,
             options.runtimeOptionsForRequest,
         ], {
             // The app-owned, read-only MemoryRecall endpoint is part of every configured
@@ -712,7 +717,7 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
             preserveMcpServersUnderOverride: memoryRecall === undefined ? [] : [memoryRecall],
         });
         const clearSessionsRuntimeOptionsForRequest = createClearSessionsRuntimeExtension(composedRuntimeOptionsForRequest, clearSessionsBoundaryOptions);
-        const runtimeOptionsForRequest = createProcessJobsRuntimeExtension({
+        const processJobsRuntimeOptionsForRequest = createProcessJobsRuntimeExtension({
             next: clearSessionsRuntimeOptionsForRequest,
             ownership,
             registry: processJobsRegistry,
@@ -726,27 +731,39 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
             routesOnlyPiNative: internalHooks.processJobs?.routesOnlyPiNative
                 ?? (() => configuredRoutesOnlyPiNative(config, model).ok),
         });
+        const monitoredRuntimeOptionsForRequest = createMonitorsRuntimeExtension({
+            next: processJobsRuntimeOptionsForRequest,
+            service: internalHooks.monitors?.service,
+            coreConfig: config,
+            channelId: internalHooks.monitors?.channelId ?? internalHooks.processJobs?.channelId,
+            conversationScheme: internalHooks.monitors?.conversationScheme
+                ?? internalHooks.processJobs?.conversationScheme,
+            routesOnlyPiNative: internalHooks.monitors?.routesOnlyPiNative
+                ?? 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,
-            baseExecutionMode: executionMode,
-            processJobsProtectionPosture,
-            ...(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(model, executionMode),
+            // 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);
@@ -757,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);
                     },
                 }),
         });
@@ -771,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
                 ? {}
@@ -783,11 +810,21 @@ 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,
-                executionMode,
                 cwd: config.runtime.workspace,
                 ...(config.runtime.effort === undefined ? {} : { effort: config.runtime.effort }),
                 ...(config.runtime.maxTurns === undefined ? {} : { maxTurns: config.runtime.maxTurns }),
@@ -821,6 +858,17 @@ async function createConfiguredAgentHarnessInternal(options, internalHooks = {})
                     routesOnlyPiNative: internalHooks.processJobs?.routesOnlyPiNative
                         ?? (() => configuredRoutesOnlyPiNative(config, model).ok),
                 }),
+                // Same predicate the monitors extension uses, for the same reason.
+                monitorsAvailable: (input) => monitorsAvailableForRequest(input, {
+                    service: internalHooks.monitors?.service,
+                    coreConfig: config,
+                    channelId: internalHooks.monitors?.channelId ?? internalHooks.processJobs?.channelId,
+                    conversationScheme: internalHooks.monitors?.conversationScheme
+                        ?? internalHooks.processJobs?.conversationScheme,
+                    routesOnlyPiNative: internalHooks.monitors?.routesOnlyPiNative
+                        ?? internalHooks.processJobs?.routesOnlyPiNative
+                        ?? (() => configuredRoutesOnlyPiNative(config, model).ok),
+                }),
                 ...(config.tools.mcpRequestContextServers === undefined
                     ? {}
                     : {
@@ -840,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 }),
@@ -881,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
@@ -893,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?.())
@@ -1087,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 {
@@ -1095,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)
@@ -1231,13 +1283,9 @@ 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
-        || (config.runtime.fallbackModels?.length ?? 0) > 0;
-}
-function supportsSessionResume(model, executionMode) {
+function supportsSessionResume() {
     try {
-        return monoRuntimeSupportsSessionResume(model, executionMode);
+        return monoRuntimeSupportsSessionResume();
     }
     catch {
         return false;
@@ -1363,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
             ? {}
@@ -1385,11 +1439,6 @@ memoryRuntimeOverride, recording, agentRoot, protectionPosture) {
         }), config, agentRoot);
     }
     const model = parseMonoRuntimeModelReference(llmConfig.model);
-    const executionMode = llmConfig.executionMode ?? defaultExecutionModeForModel(model);
-    assertExecutionModeCompatible(model, executionMode);
-    if (executionMode !== "sdk") {
-        throw new Error("memory.llm provider agent-host supports SDK execution mode only.");
-    }
     // NOTE: createMonoRuntime is called WITHOUT a fallbackChain here on purpose, so
     // the per-call `model: config.memory.llm.model` is the sole/primary model. The
     // channel runtime (which carries the fallback chain whose primary is
@@ -1399,7 +1448,6 @@ memoryRuntimeOverride, recording, agentRoot, protectionPosture) {
     return createAgentHostMemoryLlm({
         runtime,
         model,
-        executionMode,
         cwd: config.runtime.workspace,
         runtimeOptions: mergeStaticRuntimeOptions(runtimeOptionsForLocalProvider(model, config.providers?.local), configRuntimeFlags(config)),
         // Per-call timeout; default 60s. Configurable so a slow local model can be
@@ -1434,9 +1482,6 @@ function wrapPerRunOwnedConfiguredRuntime(runtime, config, agentRoot, protection
                 const protectedRoots = processJobsProtectionPolicyRoots(attested);
                 let effectiveOptions = runOptions;
                 if (protectedRoots.length > 0) {
-                    if (runOptions.model.sdk !== "pi") {
-                        throw new Error(`${PROCESS_JOBS_PI_NATIVE_REQUIRED_ERROR} The agent-host memory LLM route ${modelReferenceKey(runOptions.model)} is not Pi-native.`);
-                    }
                     if (protectionPosture?.suppressSyntheticSandbox !== true) {
                         const sandboxEngine = runOptions.sandboxEngine ?? createSrtSandboxEngine();
                         if (!await sandboxEngine.isAvailable().catch(() => false)) {
@@ -1583,7 +1628,6 @@ function createAgentHostMemoryLlm(options) {
                         model: options.model,
                         messages: [{ role: "user", content: prompt }],
                         abortSignal: ctrl.signal,
-                        executionMode: options.executionMode,
                         cwd: options.cwd,
                         maxTurns: 1,
                         allowedTools: [],
@@ -1755,6 +1799,7 @@ function configRuntimeFlags(config) {
         };
     if (permissionMode === undefined
         && piNative?.transport === undefined
+        && piNative?.promptCacheDiagnostics === undefined
         && piNative?.piMaxRetries === undefined
         && piNative?.maxRetryDelayMs === undefined
         && compaction === undefined
@@ -1766,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) {