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

package/node_modules/@maka/runtime-host/dist/client/session-subscription.js

@@ -28,6 +28,18 @@ export class RuntimeHostSubscriptionError extends Error {
         this.name = 'RuntimeHostSubscriptionError';
     }
 }
+export class SessionRemovedSubscriptionError extends Error {
+    name = 'SessionRemovedSubscriptionError';
+}
+export function subscriptionClosedError(reason) {
+    if (reason === 'session_removed') {
+        return new SessionRemovedSubscriptionError('Runtime Host Session was removed while it was observed');
+    }
+    if (reason === 'access_revoked') {
+        return new SessionRemovedSubscriptionError('Access to the shared Runtime Host Session was revoked');
+    }
+    return new RuntimeHostSubscriptionError('slow_consumer', 'Runtime Host Session subscription closed for a slow consumer');
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -42,6 +54,16 @@ export class ClientSessionSubscription {
     #readyTask;
     #readTranscriptPage;
     #expectedSessionId;
+    get transcriptWatermark() {
+        return this.#latestTranscriptThroughSequence;
+    }
+    get deathCause() {
+        // #closedReason is recorded at accept()-time, before #terminalError can
+        // exist — it is always the authoritative death statement.
+        return this.#closedReason === undefined
+            ? this.#terminalError
+            : subscriptionClosedError(this.#closedReason);
+    }
     #queue = [];
     #ptyListeners = new Set();
     #sessionDomainListeners = new Set();
@@ -50,6 +72,7 @@ export class ClientSessionSubscription {
     #latestProjectionRevision;
     #waiting;
     #terminalError;
+    #closedReason;
     #done = false;
     #doneAfterQueue = false;
     #closing = false;
@@ -237,7 +260,9 @@ export class ClientSessionSubscription {
         }
     }
     #assertTranscriptReadable() {
-        if (this.#closing || this.#done || this.#terminalError) {
+        if (this.#terminalError)
+            throw this.#terminalError;
+        if (this.#closing || this.#done) {
             throw new RuntimeHostSubscriptionError('connection_closed', 'Session subscription closed during transcript loading');
         }
     }
@@ -318,9 +343,14 @@ export class ClientSessionSubscription {
                 }
             }
         }
-        this.#offer(frame);
-        if (frame.kind === 'subscription.closed')
+        if (frame.kind === 'subscription.closed') {
+            // Record the reason before the offer: a full client queue makes #offer
+            // throw 'slow_consumer', which would otherwise discard the real reason
+            // the Host gave for closing this subscription.
+            this.#closedReason = frame.reason;
             this.#doneAfterQueue = true;
+        }
+        this.#offer(frame);
     }
     finish() {
         this.#ptyListeners.clear();

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

@@ -29,13 +29,6 @@ const EFFECT_ERRORS = [
     'persistence_failed',
     'commit_outcome_unknown',
 ];
-/**
- * Upper bound on the quota windows one usage report may carry. The producer
- * emits three today (5-hour, weekly, monthly); the cap exists because a decoder
- * is the boundary that does not trust its producer, matching how every other
- * array in this package is bounded before mapping.
- */
-const CONNECTION_USAGE_MAX_WINDOWS = 16;
 export const CONNECTION_EFFECT_CHANGED_DOMAINS = [
     'connection',
     'credential',
@@ -84,13 +77,6 @@ export const CONNECTION_EFFECT_OPERATION_SPECS = {
         decodeInput: decodeConnectionTestRunInput,
         decodeOutput: decodeConnectionTestRunResult,
     }),
-    'connection.usage.read': defineOperation({
-        mode: 'query',
-        availability: 'ready',
-        errors: EFFECT_ERRORS,
-        decodeInput: decodeConnectionUsageReadInput,
-        decodeOutput: decodeConnectionUsageReadResult,
-    }),
 };
 export function decodeConnectionOnboardingSaveInput(value) {
     const input = requireExactRecord(value, 'connection onboarding save input', [
@@ -296,100 +282,6 @@ export function decodeConnectionTestRunResult(value) {
     }
     return decodeNonEffectResult(result, 'connection test result');
 }
-export function decodeConnectionUsageReadInput(value) {
-    const input = requireExactRecord(value, 'connection usage input', ['connectionId']);
-    return { connectionId: requireEntityId(input.connectionId, 'connectionId') };
-}
-export function decodeConnectionUsageReadResult(value) {
-    const result = requireRecord(value, 'connection usage result');
-    if (result.kind === 'report') {
-        const report = requireExactRecord(result, 'connection usage report', ['kind', 'report']);
-        return { kind: 'report', report: decodeUsageReport(report.report) };
-    }
-    if (result.kind === 'unavailable') {
-        const unavailable = requireExactRecord(result, 'connection usage unavailable', [
-            'kind',
-            'reason',
-        ]);
-        if (unavailable.reason !== 'unsupported' &&
-            unavailable.reason !== 'network' &&
-            unavailable.reason !== 'no-credential' &&
-            unavailable.reason !== 'unauthorized') {
-            throw invalidProtocolFrame('Invalid connection usage unavailable reason');
-        }
-        return { kind: 'unavailable', reason: unavailable.reason };
-    }
-    if (result.kind === 'rejected') {
-        const rejected = requireExactRecord(result, 'connection usage result', ['kind', 'reason']);
-        return { kind: 'rejected', reason: rejectionReason(rejected.reason) };
-    }
-    throw invalidProtocolFrame('Invalid connection usage result');
-}
-function decodeUsageReport(value) {
-    const report = requireExactRecord(value, 'connection usage report body', [
-        'accountLabel',
-        'planLabel',
-        'stats',
-        'windows',
-        'periodEnd',
-        'partiallyUnauthorized',
-        'fetchedAt',
-    ]);
-    if (!Array.isArray(report.windows) || report.windows.length > CONNECTION_USAGE_MAX_WINDOWS) {
-        throw invalidProtocolFrame('Invalid connection usage windows');
-    }
-    return {
-        accountLabel: optionalText(report.accountLabel, 'account label'),
-        planLabel: optionalText(report.planLabel, 'plan label'),
-        stats: report.stats === null ? null : decodeUsageStats(report.stats),
-        windows: report.windows.map(decodeUsageWindow),
-        periodEnd: optionalMillis(report.periodEnd, 'period end'),
-        partiallyUnauthorized: requireBoolean(report.partiallyUnauthorized, 'partially unauthorized'),
-        fetchedAt: requireCount(report.fetchedAt, 'usage fetchedAt'),
-    };
-}
-function decodeUsageStats(value) {
-    const stats = requireExactRecord(value, 'connection usage stats', [
-        'requests',
-        'failed',
-        'successRate',
-        'cost',
-        'tokensIn',
-        'tokensOut',
-    ]);
-    return {
-        requests: optionalCount(stats.requests, 'requests'),
-        failed: optionalCount(stats.failed, 'failed'),
-        successRate: optionalAmount(stats.successRate, 'success rate'),
-        cost: optionalAmount(stats.cost, 'cost'),
-        tokensIn: optionalCount(stats.tokensIn, 'tokens in'),
-        tokensOut: optionalCount(stats.tokensOut, 'tokens out'),
-    };
-}
-function decodeUsageWindow(value) {
-    const window = requireExactRecord(value, 'connection usage window', [
-        'id',
-        'label',
-        'used',
-        'cap',
-        'unit',
-        'resetsAt',
-        'unlimited',
-    ]);
-    const unit = window.unit;
-    if (unit !== 'credits' && unit !== 'usd' && unit !== 'tokens') {
-        throw invalidProtocolFrame('Invalid connection usage unit');
-    }
-    return {
-        id: requireUtf8String(window.id, 'usage window id', 64),
-        label: optionalText(window.label, 'usage window label'),
-        used: requireAmount(window.used, 'usage window used'),
-        cap: requireAmount(window.cap, 'usage window cap'),
-        unit,
-        resetsAt: optionalMillis(window.resetsAt, 'usage window reset'),
-        unlimited: window.unlimited === null ? null : requireBoolean(window.unlimited, 'unlimited'),
-    };
-}
 function optionalText(value, label) {
     return value === null ? null : requireUtf8String(value, label, 256);
 }

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

@@ -62,7 +62,18 @@ export const RUNTIME_HOST_REGISTRATION_SCHEMA_VERSION = 1;
 export const RUNTIME_HOST_PROTOCOL_VERSION = 0;
 // Increment when the same protocol version no longer guarantees safe Client-Host
 // interoperability. Mismatches are rejected before domain commands are admitted.
-export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 166;
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 172;
+// 172: Usage screen requests and results accept fractional timestamps in the
+// persisted domain. Older peers reject these otherwise valid wire values.
+// 171: Removed the `connection.usage.read` operation along with the Command
+// Code GO provider it served. A peer older than this epoch may still advertise
+// or submit that operation, which this Host no longer answers.
+// 169: The message execution query reports an identity the Host can prove was
+// never admitted as a positive `not_admitted` resolution instead of omitting
+// it, so silence stops meaning both "not admitted" and "cannot say yet".
+// Epoch-168 peers reject the new state as an invalid frame.
+// 167: Removed the turn.regenerate operation. Older peers can no longer
+// safely interoperate because they may submit or advertise that operation.
 // 166: Connection usage reads add an operation, an accepted availability reason
 // (`unauthorized`), a report field (`partiallyUnauthorized`), and a bounded
 // window list. Peers older than this epoch take the added operation for an

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

@@ -200,6 +200,16 @@ function decodeTurnMessageExecutionQueryResult(value) {
                 state: 'cancelled',
             };
         }
+        if (resolution.state === 'not_admitted') {
+            assertExactKeys(resolution, 'turn.message.execution.query not_admitted resolution', [
+                'messageId',
+                'state',
+            ]);
+            return {
+                messageId: requireEntityId(resolution.messageId, 'messageId'),
+                state: 'not_admitted',
+            };
+        }
         if (resolution.state === 'owned') {
             assertExactKeys(resolution, 'turn.message.execution.query owned resolution', [
                 'messageId',

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

@@ -22,7 +22,6 @@ import { AGENT_GRAPH_OPERATION_SPECS } from './agent-graph.js';
 import { requireExactRecord, requireId, requireRecord, requireString } from './codec.js';
 import { CONNECTION_EFFECT_OPERATION_SPECS } from './connection-effects.js';
 import { CONFIGURATION_OPERATION_SPECS } from './configuration.js';
-import { DEEP_RESEARCH_OPERATION_SPECS } from './deep-research.js';
 import { DAILY_REVIEW_OPERATION_SPECS } from './daily-review.js';
 import { CONTEXT_OPERATION_SPECS } from './context.js';
 import { EXECUTION_INSPECT_OPERATION_SPECS } from './execution-inspect.js';
@@ -61,6 +60,7 @@ import { SKILL_CATALOG_OPERATION_SPECS } from './skill-catalog.js';
 import { TURN_OPERATION_SPECS } from './turn.js';
 import { USAGE_PRICING_OPERATION_SPECS } from './usage-pricing.js';
 import { WEB_SEARCH_OPERATION_SPECS } from './web-search.js';
+import { RECALL_OPERATION_SPECS } from './recall.js';
 import { WORKHUB_COORDINATION_OPERATION_SPECS } from './workhub-coordination.js';
 export { isHostActivityIdle } from './host-status.js';
 export { ARTIFACT_CURSOR_MAX_BYTES, ARTIFACT_INGEST_CHUNK_MAX_BYTES, ARTIFACT_INGEST_MIME_TYPE_MAX_BYTES, ARTIFACT_MIME_TYPE_MAX_BYTES, ARTIFACT_NAME_MAX_BYTES, ARTIFACT_PAGE_MAX_ITEMS, ARTIFACT_PREVIEW_MAX_BYTES, ARTIFACT_READ_CHUNK_MAX_BYTES, ARTIFACT_RESULT_MAX_BYTES, ARTIFACT_SUMMARY_MAX_BYTES, decodeArtifactDeleteInput, decodeArtifactDeleteResult, decodeArtifactIngestInput, decodeArtifactIngestResult, decodeArtifactQueryInput, decodeArtifactQueryResult, encodeArtifactDeleteResult, encodeArtifactQueryResult, } from './artifact.js';
@@ -68,7 +68,6 @@ export { TURN_FAILURE_MESSAGE_MAX_BYTES, TURN_MESSAGE_CONTENT_MAX_BYTES, TURN_ME
 export * from './connection-effects.js';
 export * from './access-authority.js';
 export * from './configuration.js';
-export * from './deep-research.js';
 export * from './daily-review.js';
 export * from './context.js';
 export * from './agent-graph.js';
@@ -97,8 +96,9 @@ export * from './session-effects.js';
 export * from './skill-catalog.js';
 export * from './usage-pricing.js';
 export * from './web-search.js';
+export * from './recall.js';
 export * from './workspace.js';
-export const HOST_OPERATION_SPECS = composeOperationSpecMaps(HOST_BOOTSTRAP_OPERATION_SPECS, HOST_RESOURCE_OPERATION_SPECS, PEER_MESH_OPERATION_SPECS, HOSTED_EXECUTION_OPERATION_SPECS, ACCESS_AUTHORITY_OPERATION_SPECS, SESSION_COLLABORATION_OPERATION_SPECS, AGENT_GRAPH_OPERATION_SPECS, GOAL_OPERATION_SPECS, TURN_OPERATION_SPECS, CONTEXT_OPERATION_SPECS, CONNECTION_EFFECT_OPERATION_SPECS, DEEP_RESEARCH_OPERATION_SPECS, DAILY_REVIEW_OPERATION_SPECS, EXECUTION_INSPECT_OPERATION_SPECS, EXTERNAL_SESSION_OPERATION_SPECS, RUNTIME_POLICY_OPERATION_SPECS, RUNTIME_RESOURCE_OPERATION_SPECS, SCHEDULED_TASK_OPERATION_SPECS, PLAN_OPERATION_SPECS, PROJECT_CATALOG_OPERATION_SPECS, MESSAGE_OPERATION_SPECS, SESSION_TODO_OPERATION_SPECS, INTERACTION_OPERATION_SPECS, SESSION_CONTINUITY_OPERATION_SPECS, SESSION_TRANSCRIPT_OPERATION_SPECS, SESSION_TURNS_OPERATION_SPECS, SESSION_CATALOG_OPERATION_SPECS, SESSION_EFFECT_OPERATION_SPECS, SESSION_REVISION_OPERATION_SPECS, SESSION_BUNDLE_OPERATION_SPECS, SESSION_RETIREMENT_OPERATION_SPECS, ARTIFACT_OPERATION_SPECS, SKILL_CATALOG_OPERATION_SPECS, USAGE_PRICING_OPERATION_SPECS, MEMORY_OPERATION_SPECS, OAUTH_OPERATION_SPECS, EXTERNAL_AGENT_SETUP_OPERATION_SPECS, CLIENT_CAPABILITY_OPERATION_SPECS, WEB_SEARCH_OPERATION_SPECS, NETWORK_PROXY_OPERATION_SPECS, CONFIGURATION_OPERATION_SPECS, WORKHUB_COORDINATION_OPERATION_SPECS, PLUGIN_PLATFORM_OPERATION_SPECS);
+export const HOST_OPERATION_SPECS = composeOperationSpecMaps(HOST_BOOTSTRAP_OPERATION_SPECS, HOST_RESOURCE_OPERATION_SPECS, PEER_MESH_OPERATION_SPECS, HOSTED_EXECUTION_OPERATION_SPECS, ACCESS_AUTHORITY_OPERATION_SPECS, SESSION_COLLABORATION_OPERATION_SPECS, AGENT_GRAPH_OPERATION_SPECS, GOAL_OPERATION_SPECS, TURN_OPERATION_SPECS, CONTEXT_OPERATION_SPECS, CONNECTION_EFFECT_OPERATION_SPECS, DAILY_REVIEW_OPERATION_SPECS, EXECUTION_INSPECT_OPERATION_SPECS, EXTERNAL_SESSION_OPERATION_SPECS, RUNTIME_POLICY_OPERATION_SPECS, RUNTIME_RESOURCE_OPERATION_SPECS, SCHEDULED_TASK_OPERATION_SPECS, PLAN_OPERATION_SPECS, PROJECT_CATALOG_OPERATION_SPECS, MESSAGE_OPERATION_SPECS, SESSION_TODO_OPERATION_SPECS, INTERACTION_OPERATION_SPECS, SESSION_CONTINUITY_OPERATION_SPECS, SESSION_TRANSCRIPT_OPERATION_SPECS, SESSION_TURNS_OPERATION_SPECS, SESSION_CATALOG_OPERATION_SPECS, SESSION_EFFECT_OPERATION_SPECS, SESSION_REVISION_OPERATION_SPECS, SESSION_BUNDLE_OPERATION_SPECS, SESSION_RETIREMENT_OPERATION_SPECS, ARTIFACT_OPERATION_SPECS, SKILL_CATALOG_OPERATION_SPECS, USAGE_PRICING_OPERATION_SPECS, MEMORY_OPERATION_SPECS, OAUTH_OPERATION_SPECS, EXTERNAL_AGENT_SETUP_OPERATION_SPECS, CLIENT_CAPABILITY_OPERATION_SPECS, WEB_SEARCH_OPERATION_SPECS, NETWORK_PROXY_OPERATION_SPECS, RECALL_OPERATION_SPECS, CONFIGURATION_OPERATION_SPECS, WORKHUB_COORDINATION_OPERATION_SPECS, PLUGIN_PLATFORM_OPERATION_SPECS);
 // Remote credentials are fail-closed: adding a protocol operation does not
 // grant it to remote owners until this policy is deliberately updated.
 export const REMOTE_OWNER_OPERATION_GRANTS = Object.freeze([
@@ -131,7 +131,6 @@ export const REMOTE_OWNER_OPERATION_GRANTS = Object.freeze([
     'connection.request-headers.query',
     'connection.request-headers.replace',
     'connection.test.run',
-    'connection.usage.read',
     'context.compact',
     'context.diagnostics.query',
     'credential.vault.delete',
@@ -139,7 +138,6 @@ export const REMOTE_OWNER_OPERATION_GRANTS = Object.freeze([
     'credential.vault.set',
     'daily-review.mutate',
     'daily-review.query',
-    'deep-research.query',
     'execution.inspect.query',
     'external-session.catalog.query',
     'external-session.import',
@@ -179,6 +177,7 @@ export const REMOTE_OWNER_OPERATION_GRANTS = Object.freeze([
     'runtime.policy.mutate',
     'runtime.policy.network-proxy.update',
     'runtime.policy.query',
+    'recall.query',
     'runtime.resource.controller.acquire',
     'runtime.resource.controller.control',
     'runtime.resource.controller.release',
@@ -219,7 +218,6 @@ export const REMOTE_OWNER_OPERATION_GRANTS = Object.freeze([
     'turn.message.query',
     'turn.message.submit',
     'turn.query',
-    'turn.regenerate',
     'turn.resume.query',
     'turn.resume.start',
     'turn.start',

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-catalog.js

@@ -273,7 +273,7 @@ export function decodeSessionCreateInput(value) {
         ...(target ? { modelTarget: target } : {}),
         ...(executorId ? { executorId } : {}),
         ...(Object.hasOwn(input, 'thinkingLevel')
-            ? { thinkingLevel: thinkingLevel(input.thinkingLevel) }
+            ? { thinkingLevel: input.thinkingLevel === null ? null : thinkingLevel(input.thinkingLevel) }
             : {}),
         ...(Object.hasOwn(input, 'toolProfile')
             ? { toolProfile: sessionToolProfile(input.toolProfile) }

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/turn.js

@@ -96,27 +96,6 @@ export const TURN_OPERATION_SPECS = {
         decodeInput: decodeTurnStopInput,
         decodeOutput: decodeTurnSnapshot,
     }),
-    'turn.regenerate': defineOperation({
-        mode: 'command',
-        availability: 'ready',
-        errors: [
-            'host_not_ready',
-            'host_draining',
-            'operation_unavailable',
-            'not_found',
-            'session_archived',
-            'session_busy',
-            'operation_conflict',
-            'internal_failure',
-        ],
-        decodeInput: decodeTurnRegenerateInput,
-        decodeOutput: decodeTurnSnapshot,
-        assertOutputForInput: (input, output) => {
-            if (input.sessionId !== output.sessionId || input.turnId !== output.turnId) {
-                throw invalidProtocolFrame('Turn regenerate changed operation identity');
-            }
-        },
-    }),
     'turn.resume.query': defineOperation({
         mode: 'query',
         availability: 'ready',
@@ -317,18 +296,6 @@ function decodeTurnStopInput(value) {
         runId: requireEntityId(record.runId, 'runId'),
     };
 }
-function decodeTurnRegenerateInput(value) {
-    const record = requireExactRecord(value, 'turn.regenerate input', [
-        'sessionId',
-        'sourceTurnId',
-        'turnId',
-    ]);
-    return {
-        sessionId: requireEntityId(record.sessionId, 'sessionId'),
-        sourceTurnId: requireEntityId(record.sourceTurnId, 'sourceTurnId'),
-        turnId: requireEntityId(record.turnId, 'turnId'),
-    };
-}
 function decodeTurnResumeQueryInput(value) {
     const record = requireShapedRecord(value, 'turn.resume.query input', ['sessionId'], ['sourceRunId', 'expectedRuntimeEventHighWater']);
     if (record.expectedRuntimeEventHighWater !== undefined && record.sourceRunId === undefined) {