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

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

@@ -0,0 +1,117 @@
+/*
+ * 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.
+ */
+import { runRecall } from '@maka/core/recall';
+/**
+ * Serves `recall.query` from the same dependency graph the model's `Recall`
+ * tool uses.
+ *
+ * The point of this coordinator is that it owns no retrieval logic: it hands
+ * the request to `runRecall` and projects the answer. Whatever recall can see —
+ * privacy gating, archived Sessions, the distilled-fact store — a Client
+ * asking over the wire sees the same thing, because there is one implementation
+ * and this is not a second one.
+ *
+ * Unlike the model's tool, no turn is excluded. A tool call runs inside a turn
+ * and must not surface that turn's own text back as corroboration; a Client
+ * search is not inside any turn, so there is nothing to exclude.
+ */
+export class HostRecallCoordinator {
+    deps;
+    handlers = {
+        'recall.query': (input) => this.#query(input),
+    };
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async #query(input) {
+        try {
+            const result = await runRecall(input, this.deps, { includeArchived: true });
+            return { ok: true, result: projectRecallResult(result) };
+        }
+        catch {
+            return {
+                ok: false,
+                error: { code: 'internal_failure', message: 'Recall query failed' },
+            };
+        }
+    }
+}
+/**
+ * `RecallQueryResult` is the core result with the Host's field vocabulary.
+ *
+ * Recall already returns exactly these fields; the projection exists to drop
+ * core-internal detail and to make the boundary explicit, so a change to the
+ * core shape shows up here rather than silently widening the wire.
+ */
+export function projectRecallResult(result) {
+    if (!result.ok) {
+        return { ok: false, reason: result.reason, message: result.message };
+    }
+    return {
+        ok: true,
+        facts: result.facts.map((fact) => ({
+            content: fact.content,
+            kind: fact.kind,
+            observedAt: fact.observedAt,
+        })),
+        passages: result.passages.map((passage) => projectPassage(passage)),
+        gaps: result.gaps,
+        searchedEverySession: result.scannedFully,
+    };
+}
+function projectPassage(passage) {
+    return {
+        sessionId: passage.sessionId,
+        sessionTitle: passage.sessionTitle,
+        ...(passage.turnId ? { turnId: passage.turnId } : {}),
+        anchorMessageId: passage.anchorMessageId,
+        sequence: passage.sequence,
+        messages: passage.messages.map((message) => ({
+            messageId: message.messageId,
+            role: message.role,
+            matchKind: message.matchKind,
+            text: message.text,
+            timestamp: message.timestamp,
+            isAnchor: message.isAnchor,
+            ...(message.materials
+                ? {
+                    materials: message.materials.map((material) => ({
+                        name: material.name,
+                        kind: material.kind,
+                        mimeType: material.mimeType,
+                        bytes: material.bytes,
+                        ...(material.resource ? { resource: material.resource } : {}),
+                        ...(material.sourceSessionId && material.materialId
+                            ? {
+                                sourceSessionId: material.sourceSessionId,
+                                materialId: material.materialId,
+                            }
+                            : {}),
+                    })),
+                }
+                : {}),
+        })),
+        matchedTerms: passage.matchedTerms,
+        score: passage.score,
+        ...(passage.lastMessageAt !== undefined ? { lastMessageAt: passage.lastMessageAt } : {}),
+        hasMoreBefore: passage.hasMoreBefore,
+        hasMoreAfter: passage.hasMoreAfter,
+        ...(passage.truncated ? { truncated: true } : {}),
+    };
+}

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

@@ -17,7 +17,6 @@
  * under the License.
  */
 import { createHash, randomUUID } from 'node:crypto';
-import { isDeepResearchSession } from '@maka/core/deep-research';
 import { SIDE_CONVERSATION_SESSION_LABEL } from '@maka/core/side-conversation';
 import { isWorkHubCoordinationSessionId, isWorkHubCoordinationSessionTarget, sessionRevisionFamilyId, } from '@maka/core/session';
 import { runtimeHostConversationCopyUnavailableReason } from './host-session-availability.js';
@@ -204,9 +203,6 @@ export class HostSessionRevisionCoordinator {
         if (sourceHeader.subagentParent) {
             return copyFailure('operation_conflict', 'Linked child Sessions cannot be copied as ordinary conversations');
         }
-        if (isDeepResearchSession(sourceHeader.labels)) {
-            return copyFailure('operation_unavailable', 'Deep Research Sessions cannot be copied without an exact research ledger boundary');
-        }
         const copyUnavailableReason = runtimeHostConversationCopyUnavailableReason(sourceHeader);
         if (copyUnavailableReason)
             return copyFailure('operation_unavailable', copyUnavailableReason);

package/node_modules/@maka/storage/dist/artifact-metadata-codec.js

@@ -18,7 +18,6 @@
  */
 import { isAbsolute } from 'node:path';
 import { ARTIFACT_KINDS, ARTIFACT_SOURCES, isArtifactTurnKey, isCanonicalArtifactEntityId, } from '@maka/core/artifacts';
-import { isDeepResearchArtifactRole } from '@maka/core/deep-research-run';
 const ARTIFACT_KIND_SET = new Set(ARTIFACT_KINDS);
 const ARTIFACT_SOURCE_SET = new Set(ARTIFACT_SOURCES);
 const ARTIFACT_RECORD_KEYS = new Set([
@@ -104,7 +103,6 @@ function decodeArtifactRecord(value, index) {
         value.sizeBytes < 0 ||
         !isOptionalNonEmptyString(value.mimeType) ||
         !isOptionalNonEmptyString(value.summary) ||
-        (value.deepResearchRole !== undefined && !isDeepResearchArtifactRole(value.deepResearchRole)) ||
         typeof value.source !== 'string') {
         throw invalidMetadataRecord(index);
     }
@@ -114,7 +112,10 @@ function decodeArtifactRecord(value, index) {
     if (value.relativePath !== `${value.sessionId}/${value.id}-${value.name}`) {
         throw invalidMetadataRecord(index);
     }
-    return value;
+    // Old reports carry a workflow role that no longer has a consumer.
+    const record = { ...value };
+    delete record.deepResearchRole;
+    return record;
 }
 function isCompatibleArtifactName(name) {
     if (name.length === 0 || name.length > 120)

package/node_modules/@maka/storage/dist/artifact-store.js

@@ -22,7 +22,6 @@ import { constants as fsConstants } from 'node:fs';
 import { access, copyFile, lstat, mkdir, open, readFile, realpath, rm, stat, unlink, writeFile, } from 'node:fs/promises';
 import { basename, dirname, join, relative, sep } from 'node:path';
 import { ARTIFACT_ENTITY_ID_MAX_CHARS, ARTIFACT_KINDS, ARTIFACT_SOURCES, canUserDeleteArtifact, isArtifactTurnKey, isCanonicalArtifactEntityId, } from '@maka/core/artifacts';
-import { isDeepResearchArtifactRole, } from '@maka/core/deep-research-run';
 import { sniffAttachmentMimeType } from '@maka/core/attachments';
 import { isSafeRelativeArtifactPath, validateRelativeArtifactPath, } from './artifact-metadata-codec.js';
 import { withArtifactWriterLock, withLeaseBoundArtifactWriterLock, } from './artifact-writer-lock.js';
@@ -68,10 +67,6 @@ class SqliteArtifactStore {
         if (!ARTIFACT_SOURCE_SET.has(acceptedInput.source)) {
             throw new Error('Invalid Artifact source');
         }
-        if (acceptedInput.deepResearchRole !== undefined &&
-            !isDeepResearchArtifactRole(acceptedInput.deepResearchRole)) {
-            throw new Error('Invalid Artifact deep-research role');
-        }
         if (acceptedInput.now !== undefined &&
             (!Number.isSafeInteger(acceptedInput.now) || acceptedInput.now < 0)) {
             throw new Error('Invalid Artifact creation time');
@@ -103,9 +98,6 @@ class SqliteArtifactStore {
                 ...(acceptedInput.mimeType ? { mimeType: acceptedInput.mimeType } : {}),
                 source: acceptedInput.source,
                 ...(acceptedInput.summary ? { summary: acceptedInput.summary } : {}),
-                ...(acceptedInput.deepResearchRole
-                    ? { deepResearchRole: acceptedInput.deepResearchRole }
-                    : {}),
             }, (targetPath) => writeFile(targetPath, acceptedInput.content, { flag: 'wx' }));
         });
     }
@@ -346,7 +338,6 @@ class SqliteArtifactStore {
             existing.mimeType !== optionalCanonicalText(input.mimeType) ||
             existing.source !== input.source ||
             existing.summary !== optionalCanonicalText(input.summary) ||
-            existing.deepResearchRole !== input.deepResearchRole ||
             (input.now !== undefined && existing.createdAt !== input.now)) {
             throw artifactReplayConflict(canonical.id);
         }
@@ -798,8 +789,7 @@ function sameArtifactRecord(a, b) {
         a.sizeBytes === b.sizeBytes &&
         a.mimeType === b.mimeType &&
         a.source === b.source &&
-        a.summary === b.summary &&
-        a.deepResearchRole === b.deepResearchRole);
+        a.summary === b.summary);
 }
 function assertPageBound(value, allowZero, label) {
     if (!Number.isSafeInteger(value) || value < (allowZero ? 0 : 1)) {

package/node_modules/@maka/storage/dist/process-lifetime-file-update-lock.js

@@ -22,43 +22,6 @@ import { openStableNativeLockFile, releaseNativeFileLock, tryAcquireNativeFileLo
 const LOCK_POLL_MS = 25;
 const LOCK_TIMEOUT_MS = 10_000;
 const lockGates = new Map();
-export async function withLegacyFileUpdateLockLease(targetPath, operation, timeoutMs = LOCK_TIMEOUT_MS) {
-    const lockPath = `${targetPath}.lock`;
-    const leasePath = `${targetPath}.lease`;
-    const supervisionPath = `${targetPath}.supervised`;
-    const deadline = Date.now() + timeoutMs;
-    return runWithLockGate(leasePath, deadline, async () => {
-        const lease = await openStableNativeLockFile(leasePath);
-        let leased = false;
-        let supervised = false;
-        let completed = false;
-        try {
-            while (!(leased = tryAcquireNativeFileLock(lease))) {
-                await waitForLockTurn(lockPath, deadline);
-            }
-            // The inherited advisory lease follows the legacy child process. A surviving
-            // supervision marker therefore proves that its directory lock is ownerless
-            // once a later process can acquire this lease.
-            await recoverSupervisedLegacyLock(lockPath, supervisionPath);
-            await createSupervisionMarker(supervisionPath);
-            supervised = true;
-            const result = await operation(lease.fd);
-            completed = true;
-            return result;
-        }
-        finally {
-            try {
-                if (supervised && completed)
-                    await unlink(supervisionPath).catch(ignoreMissing);
-            }
-            finally {
-                if (leased)
-                    releaseNativeFileLock(lease);
-                await lease.close();
-            }
-        }
-    });
-}
 /**
  * The callback may pass the lease fd as an extra child stdio descriptor. The
  * advisory lock then survives a parent crash until that exact child exits.
@@ -93,10 +56,6 @@ export async function withProcessLifetimeFileUpdateLock(targetPath, operation, t
         }
     });
 }
-async function createSupervisionMarker(path) {
-    const marker = await open(path, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY | fsConstants.O_NOFOLLOW, 0o600);
-    await marker.close();
-}
 async function recoverSupervisedLegacyLock(lockPath, supervisionPath) {
     const supervision = await lstat(supervisionPath).catch((error) => {
         if (isNodeError(error, 'ENOENT'))

package/node_modules/@maka/storage/dist/runtime-policy/coordinator.js

@@ -1111,29 +1111,6 @@ export class RuntimePolicyCoordinator {
             });
         }));
     }
-    beginConnectionUsage(connectionId) {
-        return this.inLane(async (root) => {
-            const prepared = await this.prepareConnectionOperation(root, connectionId, 'read_usage');
-            if (prepared.kind !== 'ready')
-                return prepared;
-            const ticket = this.issueTicket('connection_usage', connectionUsageSemanticBasis(prepared));
-            return deepFreeze({
-                kind: 'ready',
-                ticket: ticket,
-                connection: structuredClone(prepared.connection),
-                secretMaterial: prepared.secretMaterial,
-                networkProxy: structuredClone(prepared.networkProxy),
-            });
-        });
-    }
-    /**
-     * Read-only counterpart of `completeConnectionTest`: nothing was written, so
-     * there is no catalog state to revalidate — the ticket is simply spent.
-     */
-    async completeConnectionUsage(ticket) {
-        const claimed = this.claimTicket(ticket, 'connection_usage');
-        await this.completeClaimedTicket(claimed, async () => undefined);
-    }
     async prepareConnectionOperation(root, connectionId, action) {
         const catalog = await this.catalog.read(root);
         const connection = findConnection(catalog, { connectionId });
@@ -1594,9 +1571,6 @@ function connectionTestSemanticBasis(prepared) {
         model: connectionTestModelBasis(prepared.connection),
     };
 }
-function connectionUsageSemanticBasis(prepared) {
-    return { kind: 'connection_usage', ...commonSemanticConnectionBasis(prepared) };
-}
 function isCanonicalConnectionTestModel(connection, modelId) {
     const basis = connectionTestModelBasis(connection);
     // Either source admits: testing a discovered model before enabling it is the
@@ -1709,8 +1683,6 @@ function ticketLabel(kind) {
             return 'model fetch';
         case 'connection_test':
             return 'connection test';
-        case 'connection_usage':
-            return 'connection usage';
     }
 }
 function networkProxyCredentialLocator() {

package/node_modules/@maka/storage/dist/runtime-policy-stores.js

@@ -126,8 +126,6 @@ function createWriterFacade(coordinator) {
             completeConnectionOnboarding: (ticket, input) => coordinator.completeConnectionOnboarding(ticket, input),
             beginConnectionTest: (connectionId, modelId) => coordinator.beginConnectionTest(connectionId, modelId),
             completeConnectionTest: (ticket, result) => coordinator.completeConnectionTest(ticket, result),
-            beginConnectionUsage: (connectionId) => coordinator.beginConnectionUsage(connectionId),
-            completeConnectionUsage: (ticket) => coordinator.completeConnectionUsage(ticket),
         },
     };
     freezeFacade(stores);

package/node_modules/@maka/storage/dist/sqlite-usage-schema.js

@@ -203,6 +203,7 @@ export function migrateSqliteUsageDatabase(db) {
 
     CREATE INDEX IF NOT EXISTS usage_llm_calls_session_ts
       ON usage_llm_calls(session_id, ts DESC, id);
+    DROP INDEX IF EXISTS usage_llm_calls_session_id;
   `);
     // A ledger old enough to predate Session attribution has no column to carry
     // through, and the conversion below reads one.
@@ -224,6 +225,8 @@ export function migrateSqliteUsageDatabase(db) {
     INSERT OR IGNORE INTO usage_screen_revision VALUES (1, lower(hex(randomblob(16))), 0);
     CREATE INDEX IF NOT EXISTS usage_llm_calls_screen ON usage_llm_calls(ts DESC, storage_key DESC);
     CREATE INDEX IF NOT EXISTS usage_tool_invocations_screen ON usage_tool_invocations(ts DESC, storage_key DESC);
+    CREATE INDEX IF NOT EXISTS usage_tool_invocations_session_id
+      ON usage_tool_invocations(json_extract(record_json, '$.sessionId'));
     CREATE INDEX IF NOT EXISTS usage_model_call_attempts_screen ON usage_model_call_attempts(completed_at DESC, attempt_id DESC);
   `);
     // These are invalidation metadata, never an accounting or repair authority.
@@ -246,11 +249,26 @@ export function migrateSqliteUsageDatabase(db) {
         for (const event of ['INSERT', 'UPDATE', 'DELETE']) {
             let when = '';
             if (table === 'session_metadata') {
-                // Only title/identity changes affect the Usage activity projection.
+                // Metadata only participates in Usage through activity titles. Avoid
+                // fencing an open screen for Sessions that have no retained activity.
+                const hasUsage = (row) => `(
+          EXISTS (SELECT 1 FROM usage_llm_calls WHERE session_id = ${row}.session_id LIMIT 1)
+          OR EXISTS (
+            SELECT 1 FROM usage_tool_invocations
+            WHERE json_extract(record_json, '$.sessionId') = ${row}.session_id LIMIT 1
+          )
+          OR EXISTS (
+            SELECT 1 FROM usage_model_call_attempts
+            WHERE session_id = ${row}.session_id LIMIT 1
+          )
+        )`;
                 when =
-                    event === 'UPDATE'
-                        ? 'WHEN OLD.name IS NOT NEW.name OR OLD.session_id IS NOT NEW.session_id'
-                        : '';
+                    event === 'INSERT'
+                        ? `WHEN ${hasUsage('NEW')}`
+                        : event === 'DELETE'
+                            ? `WHEN ${hasUsage('OLD')}`
+                            : `WHEN (OLD.name IS NOT NEW.name OR OLD.session_id IS NOT NEW.session_id)
+                  AND (${hasUsage('OLD')} OR ${hasUsage('NEW')})`;
             }
             else if (table === 'core_agent_run_events') {
                 const old = "OLD.event_type = 'model_call_attempt_recorded'";
@@ -265,7 +283,13 @@ export function migrateSqliteUsageDatabase(db) {
                             ? 'WHEN OLD.latest_model_call_sequence IS NOT NULL'
                             : 'WHEN OLD.latest_model_call_sequence IS NOT NEW.latest_model_call_sequence OR OLD.session_id IS NOT NEW.session_id OR OLD.run_id IS NOT NEW.run_id';
             }
-            db.exec(`CREATE TRIGGER IF NOT EXISTS ${table}_screen_${event.toLowerCase()}
+            const trigger = `${table}_screen_${event.toLowerCase()}`;
+            // Schema v8 originally installed unconditional metadata INSERT/DELETE
+            // triggers. Recreate those named triggers so existing databases receive
+            // the narrowed predicate as well as fresh databases.
+            if (table === 'session_metadata')
+                db.exec(`DROP TRIGGER IF EXISTS ${trigger}`);
+            db.exec(`CREATE TRIGGER IF NOT EXISTS ${trigger}
         AFTER ${event} ON ${table} ${when} BEGIN
           UPDATE usage_screen_revision SET revision = revision + 1 WHERE singleton = 1;
         END`);

package/node_modules/@maka/storage/dist/sqlite-workflow-schema.js

@@ -57,6 +57,8 @@ export function migrateSqliteWorkflowDatabase(db) {
       UNIQUE (session_id, store_version)
     );
 
+    -- Retained for existing State Roots: schema validation compares the complete DDL.
+    -- The research writer is retired, but its stored events must survive upgrades.
     CREATE TABLE IF NOT EXISTS workflow_deep_research_events (
       session_id TEXT NOT NULL,
       sequence INTEGER NOT NULL CHECK (sequence >= 0),

package/node_modules/@maka/storage/dist/storage-writer-composition.js

@@ -19,7 +19,6 @@
 import { openInteractiveArtifactStoreForWrite } from './artifact-stores.js';
 import { openInteractiveContextOffloadStoreForWrite } from './context-offload-store.js';
 import { openInteractiveDailyReviewAuthorityForWrite } from './daily-review-authority.js';
-import { openInteractiveDeepResearchStoreForWrite } from './deep-research-authority.js';
 import { openInteractiveExecutionStoresForWrite } from './execution-stores.js';
 import { openInteractiveLongTermMemoryStoreForWrite } from './long-term-memory-store.js';
 import { openInteractiveMemoryBundleStoreForWrite } from './memory-bundle-store.js';
@@ -87,7 +86,6 @@ async function createComposition(lease, options) {
     }
     const scheduledTasks = await openWriter(() => openInteractiveScheduledTaskStoreForWrite(lease), closeWriter);
     const plan = await openWriter(() => openInteractivePlanStoreForWrite(lease), closeWriter);
-    const deepResearch = await openWriter(() => openInteractiveDeepResearchStoreForWrite(lease), closeWriter);
     const dailyReview = await openWriter(() => openInteractiveDailyReviewAuthorityForWrite(lease), closeWriter);
     const goal = execution.goalStore;
     const memoryBundle = await openWriter(() => openInteractiveMemoryBundleStoreForWrite(lease));
@@ -117,7 +115,6 @@ async function createComposition(lease, options) {
         runtimePolicy,
         scheduledTasks,
         plan,
-        deepResearch,
         dailyReview,
         goal,
         memoryBundle,

package/node_modules/@maka/storage/dist/telemetry-file-schema.js

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { MODEL_CALL_KINDS, } from '@maka/core/usage-stats/types';
+import { isUsageTimestamp } from '@maka/core/settings';
 import { isContextBudgetDiagnostic, isPromptSegmentEstimate } from '@maka/core/usage-record-schema';
 function exactKeys(shape) {
     return new Set(Object.keys(shape));
@@ -110,8 +111,8 @@ export function decodePersistedLlmCallRecord(input) {
         'latencyMs',
         'costUsd',
         'startedAt',
-        'ts',
-    ])) {
+    ]) ||
+        !isUsageTimestamp(input.ts)) {
         throw invalid('invalid required LLM number');
     }
     if (input.cachedInputTokens !== input.cacheHitInputTokens) {
@@ -172,7 +173,8 @@ export function decodePersistedToolInvocationRecord(input) {
     if (!strings(input, ['id', 'toolName', 'date'])) {
         throw invalid('invalid required tool string');
     }
-    if (!nonNegativeNumbers(input, ['durationMs', 'bytesIn', 'bytesOut', 'startedAt', 'ts'])) {
+    if (!nonNegativeNumbers(input, ['durationMs', 'bytesIn', 'bytesOut', 'startedAt']) ||
+        !isUsageTimestamp(input.ts)) {
         throw invalid('invalid required tool number');
     }
     if (!['success', 'error', 'aborted'].includes(input.status)) {

package/node_modules/@maka/storage/dist/usage-screen.js

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { createHash, randomUUID } from 'node:crypto';
+import { isUsageScreenSearch, isUsageTimestamp, } from '@maka/core/settings';
 import { acquireOperationalStateDatabase } from './operational-state-store.js';
 import { CACHE_READ_TOKENS } from './model-call-usage-sql.js';
 import { TelemetryQueryValidationError } from './telemetry-repo.js';
@@ -201,12 +202,10 @@ export function createUsageScreenReader(root) {
     };
 }
 function validateQuery(query) {
-    if (!Number.isSafeInteger(query.range.from) ||
-        !Number.isSafeInteger(query.range.to) ||
-        query.range.from < 0 ||
+    if (!isUsageTimestamp(query.range.from) ||
+        !isUsageTimestamp(query.range.to) ||
         query.range.to < query.range.from ||
-        typeof query.search !== 'string' ||
-        query.search.length > 1024 ||
+        !isUsageScreenSearch(query.search) ||
         !['all', 'success', 'error', 'aborted'].includes(query.status)) {
         throw new TelemetryQueryValidationError('Invalid Usage screen query');
     }
@@ -246,7 +245,7 @@ function activity(db, query, cursor) {
         if (!Array.isArray(value) ||
             value.length !== 4 ||
             value[0] !== hash(query) ||
-            !Number.isSafeInteger(value[1]) ||
+            !isUsageTimestamp(value[1]) ||
             value[1] < query.range.from ||
             value[1] > query.range.to ||
             !['canonical', 'legacy', 'tool'].includes(value[2]) ||

package/node_modules/@maka/storage/dist/usage-stores.js

@@ -110,11 +110,15 @@ export function authenticateInteractiveUsageStoresWriter(stores) {
 export async function openInteractiveUsageStoresForRead(lease) {
     const repos = await runWithStorageRootLease(lease, 'interactive', 'read', (root) => openRepos(root, false));
     let closed = false;
+    let barrier = Promise.resolve();
     let closePromise;
     const run = (operation) => {
         if (closed)
             return Promise.reject(new InteractiveUsageStoresClosedError());
-        return runWithStorageRootLease(lease, 'interactive', 'read', async () => operation());
+        const admitted = runWithStorageRootLease(lease, 'interactive', 'read', async () => operation());
+        const settled = admitted.then(() => undefined, () => undefined);
+        barrier = Promise.all([barrier, settled]).then(() => undefined);
+        return admitted;
     };
     const stores = {
         readUsageScreen: (input) => run(() => repos.screen.read(input)),
@@ -128,8 +132,11 @@ export async function openInteractiveUsageStoresForRead(lease) {
             if (closePromise)
                 return closePromise;
             closed = true;
-            repos.screen.close();
-            closePromise = closeRepos(repos.telemetry, repos.modelCalls, repos.pricing);
+            const accepted = barrier;
+            closePromise = accepted.then(async () => {
+                repos.screen.close();
+                await closeRepos(repos.telemetry, repos.modelCalls, repos.pricing);
+            });
             return closePromise;
         },
     };
@@ -230,7 +237,10 @@ function createWriterFacade(lease, telemetry, modelCalls, pricing, screen) {
     });
     const read = (operation) => {
         assertOpen();
-        return run(operation);
+        const admitted = Promise.resolve().then(() => run(operation));
+        const settled = admitted.then(() => undefined, () => undefined);
+        barrier = Promise.all([barrier, settled]).then(() => undefined);
+        return admitted;
     };
     const beginDrain = () => {
         if (drainPromise)

package/node_modules/@maka/storage/package.json

@@ -13,8 +13,6 @@
     "./tool-result-archive-evidence": "./dist/tool-result-archive-evidence.js",
     "./credential-store": "./dist/credential-store.js",
     "./daily-review-authority": "./dist/daily-review-authority.js",
-    "./deep-research-authority": "./dist/deep-research-authority.js",
-    "./deep-research-store": "./dist/deep-research-store.js",
     "./encrypted-file-managed-secret-store": "./dist/encrypted-file-managed-secret-store.js",
     "./execution-stores": "./dist/execution-stores.js",
     "./execution-persistence-provider": "./dist/execution-persistence-provider.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maka-agent",
-  "version": "0.2.0-dev.44.20260920",
+  "version": "0.2.0-dev.45.20260921",
   "description": "Apache Maka (Incubating) developer snapshot; not an Apache release.",
   "license": "Apache-2.0",
   "type": "module",

package/node_modules/@maka/core/dist/connection-usage.js

@@ -1,27 +0,0 @@
-/*
- * 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.
- */
-/**
- * The providers Maka can read account usage from. The single source of truth
- * for both the settings section's visibility and the runtime dispatch, so a
- * provider that gains a mapper is offered the card in the same change.
- */
-const USAGE_PROVIDERS = new Set(['commandcode-go']);
-export function providerReportsUsage(providerType) {
-    return USAGE_PROVIDERS.has(providerType);
-}