maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/node_modules/@maka/runtime-host/dist/server/execution-composition.js

@@ -16,8 +16,10 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { readMatterRuntimeEvents } from '../assistant/proactive-matters/settlement-context.js';
 import { markAssistantBackgroundSessions } from '../assistant/background-sessions.js';
 import { PersonalAssistantService, ASSISTANT_LEGACY_PACKAGES } from '../assistant/service.js';
+import { assistantInputTurnId, legacyAssistantInputTurnId } from '../assistant/bot/turn-ids.js';
 import { createAssistantMessageReader } from './session-transcript-reader.js';
 import { createImageFileReader } from '@maka/runtime/image-file-reader';
 import { ChatImageDeliveryService } from './chat-image-delivery.js';
@@ -60,6 +62,9 @@ import { RuntimeReadModel } from '@maka/runtime/runtime-read-model';
 import { renderAgentSwarmSupervisorWake, shouldWakeAgentSwarmSupervisor, } from '@maka/runtime/agent-swarm-status-tool';
 import { SessionActivityRegistry } from '@maka/runtime/goal-turn-lifecycle';
 import { ShellRunProcessManager } from '@maka/runtime/shell-run-manager';
+import { ShellRunEventWaitAccess } from './shell-run-event-wait-access.js';
+import { ShellRunEventWaitAdapter } from './shell-run-event-wait-adapter.js';
+import { EventWaitAdapterRegistry } from './event-wait-adapter.js';
 import { resolveShellPlan, resolveTurnShellPlan, validateShellPreference, } from '@maka/runtime/shell-detect';
 import { Context } from '@maka/runtime/plugin-kernel';
 import { PluginAgentService } from '@maka/runtime/plugin-agent-service';
@@ -109,12 +114,13 @@ import { HostConnectionEffectCoordinator } from './connection-effect-coordinator
 import { HostChangeFeed } from './host-change-feed.js';
 import { HostConfigurationCoordinator } from './configuration-coordinator.js';
 import { HostPromptSuggestionCoordinator, supportsPromptSuggestion } from './prompt-suggestion.js';
+import { checkinSessionState, HostSessionCheckinCoordinator, listCheckinCatalogSessions, } from './session-checkin.js';
 import { HostContextCoordinator } from './context-coordinator.js';
 import { HostClientCapabilityCoordinator } from './client-capability-coordinator.js';
 import { HostDailyReviewCoordinator } from './daily-review-coordinator.js';
 import { prepareHostAiSdkBackend } from './execution-model-composition.js';
 import { createInteractiveRunComposer, createInteractiveRunComposerFactory, routeInteractiveRunToolSurface, } from './interactive-run-composer.js';
-import { createHostGoalEvaluator, createHostDailyReviewModel, createHostMemoryExtractionModel, createHostPluginModel, createHostSessionEffectModel, createHostPromptSuggestionModel, } from './execution-model-authority.js';
+import { createHostGoalEvaluator, createHostDailyReviewModel, createHostMemoryExtractionModel, createHostPluginModel, createHostSessionEffectModel, createHostPromptSuggestionModel, createHostCheckinModel, resolveDefaultModelHeader, } from './execution-model-authority.js';
 import { HostExecutionInspectCoordinator } from './execution-inspect-coordinator.js';
 import { HostExternalSessionCoordinator } from './external-session-coordinator.js';
 import { boundedFailureDiagnostic } from './failure-diagnostic.js';
@@ -143,6 +149,7 @@ import { join } from 'node:path';
 import { toRuntimePolicyProxy } from './runtime-policy-proxy.js';
 import { AcpSetupError } from './acp/connection.js';
 import { installAntigravity } from './acp/antigravity-install.js';
+import { ANTIGRAVITY_ACP_EXECUTOR_ID } from '@maka/antigravity-acp-plugin';
 import { createProxiedFetchTransport } from '@maka/runtime/network/scoped-fetch-transport';
 import { HostExternalAgentSetupCoordinator } from './external-agent-setup-coordinator.js';
 import { HostOAuthCoordinator } from './oauth-coordinator.js';
@@ -163,6 +170,7 @@ import { startHostModelMetadataRefresh } from './model-metadata-refresh.js';
 import { HostRuntimeResourceCoordinator } from './runtime-resource-coordinator.js';
 import { SessionAdmissionGate } from './session-admission-gate.js';
 import { workHubResultOrigin } from './workhub-result-coordinator.js';
+import { HostPersonalAssistantWorkspace } from './personal-assistant-workspace.js';
 import { HostSessionCatalogCoordinator } from './session-catalog-coordinator.js';
 import { SessionBackgroundActivityProjection } from './session-background-activity.js';
 import { SessionInteractionActivityProjection } from './session-interaction-activity.js';
@@ -171,6 +179,7 @@ import { HostSessionRetirementCoordinator } from './session-retirement-coordinat
 import { HostStorageMaintenance } from './storage-maintenance.js';
 import { HostStorageUsageCoordinator } from './storage-usage-coordinator.js';
 import { HostArchiveRetentionCoordinator } from './archive-retention-coordinator.js';
+import { createHostSessionCheckpointPublication, } from './session-checkpoint-publication.js';
 import { HostSessionRevisionCoordinator } from './session-revision-coordinator.js';
 import { HostSessionEffectCoordinator } from './session-effect-coordinator.js';
 import { SessionContinuityCoordinator } from './session-continuity-coordinator.js';
@@ -226,6 +235,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
     let graphClient;
     let sessionEffects;
     let promptSuggestions;
+    let checkins;
     let memoryExtraction;
     let imageDelivery;
     let unsubscribeTranscriptChanges;
@@ -240,6 +250,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
     let invalidatePluginExecutorBackends = () => undefined;
     let modelMetadataRefresh;
     let archiveEvidence;
+    let sessionCheckpoints;
     try {
         const pluginRoot = new Context();
         const pluginAgents = new PluginAgentService(pluginRoot);
@@ -295,9 +306,20 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     ...(header.executorConfig ? { configuration: header.executorConfig } : {}),
                 });
             }
-            return pluginExecutors.catalog({ cwd: input.cwd, refresh: input.refresh });
+            return pluginExecutors.catalog({
+                cwd: input.cwd,
+                refresh: input.refresh,
+                executorId: input.executorId,
+                listOnly: input.listOnly,
+            });
         });
         const personalAssistant = (assistant = new PersonalAssistantService(join(context.owner.controlDirectory, 'personal-assistant'), {
+            prepareBotWake: async (ownerId, workerId) => {
+                if (await interactions.hasPendingSession(workerId))
+                    return 'deferred';
+                return sessionCatalog.synchronizeAssistantBotModel(ownerId, workerId);
+            },
+            allocateWorkspace: () => assistantWorkspace.allocate(),
             stopSessions: async () => {
                 if (!rootCoordinator)
                     return;
@@ -344,6 +366,9 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 });
             },
             markBackgroundSessions: (ids) => markAssistantBackgroundSessions(stores.sessionStore, ids),
+            readRuntimeEvents: async (sessionId, runId) => runId
+                ? readMatterRuntimeEvents(stores.runtimeEventStore, sessionId, runId)
+                : (await stores.runtimeEventStore.readSessionRuntimeEventEntries(sessionId)).map((entry) => entry.event),
             agents: pluginAgents,
             llm: pluginLlm,
             sessionQuery: pluginSessionQuery,
@@ -879,13 +904,15 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         continuity = new SessionContinuityCoordinator(context.hostEpoch, (sessionId) => canonicalProjectionReader.read(sessionId), sessionAdmission, context.requestDrain, transcriptReader, async (sessionId, attention) => {
             if (attention) {
                 try {
-                    if ((await runtimePolicyStores.runtimePolicy.getSnapshot()).policy.privacy.incognitoActive) {
+                    const header = await stores.sessionStore.readHeaderSnapshot(sessionId);
+                    if (header.labels?.includes(ASSISTANT_BACKGROUND_SESSION_LABEL) ||
+                        (await runtimePolicyStores.runtimePolicy.getSnapshot()).policy.privacy.incognitoActive) {
                         attention = undefined;
                     }
                 }
                 catch (error) {
                     attention = undefined;
-                    console.warn('[runtime-host] Could not read notification privacy policy', error);
+                    console.warn('[runtime-host] Could not read notification policy', error);
                 }
             }
             hostChanges.publishSessionCatalog(sessionId, attention);
@@ -927,6 +954,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         let domainModuleDrainBegun = false;
         const beginDrain = () => {
             draining = true;
+            sessionCheckpoints?.beginDrain();
             if (!domainModules || domainModuleDrainBegun)
                 return;
             domainModuleDrainBegun = true;
@@ -1022,19 +1050,24 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 ...(scheduledTaskTool ? { scheduledTaskTool } : {}),
                 planStore,
                 goalTools: requireGoal(goal).tools,
+                eventWaitAvailable: () => backendContext.header.toolMode !== 'code_mode' &&
+                    ['active', 'waiting'].includes(requireGoal(goal).manager.get(backendContext.sessionId)?.status ?? ''),
                 builtinTools,
                 hostTools,
                 resolveToolCeiling: (sessionId) => personalAssistant.toolCeiling(sessionId),
                 resolveRootTools: async (sessionId) => {
                     await assertAssistantSessionEnabled(sessionId);
                     return [
-                        ...personalAssistant.tools,
+                        ...personalAssistant.filterTools(sessionId, personalAssistant.tools),
                         ...(sessionId === WORKHUB_COORDINATION_SESSION_ID && workHubResults && workHubInspection
                             ? [workHubResults.tool, workHubInspection]
                             : await requireGraphCoordinator(graphCoordinator).toolsForSession(sessionId)),
                     ];
                 },
-                resolvePluginTools: (sessionId, coreTools) => pluginTools.resolveContributions(sessionId, coreTools),
+                resolvePluginTools: (sessionId, coreTools) => {
+                    const resolved = pluginTools.resolveContributions(sessionId, coreTools);
+                    return { ...resolved, tools: personalAssistant.filterTools(sessionId, resolved.tools) };
+                },
                 resolvePluginSystemPrompt: async (sessionId, promptContext, baseText) => {
                     const assembly = await pluginSystemPrompt.assemble({
                         sessionId,
@@ -1190,7 +1223,10 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 const [graphTools, planState] = await Promise.all([
                     (sessionId === WORKHUB_COORDINATION_SESSION_ID && workHubResults && workHubInspection
                         ? Promise.resolve([workHubResults.tool, workHubInspection])
-                        : requireGraphCoordinator(graphCoordinator).toolsForSession(sessionId)).then((tools) => [...personalAssistant.tools, ...tools]),
+                        : requireGraphCoordinator(graphCoordinator).toolsForSession(sessionId)).then((tools) => [
+                        ...personalAssistant.filterTools(sessionId, personalAssistant.tools),
+                        ...tools,
+                    ]),
                     planStore.readState(sessionId),
                 ]);
                 const { runtimePolicy, surface } = await resolveInteractiveToolSurface({
@@ -1524,7 +1560,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 context.requestDrain();
             },
             onSucceeded: () => {
-                pluginExecutors.invalidateCatalog();
+                pluginExecutors.invalidateCatalog(ANTIGRAVITY_ACP_EXECUTOR_ID);
                 hostChanges.publishConfiguration();
             },
             capabilities: clientCapabilities,
@@ -1621,6 +1657,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         };
         const pluginSessionSummary = (session) => Object.freeze({
             id: session.id,
+            isArchived: session.isArchived,
             ...(session.name ? { title: session.name } : {}),
             ...(session.cwd ? { cwd: session.cwd } : {}),
             ...(session.labels?.length ? { labels: session.labels } : {}),
@@ -1970,12 +2007,20 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             onError: () => context.requestDrain(),
         });
         const goalExecutionCoordinator = new HostGoalExecutionCoordinator({
+            authorizeEventWait: async (sessionId, pending) => (await requireGoal(goal).eventWaitBridge?.authorizeAdmission(sessionId, pending)) ?? false,
             executions: coordinator,
             runtime: manager,
             matchesActive: (sessionId, checkpoint, controlLease) => requireGoal(goal).matchesActive(sessionId, checkpoint, controlLease),
         });
         goalExecutions = goalExecutionCoordinator;
+        const shellRunWaitAccess = new ShellRunEventWaitAccess(openedShellRunStore, stores.runtimeEventStore);
         goal = new HostGoalCoordinator({
+            eventWaitSources: dependencies.eventWaitSources ?? {
+                adapters: new EventWaitAdapterRegistry([
+                    new ShellRunEventWaitAdapter(shellRunWaitAccess, shellRuns),
+                ]),
+                authorize: (wait, signal) => shellRunWaitAccess.authorize(wait, signal),
+            },
             store: openedGoalStore,
             stores,
             readSessionContext: async (sessionId) => {
@@ -1996,7 +2041,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 requestDrain: context.requestDrain,
                 readSessionHeader: (sessionId) => stores.sessionStore.readHeaderSnapshot(sessionId),
             }),
-            admitTurn: (sessionId, text, checkpoint, controlLease) => goalExecutionCoordinator.admitTurn(sessionId, text, checkpoint, controlLease),
+            admitTurn: (sessionId, text, checkpoint, controlLease, eventWait) => goalExecutionCoordinator.admitTurn(sessionId, text, checkpoint, controlLease, eventWait),
             acquireResidency: (kind) => context.acquireResidency('goal', kind),
             onProjectionChanged: (sessionId) => continuityCoordinator.enqueueCanonicalRefresh(sessionId),
             requestDrain: context.requestDrain,
@@ -2031,7 +2076,8 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         });
         async function applyRuntimePolicyMutationEffects() {
             try {
-                pluginExecutors.invalidateCatalog();
+                // Reconciliation replaces only changed agent configurations. Unrelated
+                // policy edits must not discard every provider's persistent catalog.
                 await builtinExternalAgentPlugins.reconcile();
                 await requireMemory(memory).refreshAfterPolicyMutation();
             }
@@ -2095,6 +2141,46 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 ? { sessionAccessAuthority: context.sessionAccessAuthority }
                 : {}),
         });
+        const sessionCheckins = new HostSessionCheckinCoordinator({
+            allowed: async () => !(await runtimePolicyStores.runtimePolicy.getSnapshot()).policy.privacy.incognitoActive,
+            listSessions: (context) => listCheckinCatalogSessions((input) => sessionCatalog.handlers['session.catalog.query'](input, context)),
+            readSession: async (session) => {
+                // The Todo read takes the Session's admission itself, so it cannot run inside this one.
+                const todos = (await sessionTodo.read(session.id)).items;
+                return sessionAdmission.run(session.id, async () => {
+                    const canonical = await canonicalProjectionReader.read(session.id);
+                    if (!canonical || canonical.session.isArchived)
+                        return undefined;
+                    await requireSessionManager(manager).ensureTranscriptLedgerForRead(session.id);
+                    const view = await recapReadModel.getSessionView(session.id);
+                    return checkinSessionState({
+                        session,
+                        canonical,
+                        todos,
+                        messages: view.messages,
+                        turns: view.turns,
+                    });
+                });
+            },
+            readModelTarget: () => resolveDefaultModelHeader(runtimePolicyStores),
+            generate: createHostCheckinModel({
+                runtimePolicy: runtimePolicyStores,
+                oauthCredentials,
+                usage: openedUsageStores,
+                requestDrain: context.requestDrain,
+            }),
+        });
+        checkins = sessionCheckins;
+        const assistantWorkspace = new HostPersonalAssistantWorkspace({
+            stateRoot: context.owner.capability.canonicalPath,
+            ...(options.assistantHomeDirectory ? { homeDirectory: options.assistantHomeDirectory } : {}),
+            projects: openedProjectCatalog,
+            membership: projectMembership,
+            projectChanged: () => hostChanges.publishProjectCatalog(),
+            preflightSessionCreation: async () => {
+                await sessionCatalog.resolveDefaultCreateTarget();
+            },
+        });
         const workHubTargetExecution = new HostWorkHubTargetExecutionAuthority({
             readSession: (sessionId) => stores.sessionStore.readHeaderRecordSnapshot(sessionId),
             runtimePolicy: {
@@ -2468,6 +2554,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         });
         const externalSessions = new HostExternalSessionCoordinator({
             adapters: createExternalSessionAdapterRegistry(),
+            artifacts: openedArtifactStore,
             admission: sessionAdmission,
             sessions: stores.sessionStore,
             workspaceResolver,
@@ -2477,6 +2564,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 const outcomes = await Promise.allSettled([
                     stores.purgeConversationOperationalState(sessionId),
                     sessionTodoStore.purgeSessionState(sessionId),
+                    openedArtifactStore.purgeSessionArtifacts(sessionId),
                     stores.sessionStore.remove(sessionId),
                 ]);
                 for (const outcome of outcomes) {
@@ -2606,6 +2694,15 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             catalog: stores.sessionStore,
             retirement: sessionRetirement,
         });
+        sessionCheckpoints = await createHostSessionCheckpointPublication({
+            context,
+            stores,
+            admission: sessionAdmission,
+            manager: requireSessionManager(manager),
+            shellRuns: openedShellRunStore,
+            isSessionIdle: (sessionId) => rootRecoveryCompleted && !draining && coordinator.isSessionExecutionIdle(sessionId),
+            options: dependencies.checkpointPublication,
+        });
         const storageMaintenance = new HostStorageMaintenance({
             artifacts: openedArtifactStore,
             contextOffload: openedContextOffloadStore,
@@ -2839,7 +2936,9 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                                 return result;
                             // Canonical receipts remain queryable even while the feature is disabled.
                             const visible = new Set((await stores.sessionStore.readMessagesSnapshot(input.sessionId))
-                                .filter((row) => row.type === 'user' && row.turnId === `assistant-input:${row.id}`)
+                                .filter((row) => row.type === 'user' &&
+                                (row.turnId === assistantInputTurnId(row.id) ||
+                                    row.turnId === legacyAssistantInputTurnId(row.id)))
                                 .map((row) => row.id));
                             return {
                                 ok: true,
@@ -2904,6 +3003,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     interactions.handlers,
                     sessionEffectCoordinator.handlers,
                     promptSuggestionCoordinator.handlers,
+                    sessionCheckins.handlers,
                     continuityCoordinator.handlers,
                     runtimeResources.handlers,
                     contextOperations.handlers,
@@ -2934,6 +3034,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     () => interactions.beginDrain(),
                     () => sessionEffects?.beginDrain(),
                     () => promptSuggestions?.beginDrain(),
+                    () => checkins?.beginDrain(),
                 ],
                 close: [
                     async () => {
@@ -2949,6 +3050,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     () => workspaceExecution?.close(),
                     () => sessionEffects?.close(),
                     () => promptSuggestions?.close(),
+                    () => checkins?.close(),
                     () => messages.close(),
                     () => interactions.close(),
                     () => turnAccessRequests?.close(),
@@ -3018,6 +3120,12 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 catch (error) {
                     errors.push(error);
                 }
+                try {
+                    await sessionCheckpoints?.close();
+                }
+                catch (error) {
+                    errors.push(error);
+                }
                 try {
                     await closeRuntimeHostDomainModules(domainModules);
                 }
@@ -3040,6 +3148,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         };
         return {
             handlers,
+            sessionCheckpoints,
             moduleIds: Object.freeze(domainModules.map(({ id }) => id)),
             workspaceExecution: requireWorkspaceExecution(workspaceExecution),
             plugins: pluginPlatform,
@@ -3124,6 +3233,12 @@ export async function createExecutionRuntimeHostComposition(context, options = {
     }
     catch (error) {
         const errors = [error];
+        try {
+            await sessionCheckpoints?.close();
+        }
+        catch (closeError) {
+            errors.push(closeError);
+        }
         archiveEvidence?.close();
         try {
             await modelMetadataRefresh?.close();
@@ -3149,6 +3264,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         try {
             await sessionEffects?.close();
             await promptSuggestions?.close();
+            await checkins?.close();
         }
         catch (closeError) {
             errors.push(closeError);

package/node_modules/@maka/runtime-host/dist/server/execution-model-authority.js

@@ -215,6 +215,43 @@ export function createHostPromptSuggestionModel(input) {
         return result.finishReason === 'length' ? undefined : result.text;
     };
 }
+const CHECKIN_MAX_OUTPUT_TOKENS = 2_048;
+const CHECKIN_REASONING_MAX_OUTPUT_TOKENS = 8_192;
+/**
+ * Creates the root-scoped check-in call. It reads many Sessions, so it runs on
+ * the user's default model (resolved by the coordinator before any read)
+ * rather than borrowing any one Session's.
+ */
+export function createHostCheckinModel(input) {
+    const authority = createAuxiliaryModelCallAuthority(input);
+    return async ({ target, prompt, abortSignal, }) => {
+        try {
+            const callId = authority.newId();
+            const result = await runHostAuxiliaryModelCall(authority, {
+                transportContextId: callId,
+                header: target,
+                callKind: 'session_checkin',
+                callId: `session_checkin_${callId}`,
+                abortSignal,
+                reasoning: 'least',
+                buildRequest: (_target, thinkingLevel) => ({
+                    prompt,
+                    maxOutputTokens: thinkingLevel === 'off'
+                        ? CHECKIN_MAX_OUTPUT_TOKENS
+                        : CHECKIN_REASONING_MAX_OUTPUT_TOKENS,
+                    maxRetries: 0,
+                }),
+            });
+            return result.finishReason === 'length'
+                ? { ok: false, errorClass: 'invalid_response' }
+                : { ok: true, text: result.text };
+        }
+        catch (error) {
+            const errorClass = auxiliaryModelErrorClass(error, abortSignal);
+            return { ok: false, errorClass: errorClass === 'persistence' ? 'unknown' : errorClass };
+        }
+    };
+}
 /** Creates tool-free Session title and recap calls on canonical Host model authority. */
 export function createHostSessionEffectModel(input) {
     const authority = createAuxiliaryModelCallAuthority(input);
@@ -649,14 +686,21 @@ async function resolveDailyReviewHeader(runtimePolicy, modelKey) {
             thinkingLevel: 'off',
         };
     }
+    const header = await resolveDefaultModelHeader(runtimePolicy);
+    if (!header) {
+        throw new AuxiliaryModelCallConfigurationError('Daily Review has no canonical default model target');
+    }
+    return header;
+}
+/** The connection and model the user chose as default, or undefined when none is set. */
+export async function resolveDefaultModelHeader(runtimePolicy) {
     const catalog = await runtimePolicy.connectionCatalog.getSnapshot();
     const target = catalog.defaultTarget;
     const connection = target
         ? catalog.connections.find((candidate) => candidate.connectionId === target.connectionId)
         : undefined;
-    if (!target || !connection) {
-        throw new AuxiliaryModelCallConfigurationError('Daily Review has no canonical default model target');
-    }
+    if (!target || !connection)
+        return undefined;
     return {
         llmConnectionId: connection.connectionId,
         llmConnectionSlug: connection.slug,

package/node_modules/@maka/runtime-host/dist/server/execution-model-composition.js

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { randomUUID } from 'node:crypto';
+import { ASSISTANT_BACKGROUND_SESSION_LABEL } from '@maka/core/session';
 import { createRunCompositionSnapshot } from '@maka/core/run-composition';
 import { resolveModelVisionSupport } from '@maka/core/model-metadata';
 import { modelOverride } from '@maka/core/model-thinking';
@@ -269,6 +270,16 @@ async function buildHostAiSdkBackend(input, target) {
             contextBudget: buildDefaultContextBudgetPolicy({
                 name: 'runtime-host-default-history-budget',
                 modelId: target.model,
+                // The persistent Bot cannot depend on a provider rejecting its ever-growing
+                // history. Ordinary sessions retain their existing opt-in policy. The
+                // runtime gives an explicit user threshold precedence over this fallback.
+                ...(input.context.header.labels?.includes(ASSISTANT_BACKGROUND_SESSION_LABEL) &&
+                    input.context.header.labels.some((label) => label.startsWith('assistant-bot:')) &&
+                    contextWindow !== undefined
+                    ? {
+                        fallbackCompactionThresholdTokens: Math.floor(contextWindow * 0.8),
+                    }
+                    : {}),
             }),
             supportsVision: resolveModelVisionSupport(target.connection.providerType, target.connection.models, target.model, modelOverride(target.connection, target.model)?.vision),
             readAttachmentBytes: createAttachmentByteReader({

package/node_modules/@maka/runtime-host/dist/server/external-session-coordinator.js

@@ -31,6 +31,7 @@ export class HostExternalSessionCoordinator {
         'external-session.import': (input) => this.importSession(input),
     };
     #adapters;
+    #artifacts;
     #admission;
     #sessions;
     #workspaceResolver;
@@ -60,6 +61,7 @@ export class HostExternalSessionCoordinator {
     #importsInFlight = new Map();
     constructor(options) {
         this.#adapters = options.adapters;
+        this.#artifacts = options.artifacts;
         this.#admission = options.admission;
         this.#sessions = options.sessions;
         this.#workspaceResolver = options.workspaceResolver;
@@ -228,14 +230,15 @@ export class HostExternalSessionCoordinator {
         }
         let commitAttempted = false;
         const importer = new ExternalSessionImporter(this.#adapters, {
-            createImportedSession: async (sessionInput, messages, externalOrigin) => {
+            createImportedSession: async (sessionInput, messages, externalOrigin, options) => {
                 return this.#sessions.createImportedSession(sessionInput, messages, externalOrigin, {
+                    ...options,
                     onCommitStarted: () => {
                         commitAttempted = true;
                     },
                 });
             },
-        });
+        }, this.#artifacts);
         let header;
         try {
             header = await importer.import({