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

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,6 +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/bootstrap-runtime-policy.js

@@ -19,70 +19,43 @@
 import { randomUUID } from 'node:crypto';
 import { readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { OPENCODE_FREE_DEFAULT_MODEL, defaultEnabledModelIdsWhenOmitted, } from '@maka/core/llm-connections';
 const JOURNAL_FILE = '.runtime-host-bootstrap.json';
-/**
- * What the seeded OpenCode Free connection starts with — the provider's own
- * declaration of the models a fresh connection to it enables, so the seed and
- * a hand-added connection cannot drift apart.
- */
-const OPENCODE_FREE_SEED_MODEL_IDS = defaultEnabledModelIdsWhenOmitted('opencode-free') ?? [];
-/** Establishes a usable first target before Runtime Host accepts clients. */
+/** Imports a user's environment credential on first start, before accepting clients. */
 export async function ensureBootstrapRuntimePolicy(input) {
     if (input.initialization)
         await initializeHostedPolicy(input.stores, input.initialization);
     const journalPath = join(input.workspaceRoot, JOURNAL_FILE);
     const resuming = await readJournal(journalPath);
     const initialCatalog = await input.stores.connectionCatalog.getSnapshot();
-    if (initialCatalog.connections.length > 0) {
-        // One atomic catalog mutation: enabled ids, static inventory, and a
-        // retarget of a system default the migration removes all land in the same
-        // document write, so no restart can observe a half-migrated row.
-        try {
-            await input.stores.connectionCatalog.migrateSystemSeed({
-                slug: 'opencode-free',
-                providerType: 'opencode-free',
-                legacyEnabledModelIds: LEGACY_OPENCODE_FREE_SEEDS,
-                enabledModelIds: OPENCODE_FREE_SEED_MODEL_IDS,
-                defaultModelId: OPENCODE_FREE_DEFAULT_MODEL,
-                retiredModelIds: retiredOpencodeFreeModelIds(),
-            });
-        }
-        catch (error) {
-            input.onDeferredError?.(error);
-        }
+    if (!resuming && initialCatalog.connections.length > 0)
+        return;
+    const seed = bootstrapSeed(input.environment ?? process.env);
+    if (!seed || initialCatalog.connections.some((connection) => connection.slug !== seed.slug)) {
+        await rm(journalPath, { force: true });
+        return;
     }
-    if (!resuming) {
-        if (initialCatalog.connections.length > 0)
-            return;
+    if (!resuming)
         await writeJournal(journalPath);
-    }
-    const seeds = bootstrapSeeds(input.environment ?? process.env);
-    const { connection: free } = await ensureConnection(input.stores, seeds[0]);
-    await setDefaultIfMissing(input.stores, free);
-    await rm(journalPath, { force: true });
+    let connection;
     try {
-        let preferred = free;
-        for (const seed of seeds.slice(1)) {
-            const ensured = await ensureConnection(input.stores, seed);
-            const connection = ensured.connection;
-            if (seed.secret) {
-                try {
-                    await ensureCredential(input.stores, connection, seed.secret);
-                }
-                catch (error) {
-                    if (ensured.created)
-                        await removeFailedBootstrapConnection(input.stores, connection);
-                    throw error;
-                }
-            }
-            preferred = connection;
+        const ensured = await ensureConnection(input.stores, seed);
+        connection = ensured.connection;
+        try {
+            await ensureCredential(input.stores, connection, seed.secret);
+        }
+        catch (error) {
+            if (ensured.created)
+                await removeFailedBootstrapConnection(input.stores, ensured.connection);
+            throw error;
         }
-        await replaceBootstrapDefault(input.stores, free, preferred);
     }
     catch (error) {
         input.onDeferredError?.(error);
+        await rm(journalPath, { force: true });
+        return;
     }
+    await setDefaultIfMissing(input.stores, connection);
+    await rm(journalPath, { force: true });
 }
 async function initializeHostedPolicy(stores, input) {
     if (input.incognito !== true ||
@@ -147,47 +120,39 @@ async function initializeHostedPolicy(stores, input) {
     if (result.kind !== 'committed')
         throw new Error('Hosted proxy initialization failed');
 }
-function bootstrapSeeds(environment) {
-    const seeds = [
-        {
-            slug: 'opencode-free',
-            name: 'OpenCode Free',
-            providerType: 'opencode-free',
-            enabledModelIds: OPENCODE_FREE_SEED_MODEL_IDS,
-        },
-    ];
+function bootstrapSeed(environment) {
     const deepseek = environment.DEEPSEEK_API_KEY?.trim();
     const anthropic = environment.ANTHROPIC_API_KEY?.trim();
     const openai = environment.OPENAI_API_KEY?.trim();
     if (deepseek) {
-        seeds.push({
+        return {
             slug: 'env-deepseek',
             name: 'DeepSeek (env)',
             providerType: 'deepseek',
             enabledModelIds: ['deepseek-v4-flash'],
             baseUrl: environment.DEEPSEEK_BASE_URL?.trim() || 'https://api.deepseek.com',
             secret: deepseek,
-        });
+        };
     }
     else if (anthropic) {
-        seeds.push({
+        return {
             slug: 'env-anthropic',
             name: 'Anthropic (env)',
             providerType: 'anthropic',
             enabledModelIds: ['claude-sonnet-4-5-20250929'],
             secret: anthropic,
-        });
+        };
     }
     else if (openai) {
-        seeds.push({
+        return {
             slug: 'env-openai',
             name: 'OpenAI (env)',
             providerType: 'openai',
             enabledModelIds: ['gpt-4o-mini'],
             secret: openai,
-        });
+        };
     }
-    return seeds;
+    return undefined;
 }
 async function ensureConnection(stores, seed) {
     for (let attempt = 0; attempt < 3; attempt += 1) {
@@ -219,24 +184,6 @@ async function ensureConnection(stores, seed) {
     }
     throw new Error(`Bootstrap Connection could not be created: ${seed.slug}`);
 }
-/**
- * Every opencode-free inventory a past release seeded, verbatim. A row still
- * equal to one of these is provably system-owned and may follow the current
- * seed; any other value is a user selection and is never touched. Every
- * release that changes the derived seed must append the previous value here,
- * or rows it planted read as user selections forever. (This exact-match
- * enumeration is deliberately lossy; the versioned seed policy discussed in
- * #3354 is the durable replacement.)
- */
-const LEGACY_OPENCODE_FREE_SEEDS = [
-    ['big-pickle'],
-    ['nemotron-3-ultra-free'],
-    ['nemotron-3-ultra-free', 'mimo-v2.5-free', 'deepseek-v4-flash-free'],
-];
-function retiredOpencodeFreeModelIds() {
-    const current = new Set(OPENCODE_FREE_SEED_MODEL_IDS);
-    return [...new Set(LEGACY_OPENCODE_FREE_SEEDS.flat())].filter((id) => !current.has(id));
-}
 async function removeFailedBootstrapConnection(stores, connection) {
     const removed = await stores.connectionCatalog.remove({
         expected: { connectionId: connection.connectionId, revision: connection.revision },
@@ -270,33 +217,13 @@ async function setDefaultIfMissing(stores, connection) {
         expectedCatalogRevision: catalog.revision,
         target: {
             connectionId: connection.connectionId,
-            modelId: OPENCODE_FREE_DEFAULT_MODEL,
+            modelId: connection.enabledModelIds[0],
         },
     });
     if (committed.kind !== 'committed') {
         throw new Error(`Bootstrap default target could not be stored: ${committed.kind}`);
     }
 }
-async function replaceBootstrapDefault(stores, free, preferred) {
-    if (preferred.connectionId === free.connectionId || !preferred.enabled)
-        return;
-    const catalog = await stores.connectionCatalog.getSnapshot();
-    const current = catalog.defaultTarget;
-    if (current !== null &&
-        (current.connectionId !== free.connectionId || current.modelId !== OPENCODE_FREE_DEFAULT_MODEL)) {
-        return;
-    }
-    const modelId = preferred.enabledModelIds[0];
-    if (!modelId)
-        return;
-    const committed = await stores.connectionCatalog.setDefaultTarget({
-        expectedCatalogRevision: catalog.revision,
-        target: { connectionId: preferred.connectionId, modelId },
-    });
-    if (committed.kind !== 'committed') {
-        throw new Error(`Bootstrap preferred target could not be stored: ${committed.kind}`);
-    }
-}
 async function readJournal(path) {
     let contents;
     try {

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 {
@@ -1484,7 +1472,6 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         const interactiveTurns = new HostInteractiveTurnCoordinator({
             executions: coordinator,
             turns: stores.agentRunStore,
-            runtime: manager,
         });
         // Compile-time guarantee that the three Turn coordinators together cover
         // every key in TURN_OPERATION_SPECS. Domain composition seeds all domain
@@ -1500,7 +1487,6 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             ? new SessionTurnAccessRequestCoordinator({
                 authority: context.sessionAccessAuthority,
                 startTurn: interactiveTurns.handlers['turn.start'],
-                regenerateTurn: interactiveTurns.handlers['turn.regenerate'],
                 hostEpoch: context.hostEpoch,
                 acquireResidency: () => context.acquireResidency('collaboration-turn-request'),
                 requestDrain: context.requestDrain,
@@ -2033,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)) {
@@ -2152,6 +2137,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     oauth.handlers,
                     externalAgentSetup.handlers,
                     webSearch.handlers,
+                    recall.handlers,
                     networkProxy.handlers,
                     configuration.handlers,
                 ],
@@ -2224,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],
@@ -2648,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) => {

package/node_modules/@maka/runtime-host/dist/server/interactive-turn-coordinator.js

@@ -26,19 +26,16 @@ const EMPTY_SKILL_INVOCATION = {
     failed: [],
     receipts: [],
 };
-/** Owns Interactive Turn start and regenerate wire semantics. */
+/** Owns Interactive Turn start wire semantics. */
 export class HostInteractiveTurnCoordinator {
     handlers = {
         'turn.start': (input, context) => this.#start(input, context),
-        'turn.regenerate': (input, context) => this.#regenerate(input, context),
     };
     #executions;
     #turns;
-    #runtime;
     constructor(options) {
         this.#executions = options.executions;
         this.#turns = options.turns;
-        this.#runtime = options.runtime;
     }
     async #start(input, context) {
         const content = normalizeMessageContent(input.content);
@@ -128,18 +125,6 @@ export class HostInteractiveTurnCoordinator {
             },
         };
     }
-    #regenerate(input, context) {
-        if (input.sourceTurnId === input.turnId) {
-            return Promise.resolve(operationConflict('Regenerate source and target Turn identities must differ'));
-        }
-        return this.#executions.startInteractiveRootMessage({
-            sessionId: input.sessionId,
-            turnId: input.turnId,
-            execution: { kind: 'regenerate', sourceTurnId: input.sourceTurnId },
-            archivedMessage: 'Cannot regenerate a Turn in an archived Session',
-            prepareContent: async () => (await this.#runtime.prepareRegenerateTurn(input.sessionId, input.sourceTurnId)).content,
-        }, context);
-    }
 }
 function rejected(message) {
     return { kind: 'rejected', outcome: operationConflict(message) };