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

package/dist/runtime-host-service-manager.js

@@ -27,7 +27,7 @@ import { truncateUtf8 } from '@maka/core/diagnostic-log';
 import { canonicalProjectDirectoryRootSpec, isCanonicalRuntimeHostWebSocketPath, PROJECT_DIRECTORY_MAX_ROOTS, projectDirectoryRootSpecValid, RUNTIME_HOST_PROTOCOL_VERSION, } from '@maka/runtime-host/protocol';
 import { connectExistingRuntimeHost, prepareConnectedRuntimeHostRetirement, } from '@maka/runtime-host/client';
 import { resolveRuntimeHostManagedServiceId, RUNTIME_HOST_SERVICE_LOG_MAX_BYTES, } from '@maka/runtime-host/operator';
-import { withLegacyFileUpdateLockLease, withProcessLifetimeFileUpdateLock, } from '@maka/storage/process-lifetime-file-update-lock';
+import { withProcessLifetimeFileUpdateLock } from '@maka/storage/process-lifetime-file-update-lock';
 import { discoverMarkedStorageRoot, resolveExistingStorageRoot, tryAcquireInteractiveRootOwner, } from '@maka/storage/root-authority';
 import { isRuntimeHostManagedDeploymentCli, removeRuntimeHostManagedDeployment, resolveExistingRuntimeHostManagedDeploymentRoot, resolveRuntimeHostManagedDeploymentForCli, resolveRuntimeHostManagedDeploymentRoot, } from './runtime-host-managed-deployment.js';
 import { writeRuntimeHostManagedUpdatePolicy } from './runtime-host-update-policy-store.js';
@@ -79,11 +79,6 @@ export async function withRuntimeHostManagedServiceDeploymentLock(clientDataRoot
     await mkdir(clientDataRoot, { recursive: true, mode: 0o700 });
     return withProcessLifetimeFileUpdateLock(join(clientDataRoot, SERVICE_DEPLOYMENT_LOCK_FILE), operation, timeoutMs);
 }
-export async function withRuntimeHostManagedServiceLegacyOperatorLeases(clientDataRoot, operation, timeoutMs = SERVICE_OPERATION_LOCK_TIMEOUT_MS) {
-    const configPath = resolveRuntimeHostManagedServiceConfigPath(clientDataRoot);
-    await mkdir(dirname(configPath), { recursive: true, mode: 0o700 });
-    return withLegacyFileUpdateLockLease(join(clientDataRoot, SERVICE_LIFECYCLE_LOCK_FILE), (lifecycleFd) => withLegacyFileUpdateLockLease(configPath, (configFd) => operation([lifecycleFd, configFd]), timeoutMs), timeoutMs);
-}
 export async function replaceRuntimeHostManagedService(input, backend, overrides = {}) {
     const deps = runtimeHostServiceManagerDeps(overrides);
     const configPath = resolveRuntimeHostManagedServiceConfigPath(input.clientDataRoot);

package/dist/runtime-host-update-command.js

@@ -22,7 +22,7 @@ import { truncateUtf8 } from '@maka/core/diagnostic-log';
 import { activateRuntimeHostManagedDeployment } from '@maka/runtime-host/client';
 import { compareProductReleaseVersions, createRuntimeHostLegacyPosixOperatorCommand, decodeRuntimeHostServiceManagementFrame, encodeRuntimeHostServiceManagementFrame, RUNTIME_HOST_SERVICE_ERROR_CODE_MAX_BYTES, RUNTIME_HOST_SERVICE_ERROR_MESSAGE_MAX_BYTES, RUNTIME_HOST_OPERATOR_ACCESS_MANAGEMENT_CAPABILITY, RUNTIME_HOST_OPERATOR_CAPABILITY_REQUEST_ENV, RUNTIME_HOST_OPERATOR_PROCESS_LIFETIME_LOCK_CAPABILITY, runtimeHostOperatorInvocation, RuntimeHostManagedDeploymentError as RuntimeHostDeploymentAuthorityError, } from '@maka/runtime-host/operator';
 import { isRuntimeHostDevelopmentPackageVersion, assertRuntimeHostManagedOperatorConfig, assertRuntimeHostManagedOperatorDeployment, convergeRuntimeHostManagedOperator, verifyRuntimeHostManagedOperator, openRuntimeHostManagedPackageDeployment, prepareRuntimeHostManagedPackageDeployment, pruneRuntimeHostManagedPackages, resolveRuntimeHostManagedControlRoot, resolveRuntimeHostManagedPackageCliPath, RuntimeHostManagedDeploymentError, } from './runtime-host-managed-deployment.js';
-import { runtimeHostManagedServiceConfigFingerprint, manageRuntimeHostService, replaceRuntimeHostManagedService, resolveRuntimeHostManagedServiceId, RuntimeHostServiceManagerError, verifyRuntimeHostManagedServiceReady, withRuntimeHostManagedServiceDeploymentLock, withRuntimeHostManagedServiceLegacyOperatorLeases, withRuntimeHostManagedServiceLifecycleLock, } from './runtime-host-service-manager.js';
+import { runtimeHostManagedServiceConfigFingerprint, manageRuntimeHostService, replaceRuntimeHostManagedService, resolveRuntimeHostManagedServiceId, RuntimeHostServiceManagerError, verifyRuntimeHostManagedServiceReady, withRuntimeHostManagedServiceDeploymentLock, withRuntimeHostManagedServiceLifecycleLock, } from './runtime-host-service-manager.js';
 import { createPlatformRuntimeHostServiceBackend, resolveRuntimeHostLifecycleProvider, runtimeHostServiceSummary, } from './runtime-host-service-management-command.js';
 import { resolveManagedRuntimeHostUpdateSelection, RuntimeHostUpdateDiscoveryError, } from './runtime-host-update-discovery.js';
 import { RuntimeHostUpdatePackageError, withRuntimeHostRegistryUpdatePackage, } from './runtime-host-update-package.js';
@@ -60,7 +60,6 @@ export async function runManagedRuntimeHostUpdateCli(options, overrides = {}, fr
         }),
         withLifecycleLock: withRuntimeHostManagedServiceLifecycleLock,
         withDeploymentLock: withRuntimeHostManagedServiceDeploymentLock,
-        withLegacyOperatorLeases: withRuntimeHostManagedServiceLegacyOperatorLeases,
         createBackend: createPlatformRuntimeHostServiceBackend,
         verifyReady: verifyRuntimeHostManagedServiceReady,
         runOperator: runManagedRuntimeHostOperator,
@@ -170,19 +169,48 @@ export async function runManagedRuntimeHostUpdateCli(options, overrides = {}, fr
                     }
                 }
                 const currentOperator = createRuntimeHostLegacyPosixOperatorCommand(join(serviceConfig.managedDeploymentRoot, 'operator'));
-                let currentOperatorUsesProcessLifetimeLock = false;
                 let currentOperatorUnavailable = false;
                 if (status.service.active) {
+                    let probeSupportsLifetimeLock = false;
                     try {
-                        currentOperatorUsesProcessLifetimeLock = operatorUsesProcessLifetimeLock(await deps.runOperator(currentOperator, ['status', '--framed', ...expectedTargetArgs(options.expectedTarget)], {
+                        const probe = await deps.runOperator(currentOperator, ['status', '--framed', ...expectedTargetArgs(options.expectedTarget)], {
                             capabilityRequest: RUNTIME_HOST_OPERATOR_PROCESS_LIFETIME_LOCK_CAPABILITY,
-                        }));
+                        });
+                        if (probe.kind === 'error') {
+                            throw new RuntimeHostServiceManagerError('service_manager_operation_failed', `The current Runtime Host operator could not report its status: ${probe.error.message}`);
+                        }
+                        if (probe.action !== 'status') {
+                            throw new Error('The current Runtime Host operator returned an invalid status result');
+                        }
+                        probeSupportsLifetimeLock =
+                            probe.operatorCapabilities?.includes(RUNTIME_HOST_OPERATOR_PROCESS_LIFETIME_LOCK_CAPABILITY) ?? false;
                     }
                     catch (error) {
                         if (!activeTargetNeedsRepair)
                             throw error;
                         currentOperatorUnavailable = true;
                     }
+                    // An operator that answered but cannot echo the requested
+                    // capability predates the lifetime-lock protocol; retiring it would
+                    // race unmanaged service state, so it must be removed before
+                    // updating. This verdict is not a probe failure: it must refuse
+                    // even when the target needs repair (where the catch above would
+                    // degrade it to an unavailable operator), and nothing has been
+                    // mutated yet — emitting directly keeps the instruction visible
+                    // instead of folding it into the post-mutation "update_incomplete"
+                    // remap.
+                    if (!currentOperatorUnavailable && !probeSupportsLifetimeLock) {
+                        emit({
+                            schemaVersion: 1,
+                            kind: 'error',
+                            action: 'update',
+                            error: {
+                                code: 'service_manager_operation_failed',
+                                message: 'The active Runtime Host operator predates capability reporting and cannot be safely retired; uninstall it before updating',
+                            },
+                        });
+                        return 1;
+                    }
                 }
                 emit(progress('staging', currentVersion, options.version));
                 deployment = await deps.withLifecycleLock(options.clientDataRoot, () => targetDeploymentIsCurrent
@@ -212,11 +240,6 @@ export async function runManagedRuntimeHostUpdateCli(options, overrides = {}, fr
                 }
                 if (status.service.active) {
                     emit(progress('retiring', currentVersion, options.version));
-                    const runCurrentOperator = (args) => currentOperatorUsesProcessLifetimeLock
-                        ? deps.runOperator(currentOperator, args)
-                        : deps.withLegacyOperatorLeases(options.clientDataRoot, (inheritedFds) => deps.runOperator(currentOperator, args, {
-                            inheritedFds,
-                        }));
                     let retirement = currentOperatorUnavailable
                         ? {
                             schemaVersion: 1,
@@ -227,7 +250,7 @@ export async function runManagedRuntimeHostUpdateCli(options, overrides = {}, fr
                                 message: 'The active Runtime Host operator is unavailable',
                             },
                         }
-                        : await runCurrentOperator([
+                        : await deps.runOperator(currentOperator, [
                             'retire',
                             '--framed',
                             ...expectedTargetArgs(options.expectedTarget),
@@ -772,16 +795,6 @@ function activeTasksRetirementFrame(status) {
         retirement: { kind: 'active_tasks' },
     };
 }
-function operatorUsesProcessLifetimeLock(frame) {
-    if (frame.kind === 'error') {
-        throw new RuntimeHostServiceManagerError('service_manager_operation_failed', `The current Runtime Host operator could not report its lock protocol: ${frame.error.message}`);
-    }
-    if (frame.action !== 'status') {
-        throw new Error('The current Runtime Host operator returned an invalid capability result');
-    }
-    return (frame.operatorCapabilities?.includes(RUNTIME_HOST_OPERATOR_PROCESS_LIFETIME_LOCK_CAPABILITY) ===
-        true);
-}
 function operatorCapabilities() {
     return process.env[RUNTIME_HOST_OPERATOR_CAPABILITY_REQUEST_ENV] ===
         RUNTIME_HOST_OPERATOR_ACCESS_MANAGEMENT_CAPABILITY
@@ -790,21 +803,20 @@ function operatorCapabilities() {
         }
         : {};
 }
-async function runManagedRuntimeHostOperator(operator, args, invocation = {}) {
+async function runManagedRuntimeHostOperator(operator, args, invocation) {
     return new Promise((resolve, reject) => {
-        const inheritedFds = invocation.inheritedFds ?? [];
         const command = runtimeHostOperatorInvocation(operator, args);
         const child = spawn(command.executable, [...command.args], {
-            // A detached legacy operator keeps the inherited advisory leases alive if
-            // this updater is interrupted, so an exact retry never steals active work.
+            // A detached operator can finish a retirement already in progress even
+            // if this updater exits, so an exact retry never steals active work.
             detached: process.platform !== 'win32',
-            env: invocation.capabilityRequest
+            env: invocation?.capabilityRequest
                 ? {
                     ...process.env,
                     [RUNTIME_HOST_OPERATOR_CAPABILITY_REQUEST_ENV]: invocation.capabilityRequest,
                 }
                 : process.env,
-            stdio: ['ignore', 'pipe', 'pipe', ...inheritedFds],
+            stdio: ['ignore', 'pipe', 'pipe'],
             windowsHide: true,
         });
         if (!child.stdout || !child.stderr) {

package/node_modules/@maka/core/dist/artifacts.js

@@ -85,6 +85,7 @@ const ARTIFACT_SOURCE_POLICIES = {
     tool_result_projection: { userDeletable: false, userVisible: false, sharedReadable: true },
     tool_result_archive: { userDeletable: false, userVisible: false, sharedReadable: false },
     subagent_writeback: { userDeletable: false, userVisible: true, sharedReadable: false },
+    // Kept so reports saved before Deep Research retirement remain readable.
     deep_research: { userDeletable: false, userVisible: true, sharedReadable: false },
     user_upload: { userDeletable: true, userVisible: false, sharedReadable: true },
     session_effect: { userDeletable: false, userVisible: false, sharedReadable: false },

package/node_modules/@maka/core/dist/model-metadata.js

@@ -413,9 +413,8 @@ function buildStaticModelMetadata(active) {
     return {
         anthropic: ANTHROPIC_MODEL_OVERRIDES,
         'claude-subscription': claudeSubscriptionModelMetadata(active),
-        // Both Command Code providers ride the same Provider-API effort table.
+        // The Command Code Provider-API plan rides the same effort table.
         commandcode: COMMAND_CODE_MODEL_METADATA,
-        'commandcode-go': COMMAND_CODE_MODEL_METADATA,
         'alibaba-token-plan-cn': {
             'qwen3.8-max': {
                 thinkingOptions: { efforts: ['none', 'low', 'medium', 'xhigh'], toggle: true },

package/node_modules/@maka/core/dist/provider-auth.js

@@ -22,12 +22,7 @@ import { providerAuthRequiresSecret, providerDefaultsOf, providerSupportsModelDi
  * storage coordinator actually gates — an operation with no admission point
  * does not belong here, however natural it sounds beside these three.
  */
-export const PROVIDER_AUTH_ACTIONS = [
-    'test_credentials',
-    'fetch_models',
-    'read_usage',
-    'start_oauth',
-];
+export const PROVIDER_AUTH_ACTIONS = ['test_credentials', 'fetch_models', 'start_oauth'];
 /**
  * Which credential operations a connection may run. This is an admission
  * answer, not a UI state: the storage layer refuses an unavailable action, so a
@@ -74,7 +69,6 @@ export function deriveProviderAuthContract(input) {
             fetch_models: canFetchModels && (reachableWithoutSecret || hasSecret),
             // Reading account usage needs the same reachability as a connection test:
             // a credential the provider accepts over HTTP.
-            read_usage: reachableWithoutSecret || hasSecret,
         }),
     };
 }

package/node_modules/@maka/core/dist/provider-registry.js

@@ -1220,20 +1220,26 @@ const providerRegistry = {
         signupUrl: 'https://commandcode.ai/docs/plans/goat',
         catalogOrder: 41.5,
     },
+    // Retired rather than removed: an existing connection must stay identifiable
+    // and must answer `provider_retired` at readiness. Removing the entry would
+    // leave it *unknown*, which `isConnectionReady` does not reject, so a send
+    // would be admitted and only fail deep in model construction. Its transport
+    // presented the official CLI's identity to a private endpoint, which is why
+    // nothing can send through it any more.
     'commandcode-go': {
         label: 'Command Code GO',
-        // The API root, not `/provider/v1`: generation posts to `/alpha/generate`
-        // and discovery reads `/provider/v1/models`, both under it.
         baseUrl: 'https://api.commandcode.ai',
         authKind: 'api_key',
         fallbackModels: [],
-        status: 'ready',
-        runtimeAdapter: { kind: 'commandcode-cli' },
-        modelDiscovery: { kind: 'protocol', path: 'provider/v1/models' },
+        status: 'phase3-experimental',
+        runtimeAdapter: { kind: 'unavailable' },
+        retired: true,
+        modelDiscovery: {
+            kind: 'fallback',
+            reason: 'The GO plan was reached through the official CLI\u2019s private transport.',
+        },
         category: 'overseas',
         catalogGroup: 'plans',
-        signupUrl: 'https://commandcode.ai/docs/plans/go',
-        catalogOrder: 41.6,
     },
     'cloudflare-workers-ai': {
         label: cloudflareWorkersAi.name,

package/node_modules/@maka/core/dist/recall.js

@@ -59,7 +59,7 @@ import { validateWorkspacePrivacyContext } from './incognito.js';
 import { redactSecrets } from './redaction.js';
 import { SEARCH_QUERY_MAX_CHARS } from './search.js';
 import { collapseSessionRevisions } from './session-revisions.js';
-import { foldForMatch, MAX_SESSIONS_SCANNED, threadSearchMatchKind } from './thread-search.js';
+import { foldForMatch, MAX_SESSIONS_SCANNED, threadSearchMatchKind } from './transcript-search.js';
 /** Okapi BM25 term-frequency saturation, Lucene's default. */
 export const RECALL_BM25_K1 = 1.2;
 /** Okapi BM25 length normalization, Lucene's default. */
@@ -960,6 +960,10 @@ function buildPassage(anchor, transcript, session, budget, activeSessionId, span
         sessionTitle: redactSecrets(session?.name ?? ''),
         ...(anchor.turnId ? { turnId: anchor.turnId } : {}),
         anchorMessageId: anchor.message.id,
+        // The anchor's position in the transcript this passage was built from.
+        // `anchorIndex` is already `findIndex` over that exact array, so this is
+        // the same coordinate the transcript reader addresses.
+        sequence: anchorIndex,
         messages,
         matchedTerms: anchor.matchedTerms,
         score: Number(anchor.score.toFixed(4)),

package/node_modules/@maka/core/dist/session-start-mode.js

@@ -17,11 +17,6 @@
  * under the License.
  */
 export const SESSION_START_MODE_SPECS = {
-    deep_research: {
-        name: 'Deep Research',
-        labels: ['mode:deep_research'],
-        permissionMode: 'explore',
-    },
     bot: {
         labels: ['mode:bot'],
         permissionMode: 'explore',
@@ -29,6 +24,8 @@ export const SESSION_START_MODE_SPECS = {
 };
 export const SESSION_START_MODES = Object.keys(SESSION_START_MODE_SPECS);
 export const SESSION_START_MODE_LABELS = [
+    // Historical mode labels remain reserved when editing old Sessions.
+    'mode:deep_research',
     ...new Set(Object.values(SESSION_START_MODE_SPECS).flatMap((spec) => spec.labels)),
 ];
 export function isSessionStartMode(value) {

package/node_modules/@maka/core/dist/session.js

@@ -27,7 +27,6 @@ import { isTokenUsageFields } from './usage-record-schema.js';
 import { decodeCanonicalToolResultContent, decodePersistedToolResultContent, } from './tool-result-record-schema.js';
 import { markPersisted } from './persisted-value.js';
 import { decodeTurnOrigin } from './turn-origin.js';
-export { DEEP_RESEARCH_SESSION_LABEL, isDeepResearchSession } from './deep-research.js';
 /** Runtime execution states. Archive visibility is represented by `isArchived`. */
 export const SESSION_STATUSES = [
     'active',

package/node_modules/@maka/core/dist/settings.js

@@ -27,6 +27,23 @@ import { normalizeSubagentSettings } from './subagent-settings.js';
 import { isPetPackId } from './pet.js';
 export { UI_LOCALE_PREFERENCES, isUiLocalePreference } from './ui-locale.js';
 export { BOT_DELIVERY_PROVIDERS, BOT_PROVIDERS, BOT_READINESS_STATES, MAX_ALLOWED_USER_IDS, createDefaultBotChannel, hasBotChannelCredentials, isBotDeliveryProvider, isBotReadinessState, normalizeAllowedUserIds, parseAllowedUserIdsFromText, } from './bot-chat-settings.js';
+export const USAGE_SCREEN_SEARCH_MAX_BYTES = 1024;
+const USAGE_SCREEN_UTF8 = new TextEncoder();
+/** Shared domain for the Usage screen's free-text query at every boundary. */
+export function isUsageScreenSearch(value) {
+    return (typeof value === 'string' &&
+        USAGE_SCREEN_UTF8.encode(value).byteLength <= USAGE_SCREEN_SEARCH_MAX_BYTES);
+}
+/**
+ * Persisted Usage timestamps may retain sub-millisecond precision. Keep them
+ * JSON/SQLite round-trip safe so a stored value can also name a continuation.
+ */
+export function isUsageTimestamp(value) {
+    return (typeof value === 'number' &&
+        Number.isFinite(value) &&
+        value >= 0 &&
+        value <= Number.MAX_SAFE_INTEGER);
+}
 export const SETTINGS_SECTIONS = [
     'general',
     'appearance',

package/node_modules/@maka/core/dist/tool-quiet-preview.js

@@ -217,13 +217,6 @@ export function formatToolInvocationLine(item, locale) {
             parts.push(`${cols}x${rows}`);
         return parts.join(' · ');
     }
-    if (name === 'deep_research_start') {
-        const objective = stringField(args, 'objective');
-        if (objective) {
-            const scopeLevel = stringField(args, 'scope_level');
-            return redactSecrets(scopeLevel ? `${objective} (${scopeLevel})` : objective);
-        }
-    }
     if (name === 'GoalSet') {
         const condition = stringField(args, 'condition');
         if (condition)
@@ -304,10 +297,6 @@ const ARGS_PREVIEW_SCALAR_KEYS = [
     'id',
     'ref',
 ];
-// This tool's objective is the compact row's durable headline. Keep it
-// explicit rather than widening the generic wire allowlist with a broad key
-// such as `input`: non-WriteStdin tools otherwise retain arbitrary payloads.
-const DEEP_RESEARCH_START_PREVIEW_SCALAR_KEYS = ['objective', 'scope_level'];
 const ARGS_PREVIEW_NUMBER_KEYS = ['offset', 'limit'];
 function boundPreviewString(value) {
     const redacted = redactSecrets(value);
@@ -387,11 +376,8 @@ export function projectToolArgsPreview(toolName, args) {
     // Apply the canonical activity projection first so WriteStdin's inputPreview
     // shape (bounded, display-safe) is what the whitelist picks up.
     const projected = asRecord(projectToolActivityArgs(toolName, args)) ?? record;
-    const scalarKeys = toolName === 'deep_research_start'
-        ? [...ARGS_PREVIEW_SCALAR_KEYS, ...DEEP_RESEARCH_START_PREVIEW_SCALAR_KEYS]
-        : ARGS_PREVIEW_SCALAR_KEYS;
     const picked = new Map();
-    for (const key of scalarKeys) {
+    for (const key of ARGS_PREVIEW_SCALAR_KEYS) {
         if (isSensitiveKey(key))
             continue;
         const value = previewStringField(projected, key);
@@ -429,7 +415,7 @@ export function projectToolArgsPreview(toolName, args) {
     // Enforce the whole-preview budget by dropping lowest-priority fields; the
     // first picked (highest-priority) field always survives.
     const keysByPriority = [
-        ...scalarKeys,
+        ...ARGS_PREVIEW_SCALAR_KEYS,
         ...ARGS_PREVIEW_NUMBER_KEYS,
         'inputPreview',
         'size',

package/node_modules/@maka/core/dist/transcript-search.js

@@ -0,0 +1,46 @@
+/*
+ * 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.
+ */
+/** Max sessions scanned per query (newest first by lastMessageAt). */
+export const MAX_SESSIONS_SCANNED = 200;
+/**
+ * NFC + lowercase canonicalization for substring match. NOT a security
+ * boundary — purely for case-insensitive + composed-form matching.
+ */
+export function foldForMatch(value) {
+    return value.normalize('NFC').toLowerCase();
+}
+/** Stable result classification shared by Desktop navigation and Agent tools. */
+export function threadSearchMatchKind(message) {
+    switch (message.type) {
+        case 'user':
+            return 'user_message';
+        case 'assistant':
+            return 'assistant_message';
+        case 'tool_call':
+            return 'tool_intent';
+        case 'tool_result':
+            return 'tool_result';
+        case 'permission_decision':
+        case 'token_usage':
+        case 'turn_state':
+        case 'workhub_coordination':
+        case 'system_note':
+            throw new Error(`Message type ${message.type} is not searchable`);
+    }
+}

package/node_modules/@maka/core/package.json

@@ -82,11 +82,8 @@
     "./agent-graph-supervisor-wake": "./dist/agent-graph-supervisor-wake.js",
     "./session-todo": "./dist/session-todo.js",
     "./external-session": "./dist/external-session.js",
-    "./deep-research-run": "./dist/deep-research-run.js",
-    "./deep-research-client-progress": "./dist/deep-research-client-progress.js",
     "./daily-review": "./dist/daily-review.js",
     "./work-board": "./dist/work-board.js",
-    "./deep-research": "./dist/deep-research.js",
     "./session-start-mode": "./dist/session-start-mode.js",
     "./long-term-memory": "./dist/long-term-memory.js",
     "./local-memory": "./dist/local-memory.js",
@@ -128,7 +125,7 @@
     "./session-send-projection": "./dist/session-send-projection.js",
     "./session-name": "./dist/session-name.js",
     "./recall": "./dist/recall.js",
-    "./thread-search": "./dist/thread-search.js",
+    "./transcript-search": "./dist/transcript-search.js",
     "./agent-graph-timeline": "./dist/agent-graph-timeline.js",
     "./agent-swarm": "./dist/agent-swarm.js",
     "./bot-chat-settings": "./dist/bot-chat-settings.js",

package/node_modules/@maka/runtime/dist/model-factory.js

@@ -33,7 +33,6 @@ import { openResponsesUrl } from './provider-urls.js';
 import { createOpenResponsesCompatibilityFinalizer } from './open-responses-compatibility.js';
 import { resolveModelRuntime, runtimeProviderName, } from './model-runtime.js';
 import { openAiCodexHeaders } from './subscription-auth.js';
-import { CommandCodeCliLanguageModel } from './commandcode-cli-language-model.js';
 import { createRequestCustomizationFetch } from './request-customization-fetch.js';
 import { createStreamUsageFallbackFetch } from './stream-usage-fallback-fetch.js';
 import { withOpenCodeSessionHeader } from './opencode-session-header.js';
@@ -112,13 +111,6 @@ export function getAIModel(input) {
             }).chat(modelId);
         case 'cohere':
             return createCohere({ apiKey, baseURL, fetch: requestFetch })(modelId);
-        case 'commandcode-cli':
-            return new CommandCodeCliLanguageModel({
-                modelId,
-                apiKey,
-                apiBase: baseURL,
-                fetch: requestFetch,
-            });
         case 'openai-compatible': {
             if (adapter.requireBaseUrl && !baseURL) {
                 throw new Error(`${connection.providerType} connection ${connection.slug} requires a base URL`);
@@ -653,14 +645,6 @@ function buildFamilyWire(connection, modelId, level, thinkingOptions, requestedL
                     ? { thinking: { type: 'disabled' } }
                     : {},
             };
-        case 'commandcode-cli':
-            // The CLI wire takes `reasoning_effort` as the CLI's own effort words.
-            // `max` is one of them (claude-fable-5-1, moonshotai/Kimi-K3, …), so the
-            // chosen level is forwarded verbatim — rounding it down would silently
-            // send a weaker request than the user asked for.
-            return level === undefined || level === 'off'
-                ? {}
-                : { 'commandcode-cli': { reasoningEffort: level } };
         default:
             return {};
     }

package/node_modules/@maka/runtime/dist/model-fetcher.js

@@ -103,10 +103,7 @@ async function fetchProviderModelsStrict(connection, apiKey, fetchFn) {
             return filterDiscoveredModels(models, discovery.filter);
         }
         case 'openai':
-        case 'openai-compatible':
-        // The CLI transport lists models through the Provider API's `/models`,
-        // which every plan may read.
-        case 'commandcode-cli': {
+        case 'openai-compatible': {
             const r = await fetchForConnectionEffect(fetchFn, modelListUrl(baseUrl, discovery.path, discovery.query), {
                 headers: {
                     'content-type': 'application/json',

package/node_modules/@maka/runtime/dist/model-runtime.js

@@ -114,14 +114,6 @@ function adapterCalls(adapter) {
             return [{ adapter, wire: 'google-generate', reasoningReplay: { kind: 'none' } }];
         case 'cohere':
             return [{ adapter, wire: 'cohere-v2', reasoningReplay: { kind: 'none' } }];
-        case 'commandcode-cli':
-            return [
-                {
-                    adapter,
-                    wire: 'commandcode-cli',
-                    reasoningReplay: { kind: 'openai-chat-plaintext', requestField: 'reasoning' },
-                },
-            ];
         case 'openai-codex':
             return [
                 {

package/node_modules/@maka/runtime/dist/recall-tools.js

@@ -230,6 +230,10 @@ function projectPassage(passage, activeSessionId) {
         title: passage.sessionTitle,
         ...(passage.turnId ? { turn_id: passage.turnId } : {}),
         anchor_message_id: passage.anchorMessageId,
+        // The anchor's index in its Session transcript. Carried for the same
+        // reason a UI needs it: a caller that wants to point at the passage in a
+        // transcript scrolls by sequence, and this spares it a second lookup.
+        sequence: passage.sequence,
         is_current_session: passage.sessionId === activeSessionId,
         ...(passage.lastMessageAt !== undefined ? { last_message_at: passage.lastMessageAt } : {}),
         matched_terms: passage.matchedTerms,

package/node_modules/@maka/runtime/dist/session-manager.js

@@ -25,7 +25,6 @@ import { isCanonicalReadOnlyPermissionProfile } from '@maka/core/permission-prof
 import { DEFAULT_TOOL_MODE } from '@maka/core/tool-mode';
 import { PLAN_USER_ABANDON_REASON, PLAN_USER_CANCEL_REASON, PlanConflictError, activePlanExecution, } from '@maka/core/plan';
 import { DEFAULT_SESSION_NAME } from '@maka/core/session-name';
-import { DEEP_RESEARCH_SESSION_LABEL, isDeepResearchSession } from '@maka/core/deep-research';
 import { SUBAGENT_SESSION_RUNTIME_SCHEMA_VERSION, SUBAGENT_SESSION_SPAWN_SCHEMA_VERSION, childSessionsForParent, subagentSessionRuntimeSummary, } from '@maka/core/session';
 import { decodeAgentGraphIntentClaim } from '@maka/core/agent-graph-control';
 import { executionBoundaryContains } from '@maka/core/sandbox-boundary';
@@ -347,11 +346,7 @@ export class SessionManager {
                 throw new SessionConfigurationTransitionError('session_busy', 'Session has a pending Interaction');
             }
             await this.assertCollaborationTransition(current.header, input.configuration.collaborationMode);
-            const leavingDeepResearch = isDeepResearchSession(current.header.labels) &&
-                input.configuration.permissionMode !== 'explore';
-            const labels = leavingDeepResearch
-                ? current.header.labels.filter((label) => label !== DEEP_RESEARCH_SESSION_LABEL)
-                : current.header.labels;
+            const labels = current.header.labels;
             return () => store.updateSessionConfiguration(sessionId, {
                 expectedVersion: input.expectedRevision,
                 configuration: {
@@ -705,15 +700,11 @@ export class SessionManager {
     async setPermissionModeWithLegacyStore(sessionId, mode) {
         const previous = await this.deps.store.readHeader(sessionId);
         const boundary = await this.deps.store.readExecutionBoundary(sessionId);
-        const leavingDeepResearch = isDeepResearchSession(previous.labels) && mode !== 'explore';
         if (previous.permissionMode === mode &&
-            executionBoundaryMatchesPermissionMode(boundary, mode) &&
-            !leavingDeepResearch) {
+            executionBoundaryMatchesPermissionMode(boundary, mode)) {
             return headerToSummary(previous);
         }
-        const labels = leavingDeepResearch
-            ? previous.labels.filter((label) => label !== DEEP_RESEARCH_SESSION_LABEL)
-            : previous.labels;
+        const labels = previous.labels;
         const kind = mode === 'bypass' ? 'bypass' : 'managed';
         await this.commitExecutionBoundaryTransition(sessionId, boundary, mode, async () => {
             const current = await this.deps.store.readHeader(sessionId);
@@ -1455,7 +1446,7 @@ export class SessionManager {
         }
         const resolvedPreset = await this.deps.subagentCatalog.resolve(input.subagentId);
         if (resolvedPreset.profile !== input.agentProfile) {
-            throw new Error(`Subagent preset "${input.subagentId}" profile changed during spawn`);
+            throw new Error(`Subagent preset "${input.subagentId}" profile changed during spawn. Retry the same agent_spawn call.`);
         }
         return { ...input, resolvedPreset };
     }