maka-agent 0.2.0-dev.44.20260920 → 0.2.0-dev.45.20260921

package/node_modules/@maka/runtime-host/dist/protocol/recall.js

@@ -0,0 +1,270 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * `recall.query` — the retrieval surface a Client can ask for directly.
+ *
+ * Recall runs inside the Host because that is where the corpus lives: the
+ * Session manager, the distilled-fact store, and the material fetch are all
+ * Host-owned. A Client cannot perform it itself without pulling every
+ * transcript across the boundary, which is exactly the arrangement this
+ * operation replaces.
+ *
+ * The wire shape mirrors what the model's `Recall` tool already returns
+ * (`@maka/runtime/recall-tools`), with this protocol's camelCase field naming.
+ * That is deliberate: one recall answer, two presentations. A UI renders
+ * passages as navigable results and a model reads them as context, and neither
+ * gets a second implementation to drift from.
+ */
+import { RECALL_MAX_LIMIT, RECALL_MAX_TERMS, RECALL_TOTAL_PAYLOAD_CAP_BYTES, } from '@maka/core/recall';
+import { SEARCH_QUERY_MAX_CHARS } from '@maka/core/search';
+import { requireCount, requireEncodedByteLimit, requireEntityId, requireShapedRecord, requireUtf8String, } from './codec.js';
+import { invalidProtocolFrame } from './errors.js';
+import { defineOperation } from './operation-spec.js';
+export const RECALL_QUERY_TERM_MAX_CHARS = SEARCH_QUERY_MAX_CHARS;
+/**
+ * Byte ceiling for one term. Core measures a term in code points
+ * (`Array.from(term).length`), so the wire bound is that count times the
+ * widest UTF-8 encoding of one code point. A term that passes here can still
+ * be rejected by core on the character count; this only stops a frame that
+ * could not represent a legal term at all.
+ */
+const RECALL_QUERY_TERM_MAX_BYTES = RECALL_QUERY_TERM_MAX_CHARS * 4;
+export const RECALL_QUERY_QUESTION_MAX_BYTES = 2 * 1024;
+export const RECALL_QUERY_TEXT_MAX_BYTES = 32 * 1024;
+export const RECALL_QUERY_MATERIAL_NAME_MAX_BYTES = 1024;
+export const RECALL_QUERY_RESOURCE_MAX_BYTES = 1024;
+/**
+ * Encoded ceiling for one envelope. Recall caps its own payload at
+ * `RECALL_TOTAL_PAYLOAD_CAP_BYTES`, but that counts passage text only; the
+ * envelope adds field names, message ids, timestamps and materials on top.
+ * This bound is that cap plus generous structural headroom, so it rejects a
+ * frame that no honest Host could have produced without constraining one that
+ * did.
+ */
+export const RECALL_QUERY_RESULT_MAX_BYTES = RECALL_TOTAL_PAYLOAD_CAP_BYTES + 64 * 1024;
+const RECALL_FAILURE_REASONS = [
+    'invalid_query',
+    'incognito_active',
+    'not_found',
+    'aborted',
+];
+const RECALL_ROLES = ['user', 'assistant', 'tool'];
+const RECALL_MATERIAL_KINDS = ['image', 'pdf', 'doc', 'code', 'other'];
+const ERROR_CODES = [
+    'host_not_ready',
+    'host_draining',
+    'operation_unavailable',
+    'invalid_request',
+    'internal_failure',
+];
+export const RECALL_OPERATION_SPECS = {
+    'recall.query': defineOperation({
+        mode: 'query',
+        availability: 'ready',
+        errors: ERROR_CODES,
+        decodeInput: decodeRecallQueryInput,
+        decodeOutput: decodeRecallQueryResult,
+    }),
+};
+function decodeRecallQueryInput(value) {
+    const record = requireShapedRecord(value, 'Recall query input', ['terms'], ['question', 'limit', 'sessionId', 'since', 'until']);
+    if (!Array.isArray(record.terms) || record.terms.length === 0) {
+        throw invalidProtocolFrame('Invalid Recall terms');
+    }
+    if (record.terms.length > RECALL_MAX_TERMS) {
+        throw invalidProtocolFrame('Too many Recall terms');
+    }
+    const terms = record.terms.map((term) => requireUtf8String(term, 'Recall term', RECALL_QUERY_TERM_MAX_BYTES));
+    const limit = record.limit === undefined ? undefined : requireCount(record.limit, 'Recall limit');
+    if (limit !== undefined && (limit < 1 || limit > RECALL_MAX_LIMIT)) {
+        throw invalidProtocolFrame('Invalid Recall limit');
+    }
+    return {
+        terms,
+        ...(record.question === undefined
+            ? {}
+            : {
+                question: requireUtf8String(record.question, 'Recall question', RECALL_QUERY_QUESTION_MAX_BYTES),
+            }),
+        ...(limit === undefined ? {} : { limit }),
+        ...(record.sessionId === undefined
+            ? {}
+            : { sessionId: requireEntityId(record.sessionId, 'Recall sessionId') }),
+        ...(record.since === undefined ? {} : { since: requireCount(record.since, 'Recall since') }),
+        ...(record.until === undefined ? {} : { until: requireCount(record.until, 'Recall until') }),
+    };
+}
+/**
+ * Bounded text that may be empty. Transcript text is legitimately empty when a
+ * message carried only files, and a Session title is empty for an unnamed
+ * Session; both are legal answers, so they must not be rejected as malformed.
+ */
+function requireBoundedText(value, label, maxBytes) {
+    if (typeof value !== 'string' || Buffer.byteLength(value, 'utf8') > maxBytes) {
+        throw invalidProtocolFrame(`Invalid ${label}`);
+    }
+    return value;
+}
+function decodeRecallQueryResult(value) {
+    requireEncodedByteLimit(value, 'Recall query result', RECALL_QUERY_RESULT_MAX_BYTES);
+    const record = requireShapedRecord(value, 'Recall query result', ['ok'], ['facts', 'passages', 'gaps', 'searchedEverySession', 'reason', 'message']);
+    if (record.ok === false) {
+        const exact = requireShapedRecord(record, 'Recall error result', ['ok', 'reason', 'message'], []);
+        if (typeof exact.reason !== 'string' ||
+            !RECALL_FAILURE_REASONS.includes(exact.reason)) {
+            throw invalidProtocolFrame('Invalid Recall failure reason');
+        }
+        return {
+            ok: false,
+            reason: exact.reason,
+            message: requireUtf8String(exact.message, 'Recall failure message', RECALL_QUERY_TEXT_MAX_BYTES),
+        };
+    }
+    if (record.ok !== true)
+        throw invalidProtocolFrame('Invalid Recall query result kind');
+    const exact = requireShapedRecord(record, 'Recall success result', ['ok', 'facts', 'passages', 'gaps', 'searchedEverySession'], []);
+    if (!Array.isArray(exact.facts) || !Array.isArray(exact.passages)) {
+        throw invalidProtocolFrame('Invalid Recall success result');
+    }
+    if (typeof exact.searchedEverySession !== 'boolean') {
+        throw invalidProtocolFrame('Invalid Recall searchedEverySession');
+    }
+    return {
+        ok: true,
+        facts: exact.facts.map((fact) => decodeFact(fact)),
+        passages: exact.passages.map((passage) => decodePassage(passage)),
+        gaps: requireUtf8String(exact.gaps, 'Recall gaps', RECALL_QUERY_TEXT_MAX_BYTES),
+        searchedEverySession: exact.searchedEverySession,
+    };
+}
+function decodeFact(value) {
+    const record = requireShapedRecord(value, 'Recall fact', ['content', 'kind', 'observedAt'], []);
+    return {
+        content: requireUtf8String(record.content, 'Recall fact content', RECALL_QUERY_TEXT_MAX_BYTES),
+        kind: requireUtf8String(record.kind, 'Recall fact kind', RECALL_QUERY_MATERIAL_NAME_MAX_BYTES),
+        observedAt: requireCount(record.observedAt, 'Recall fact observedAt'),
+    };
+}
+function decodePassage(value) {
+    const record = requireShapedRecord(value, 'Recall passage', [
+        'sessionId',
+        'sessionTitle',
+        'anchorMessageId',
+        'sequence',
+        'messages',
+        'matchedTerms',
+        'score',
+        'hasMoreBefore',
+        'hasMoreAfter',
+    ], ['turnId', 'lastMessageAt', 'truncated']);
+    if (!Array.isArray(record.messages) || !Array.isArray(record.matchedTerms)) {
+        throw invalidProtocolFrame('Invalid Recall passage messages');
+    }
+    if (typeof record.score !== 'number' || !Number.isFinite(record.score)) {
+        throw invalidProtocolFrame('Invalid Recall passage score');
+    }
+    if (typeof record.hasMoreBefore !== 'boolean' || typeof record.hasMoreAfter !== 'boolean') {
+        throw invalidProtocolFrame('Invalid Recall passage continuation flags');
+    }
+    return {
+        sessionId: requireEntityId(record.sessionId, 'Recall passage sessionId'),
+        sessionTitle: requireBoundedText(record.sessionTitle, 'Recall passage sessionTitle', RECALL_QUERY_TEXT_MAX_BYTES),
+        ...(record.turnId === undefined
+            ? {}
+            : { turnId: requireEntityId(record.turnId, 'Recall passage turnId') }),
+        anchorMessageId: requireEntityId(record.anchorMessageId, 'Recall passage anchorMessageId'),
+        sequence: requireCount(record.sequence, 'Recall passage sequence'),
+        messages: record.messages.map((message) => decodePassageMessage(message)),
+        matchedTerms: record.matchedTerms.map((term) => requireUtf8String(term, 'Recall matched term', RECALL_QUERY_TERM_MAX_BYTES)),
+        score: record.score,
+        ...(record.lastMessageAt === undefined
+            ? {}
+            : { lastMessageAt: requireCount(record.lastMessageAt, 'Recall passage lastMessageAt') }),
+        hasMoreBefore: record.hasMoreBefore,
+        hasMoreAfter: record.hasMoreAfter,
+        ...(record.truncated === undefined
+            ? {}
+            : record.truncated === true
+                ? { truncated: true }
+                : (() => {
+                    throw invalidProtocolFrame('Invalid Recall passage truncated flag');
+                })()),
+    };
+}
+function decodePassageMessage(value) {
+    const record = requireShapedRecord(value, 'Recall passage message', ['messageId', 'role', 'matchKind', 'text', 'timestamp', 'isAnchor'], ['materials']);
+    if (typeof record.role !== 'string' ||
+        !RECALL_ROLES.includes(record.role)) {
+        throw invalidProtocolFrame('Invalid Recall passage message role');
+    }
+    if (typeof record.isAnchor !== 'boolean') {
+        throw invalidProtocolFrame('Invalid Recall passage message anchor flag');
+    }
+    if (record.materials !== undefined && !Array.isArray(record.materials)) {
+        throw invalidProtocolFrame('Invalid Recall passage message materials');
+    }
+    return {
+        messageId: requireEntityId(record.messageId, 'Recall passage messageId'),
+        role: record.role,
+        matchKind: requireUtf8String(record.matchKind, 'Recall passage message matchKind', RECALL_QUERY_MATERIAL_NAME_MAX_BYTES),
+        // A message whose whole content was a pasted file carries no text of its
+        // own; the material beside it is the point. Empty is legal here, unlike
+        // the identifiers around it.
+        text: requireBoundedText(record.text, 'Recall passage message text', RECALL_QUERY_TEXT_MAX_BYTES),
+        timestamp: requireCount(record.timestamp, 'Recall passage message timestamp'),
+        isAnchor: record.isAnchor,
+        ...(record.materials === undefined
+            ? {}
+            : { materials: record.materials.map((material) => decodeMaterial(material)) }),
+    };
+}
+function decodeMaterial(value) {
+    const record = requireShapedRecord(value, 'Recall material', ['name', 'kind', 'mimeType', 'bytes'], ['resource', 'sourceSessionId', 'materialId']);
+    if (typeof record.kind !== 'string' ||
+        !RECALL_MATERIAL_KINDS.includes(record.kind)) {
+        throw invalidProtocolFrame('Invalid Recall material kind');
+    }
+    const resource = record.resource === undefined
+        ? undefined
+        : requireUtf8String(record.resource, 'Recall material resource', RECALL_QUERY_RESOURCE_MAX_BYTES);
+    const sourceSessionId = record.sourceSessionId === undefined
+        ? undefined
+        : requireEntityId(record.sourceSessionId, 'Recall material sourceSessionId');
+    const materialId = record.materialId === undefined
+        ? undefined
+        : requireEntityId(record.materialId, 'Recall material materialId');
+    // An address says "read this now"; a location says "ask for it". Carrying
+    // both would offer a caller two answers to one question, so recall never
+    // emits both and the decoder refuses the shape rather than picking a winner.
+    if (resource !== undefined && (sourceSessionId !== undefined || materialId !== undefined)) {
+        throw invalidProtocolFrame('Invalid Recall material location');
+    }
+    if ((sourceSessionId === undefined) !== (materialId === undefined)) {
+        throw invalidProtocolFrame('Incomplete Recall material location');
+    }
+    return {
+        name: requireUtf8String(record.name, 'Recall material name', RECALL_QUERY_MATERIAL_NAME_MAX_BYTES),
+        kind: record.kind,
+        mimeType: requireUtf8String(record.mimeType, 'Recall material mimeType', RECALL_QUERY_MATERIAL_NAME_MAX_BYTES),
+        bytes: requireCount(record.bytes, 'Recall material bytes'),
+        ...(resource === undefined ? {} : { resource }),
+        ...(sourceSessionId === undefined ? {} : { sourceSessionId }),
+        ...(materialId === undefined ? {} : { materialId }),
+    };
+}

package/node_modules/@maka/runtime-host/dist/protocol/session-continuity.js

@@ -47,13 +47,7 @@ export const SESSION_TOOL_INTENT_MAX_BYTES = 512;
 export const SESSION_TOOL_ARGS_PREVIEW_MAX_BYTES = 8 * 1024;
 export const SESSION_SUBSCRIPTION_FRAME_MAX_BYTES = 64 * 1024 - 1;
 export const SESSION_RUNTIME_RESOURCE_PTY_DATA_MAX_BYTES = 48 * 1024;
-export const SESSION_DOMAINS = [
-    'todo',
-    'plan',
-    'deep_research',
-    'usage',
-    'runtime_resource',
-];
+export const SESSION_DOMAINS = ['todo', 'plan', 'usage', 'runtime_resource'];
 export const SESSION_RUNTIME_RESOURCE_CHANGES_MAX = 64;
 const SUBSCRIPTION_OPEN_ERRORS = [
     'transcript_preparing',

package/node_modules/@maka/runtime-host/dist/protocol/usage-screen.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { isUsageScreenSearch, isUsageTimestamp, } from '@maka/core/settings';
 import { requireExactRecord, requireRecord, requireShapedRecord, requireCount } from './codec.js';
 import { invalidProtocolFrame } from './errors.js';
 import { decodeUsageProvenance } from './usage-pricing.js';
@@ -41,16 +42,23 @@ function amount(value) {
         return fail();
     return value;
 }
+function timestamp(value) {
+    if (!isUsageTimestamp(value))
+        return fail();
+    return value;
+}
 function query(value) {
     const v = requireExactRecord(value, 'Usage screen query', ['range', 'search', 'status']);
     const range = requireExactRecord(v.range, 'Usage range', ['from', 'to']);
-    const from = requireCount(range.from, 'Usage from');
-    const to = requireCount(range.to, 'Usage to');
+    const from = timestamp(range.from);
+    const to = timestamp(range.to);
     if (from > to || !['all', 'success', 'error', 'aborted'].includes(String(v.status)))
         return fail();
+    if (!isUsageScreenSearch(v.search))
+        return fail();
     return {
         range: { from, to },
-        search: text(v.search),
+        search: v.search,
         status: v.status,
     };
 }
@@ -228,8 +236,8 @@ export function decodeUsageScreenResult(value) {
         for (const key of ['id', 'provider', 'model', 'sessionId', 'sessionName', 'turnId', 'toolName'])
             if (row[key] !== undefined)
                 text(row[key]);
+        timestamp(row.ts);
         for (const key of [
-            'ts',
             'inputTokens',
             'outputTokens',
             'cacheMiss',

package/node_modules/@maka/runtime-host/dist/server/access-credential-store.js

@@ -48,8 +48,12 @@ const PERSISTED_GRANT_MIGRATIONS = new Map([
     // Retired with the second execution-inspection contract; no shipped surface
     // called execution.inspect.resolve.
     ['execution.inspect.resolve', { kind: 'release' }],
+    // Retired with the Command Code GO provider, whose private transport the
+    // usage read required.
+    ['connection.usage.read', { kind: 'release' }],
     // Retired in favor of editing and resending the original user message.
     ['turn.regenerate', { kind: 'release' }],
+    ['deep-research.query', { kind: 'release' }],
     // Direct WorkHub actions and record writes were retired. Their grants do not
     // authorize actFromTurn, which requires the active coordination Turn.
     ['workhub.coordination.act', { kind: 'release' }],

package/node_modules/@maka/runtime-host/dist/server/connection-effect-coordinator.js

@@ -17,13 +17,12 @@
  * under the License.
  */
 import { parseRequestHeaders } from '@maka/core/runtime-policy';
-import { PROVIDER_REGISTRY, effectiveBaseUrl, providerFallbackModelIds, } from '@maka/core/llm-connections';
+import { PROVIDER_REGISTRY, providerFallbackModelIds, } from '@maka/core/llm-connections';
 import { createConnectionEffectFetchTransport, } from '@maka/runtime/network/scoped-fetch-transport';
 import { createRequestCustomizationFetch } from '@maka/runtime/request-customization-fetch';
 import { isOAuthSubscriptionProvider, parseOAuthSubscriptionTokens, } from '@maka/runtime/subscription-credentials';
 import { runConnectionModelDiscoveryEffect } from '@maka/runtime/model-fetcher';
 import { runConnectionTestEffect } from '@maka/runtime/test-connection';
-import { fetchConnectionUsage } from '@maka/runtime/connection-usage';
 import { authenticateRuntimePolicyStoresWriter, RuntimePolicyStoreError, } from '@maka/storage/runtime-policy-stores';
 import { toRuntimePolicyProxy } from './runtime-policy-proxy.js';
 /** Runs provider I/O outside Storage lanes and conditionally commits canonical results. */
@@ -33,7 +32,6 @@ export class HostConnectionEffectCoordinator {
         'connection.onboarding.verify': (input) => this.#verifyOnboarding(input),
         'connection.models.fetch': (input) => this.#fetchModels(input),
         'connection.test.run': (input) => this.#testConnection(input),
-        'connection.usage.read': (input) => this.#readConnectionUsage(input),
     };
     #stores;
     #activation;
@@ -265,32 +263,6 @@ export class HostConnectionEffectCoordinator {
                 : projectSuperseded(completion);
         });
     }
-    /**
-     * Read-only: fetch the account's usage and project it. Nothing is committed,
-     * so no superseded branch exists — the ticket is spent and the report
-     * returned.
-     */
-    #readConnectionUsage(input) {
-        return this.#admit(input.connectionId, 'connection.usage.read', async () => {
-            const prepared = await this.#stores.operations.beginConnectionUsage(input.connectionId);
-            if (prepared.kind !== 'ready')
-                return preparationResult(prepared);
-            try {
-                const result = await this.#withTransport(prepared, (fetch, secret) => fetchConnectionUsage({
-                    providerType: prepared.connection.providerType,
-                    apiKey: secret,
-                    baseUrl: effectiveBaseUrl(prepared.connection),
-                    fetch,
-                }));
-                return result.kind === 'report'
-                    ? { kind: 'report', report: projectUsageReport(result.report) }
-                    : { kind: 'unavailable', reason: result.reason };
-            }
-            finally {
-                await this.#stores.operations.completeConnectionUsage(prepared.ticket);
-            }
-        });
-    }
     #admit(connectionId, operation, run) {
         if (!this.#accepting) {
             return Promise.resolve({
@@ -379,34 +351,6 @@ function projectSuperseded(completion) {
         changed: completion.changed.map((domain) => domain),
     };
 }
-function projectUsageReport(report) {
-    return {
-        accountLabel: report.accountLabel ?? null,
-        planLabel: report.planLabel ?? null,
-        stats: report.stats
-            ? {
-                requests: report.stats.requests ?? null,
-                failed: report.stats.failed ?? null,
-                successRate: report.stats.successRate ?? null,
-                cost: report.stats.cost ?? null,
-                tokensIn: report.stats.tokensIn ?? null,
-                tokensOut: report.stats.tokensOut ?? null,
-            }
-            : null,
-        windows: report.windows.map((window) => ({
-            id: window.id,
-            label: window.label ?? null,
-            used: window.used,
-            cap: window.cap,
-            unit: window.unit,
-            resetsAt: window.resetsAt ?? null,
-            unlimited: window.unlimited ?? null,
-        })),
-        periodEnd: report.periodEnd ?? null,
-        partiallyUnauthorized: report.partiallyUnauthorized === true,
-        fetchedAt: report.fetchedAt,
-    };
-}
 function projectConnectionTest(outcome, checkedAt) {
     const checkedAtIso = new Date(checkedAt).toISOString();
     if (outcome.ok) {

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

@@ -24,9 +24,9 @@ import { NO_REAL_CONNECTION_CODE } from '@maka/core/connection-error-copy';
 import { generalizedErrorMessage } from '@maka/core/redaction';
 import { emptyPlanSessionState } from '@maka/core/plan';
 import { readLogicalRuntimeExecutionForRun } from '@maka/core/runtime-logical-execution';
-import { foldForMatch } from '@maka/core/thread-search';
+import { foldForMatch } from '@maka/core/transcript-search';
 import { runtimeInvocationOutcome, } from '@maka/core/runtime-invocation';
-import { isDeepResearchSession, WORKHUB_COORDINATION_SESSION_ID, WORKHUB_COORDINATION_REPLACEMENT_SCHEMA_VERSION, } from '@maka/core/session';
+import { WORKHUB_COORDINATION_SESSION_ID, WORKHUB_COORDINATION_REPLACEMENT_SCHEMA_VERSION, } from '@maka/core/session';
 import { AgentGraphClientOperationError, AgentGraphCoordinator, } from '@maka/runtime/stream-graph-coordinator';
 import { AgentGraphSupervisorWakeCoordinator } from '@maka/runtime/agent-graph-supervisor-wake';
 import { BackendRegistry, SessionManager, workHubDirectStopAbortSource, } from '@maka/runtime/session-manager';
@@ -34,6 +34,7 @@ import { buildToolsForAgentDefinition } from '@maka/runtime/agent-catalog';
 import { buildRecallTools } from '@maka/runtime/recall-tools';
 import { RECALL_SYNTHETIC_TEXT_PATTERNS } from '@maka/runtime/recall-candidates';
 import { createRecallMaterialFetch } from './recall-material-fetch.js';
+import { HostRecallCoordinator } from './recall-coordinator.js';
 import { buildBuiltinTools } from '@maka/runtime/builtin-tools';
 import { createLocalContinuationSafetyInspector } from '@maka/runtime/continuation-safety';
 import { createConfiguredSubagentCatalog } from '@maka/runtime/configured-subagent-catalog';
@@ -95,7 +96,6 @@ import { HostChangeFeed } from './host-change-feed.js';
 import { HostConfigurationCoordinator } from './configuration-coordinator.js';
 import { HostContextCoordinator } from './context-coordinator.js';
 import { HostClientCapabilityCoordinator } from './client-capability-coordinator.js';
-import { HostDeepResearchCoordinator } from './deep-research-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';
@@ -258,7 +258,6 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         const oauthCredentials = new HostOAuthExecutionAuthority(runtimePolicyStores);
         const openedScheduledTaskStore = storage.scheduledTasks;
         const openedPlanStore = storage.plan;
-        const openedDeepResearchStore = storage.deepResearch;
         const openedDailyReviewStore = storage.dailyReview;
         const openedGoalStore = storage.goal;
         const memoryStore = storage.memoryBundle;
@@ -485,7 +484,10 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             search: ({ query, limit, abortSignal }) => webSearchService.search({ query, limit, ...(abortSignal ? { abortSignal } : {}) }),
             fetch: (input) => webFetchService.fetch(input),
         });
-        const recallTools = buildRecallTools({
+        // The recall surface is built once and shared: the model's tools and the
+        // Host's `recall.query` operation answer from the same dependency graph, so
+        // a UI search and a model recall cannot diverge in what they can see.
+        const recallDeps = {
             listSessions: () => requireSessionManager(manager).listSessions(),
             readMessages: async (sessionId, abortSignal) => {
                 if (abortSignal?.aborted)
@@ -540,7 +542,9 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 incognitoActive: (await runtimePolicyStores.runtimePolicy.getSnapshot()).policy.privacy
                     .incognitoActive,
             }),
-        });
+        };
+        const recallTools = buildRecallTools(recallDeps);
+        const recall = new HostRecallCoordinator(recallDeps);
         const childHostTools = [
             createHostWebSearchToolFromService(webSearchService),
             createHostWebFetchToolFromService(webFetchService),
@@ -626,7 +630,6 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         let scheduledTasks;
         let scheduledTaskTool;
         let goal;
-        let deepResearch;
         let dailyReview;
         const rootPort = {
             readLatestRootTurnLineage: (identity) => requireRootCoordinator(rootCoordinator).readLatestRootTurnLineage(identity),
@@ -675,13 +678,6 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         unsubscribeTranscriptChanges = stores.sessionStore.subscribeTranscriptChanges((sessionId) => continuityCoordinator.enqueueCanonicalRefresh(sessionId));
         unsubscribeRuntimeEventCommits = stores.runtimeEventStore.subscribeRuntimeEventCommits((sessionId) => continuityCoordinator.enqueueTranscriptAdvanced(sessionId));
         unsubscribeUsageChanges = openedUsageStores.subscribeSessionUsageChanges((sessionId) => continuityCoordinator.enqueueSessionDomainChanged(sessionId, 'usage'));
-        deepResearch = new HostDeepResearchCoordinator({
-            store: openedDeepResearchStore,
-            artifacts: openedArtifactStore,
-            sessions: stores.sessionStore,
-            sessionAdmission,
-            onProjectionChanged: (sessionId) => continuityCoordinator.enqueueSessionDomainChanged(sessionId, 'deep_research'),
-        });
         dailyReview = new HostDailyReviewCoordinator({
             store: openedDailyReviewStore,
             usage: openedUsageStores,
@@ -784,7 +780,6 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 resolveTavilyWebSearchReadiness: () => resolveHostTavilyWebSearchReadiness(runtimePolicyStores.operations),
                 ...(scheduledTaskTool ? { scheduledTaskTool } : {}),
                 planStore,
-                deepResearchTools: requireDeepResearch(deepResearch).toolsForSession(backendContext.sessionId),
                 goalTools: requireGoal(goal).tools,
                 builtinTools,
                 hostTools,
@@ -946,13 +941,6 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                         mode: header.collaborationMode ?? 'agent',
                         permissionMode: header.permissionMode,
                     },
-                    ...(isDeepResearchSession(header.labels)
-                        ? {
-                            deepResearch: {
-                                tools: requireDeepResearch(deepResearch).toolsForSession(sessionId),
-                            },
-                        }
-                        : {}),
                 }).tools.map((tool) => tool.name);
             }
             finally {
@@ -2031,7 +2019,6 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 // writer: publishing a per-Session `plan` invalidation for state that is
                 // being removed would only wake subscribers to read nothing.
                 await openedPlanStore.purgeSessionState(sessionId);
-                await openedDeepResearchStore.purgeSessionState(sessionId);
             },
             purgeAgentGraphState: async (sessionId) => {
                 for (const graphId of await requireGraphCoordinator(graphCoordinator).listGraphIds(sessionId)) {
@@ -2150,6 +2137,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     oauth.handlers,
                     externalAgentSetup.handlers,
                     webSearch.handlers,
+                    recall.handlers,
                     networkProxy.handlers,
                     configuration.handlers,
                 ],
@@ -2222,11 +2210,6 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 drain: [() => clientCapabilities.beginDrain()],
                 close: [() => clientCapabilities.close()],
             }),
-            createRuntimeHostDomainModule({
-                id: 'deep-research',
-                handlers: [requireDeepResearch(deepResearch).handlers],
-                close: [() => deepResearch?.close()],
-            }),
             createRuntimeHostDomainModule({
                 id: 'daily-review',
                 handlers: [requireDailyReview(dailyReview).handlers],
@@ -2646,11 +2629,6 @@ function requireScheduledTasks(coordinator) {
         throw new Error('Runtime Host ScheduledTask coordinator is not composed');
     return coordinator;
 }
-function requireDeepResearch(coordinator) {
-    if (!coordinator)
-        throw new Error('Runtime Host Deep Research coordinator is not composed');
-    return coordinator;
-}
 function requireDailyReview(coordinator) {
     if (!coordinator)
         throw new Error('Runtime Host Daily Review coordinator is not composed');

package/node_modules/@maka/runtime-host/dist/server/interactive-run-composer.js

@@ -18,7 +18,6 @@
  */
 import { isDeepStrictEqual } from 'node:util';
 import { buildSideConversationSystemPromptFragment, isSideConversationSession, } from '@maka/core/side-conversation';
-import { buildDeepResearchSystemPromptFragment, isDeepResearchSession, } from '@maka/core/deep-research';
 import { activePlanExecution } from '@maka/core/plan';
 import { createHash } from 'node:crypto';
 import { assembleMainSessionSystemPrompt } from '@maka/runtime/system-prompt/main-session-prompt';
@@ -31,7 +30,6 @@ import { buildRequestSandboxBoundaryTool } from '@maka/runtime/sandbox-boundary-
 import { buildHostCapabilitiesFromBinding, buildSkillAgentToolFromInventory, buildSkillSearchAgentToolFromInventory, buildSkillsPromptFragmentFromInventoryWithReport, SkillShadowSelectionTracker, } from '@maka/runtime/skills';
 import { buildSessionTodoTools } from '@maka/runtime/session-todo-tools';
 import { buildWorkspaceInstructionsPromptFragment } from '@maka/runtime/system-prompt/workspace-instructions';
-import { isDeepResearchToolAllowed } from '@maka/runtime/deep-research-tools';
 import { listRunnableBuiltinAgentDefinitions } from '@maka/runtime/agent-catalog';
 import { renderPlanModePrompt, selectCollaborationTools } from '@maka/runtime/plan-mode';
 import { routeWebFetchTools } from '@maka/runtime/web-fetch-tool';
@@ -60,7 +58,7 @@ export function createInteractiveRunComposer(input) {
     // contributions are sampled at logical step boundaries.
     const defaultTools = input.boundTools
         ? input.boundTools
-        : buildDefaultHostTools(input.sessionTodo, inventoryFor, builtinTools, input.hostTools ?? [], input.scheduledTaskTool, input.goalTools, input.parentAgentTools, input.plan, input.deepResearch?.tools);
+        : buildDefaultHostTools(input.sessionTodo, inventoryFor, builtinTools, input.hostTools ?? [], input.scheduledTaskTool, input.goalTools, input.parentAgentTools, input.plan);
     const clientCapabilityTools = input.boundTools !== undefined ||
         (input.toolProfile !== undefined && input.toolProfile !== 'workhub-coordination-v2')
         ? []
@@ -70,11 +68,7 @@ export function createInteractiveRunComposer(input) {
         const additionalTools = hasToolCeiling
             ? []
             : (input.resolveAdditionalTools?.(stableHostTools) ?? []);
-        const unscopedCandidateTools = [...stableHostTools, ...additionalTools];
-        const routedCandidateTools = input.deepResearch
-            ? unscopedCandidateTools.filter(isDeepResearchToolAllowed)
-            : unscopedCandidateTools;
-        const candidateTools = projectHostedExecutionTools(routedCandidateTools, input.toolProfile);
+        const candidateTools = projectHostedExecutionTools([...stableHostTools, ...additionalTools], input.toolProfile);
         const selectedTools = input.plan
             ? selectCollaborationTools({
                 mode: input.plan.mode,
@@ -145,7 +139,6 @@ export function createInteractiveRunComposer(input) {
                     input.plan?.mode === 'plan'
                         ? renderPlanModePrompt({ fullAccess: input.plan.permissionMode === 'bypass' })
                         : undefined,
-                    input.deepResearch ? buildDeepResearchSystemPromptFragment() : undefined,
                     input.sideConversation ? buildSideConversationSystemPromptFragment() : undefined,
                 ]);
             // Keep each turn's source revisions independent while sharing identical
@@ -320,9 +313,6 @@ export function createInteractiveRunComposerFactory(input) {
                         },
                     }
                     : {}),
-                ...(isDeepResearchSession(backendContext.header.labels) && !backendContext.tools
-                    ? { deepResearch: { tools: requireDeepResearchTools(input.deepResearchTools) } }
-                    : {}),
                 skillBudget: contextWindow === null ? {} : { contextWindow },
                 shell,
                 ...(input.resolveProfileSystemPrompt
@@ -354,7 +344,7 @@ function assertUniqueToolNames(tools) {
         names.add(tool.name);
     }
 }
-function buildDefaultHostTools(sessionTodo, inventoryFor, builtinOptions, hostTools = [], scheduledTaskTool, goalTools = [], parentAgentTools = [], plan, deepResearchTools = []) {
+function buildDefaultHostTools(sessionTodo, inventoryFor, builtinOptions, hostTools = [], scheduledTaskTool, goalTools = [], parentAgentTools = [], plan) {
     // Full access has no boundary to widen, so neither the Bash declaration nor
     // the widening tool is offered. An unknown mode is not Full access.
     const fullAccess = plan?.permissionMode === 'bypass';
@@ -390,7 +380,6 @@ function buildDefaultHostTools(sessionTodo, inventoryFor, builtinOptions, hostTo
         ...goalTools.map((tool) => tool.name),
         ...parentAgentTools.map((tool) => tool.name),
         ...planTools.map((tool) => tool.name),
-        ...deepResearchTools.map((tool) => tool.name),
     ];
     const skillHost = buildHostCapabilitiesFromBinding(toolNames);
     const shadowTracker = new SkillShadowSelectionTracker();
@@ -406,14 +395,8 @@ function buildDefaultHostTools(sessionTodo, inventoryFor, builtinOptions, hostTo
         ...goalTools,
         ...parentAgentTools,
         ...planTools,
-        ...deepResearchTools,
     ];
 }
-function requireDeepResearchTools(tools) {
-    if (!tools)
-        throw new Error('Runtime Host Deep Research tools are not composed');
-    return tools;
-}
 function filterToolGroups(groups, names) {
     const seenIds = new Set();
     return groups.flatMap((group) => {