maka-agent 0.2.0-dev.14.20260902 → 0.2.0-dev.16.20260903

package/node_modules/@maka/storage/dist/runtime-policy/oauth-login-receipt-document.js

@@ -154,7 +154,9 @@ function decodeIdentity(value) {
 }
 function decodeOAuthProvider(value) {
     const providerType = decodePersistedDomain(() => decodeProviderType(value));
-    if (providerType !== 'openai-codex' && providerType !== 'xai-oauth') {
+    if (providerType !== 'openai-codex' &&
+        providerType !== 'xai-oauth' &&
+        providerType !== 'github-copilot') {
         throw codecError('invalid_document', 'OAuth login receipt provider is invalid');
     }
     return providerType;

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

@@ -18,7 +18,7 @@
  */
 import { unlink } from 'node:fs/promises';
 import { join } from 'node:path';
-import { decodeProviderType, decodeCanonicalConnectionCatalogEntry, decodeCredentialVersionBasis, decodeConnectionSlug, decodeRuntimePolicyEntityId, normalizeCatalogConnectionBaseUrl, normalizeConnectionCatalogEntryUpdateForProvider, normalizeConnectionModelDiscoveryResult, normalizeCredentialSecret, } from '@maka/core/runtime-policy';
+import { decodeProviderType, decodeCanonicalConnectionCatalogEntry, decodeCredentialVersionBasis, decodeConnectionName, decodeConnectionSlug, decodeRuntimePolicyEntityId, normalizeCatalogConnectionBaseUrl, normalizeConnectionCatalogEntryUpdateForProvider, normalizeConnectionModelDiscoveryResult, normalizeCredentialSecret, } from '@maka/core/runtime-policy';
 import { deriveConnectionSlug, PROVIDER_REGISTRY, providerAuthSupportsApiKey, } from '@maka/core/llm-connections';
 import { syncDirectory } from '../stable-storage.js';
 import { record } from './codec.js';
@@ -31,10 +31,10 @@ const MAX_BYTES = 5 * 1024 * 1024;
 export function prepareConnectionOnboardingIntent(input, source = 'input') {
     const decode = source === 'persisted' ? decodePersistedDomain : decodeConnectionInput;
     const providerType = decode(() => decodeProviderType(input.providerType));
-    if (!providerAuthSupportsApiKey(providerType)) {
-        throw codecError(source === 'persisted' ? 'invalid_document' : 'invalid_connection_input', 'Onboarding requires an API-key provider');
-    }
     const definition = PROVIDER_REGISTRY[providerType];
+    if (!providerAuthSupportsApiKey(providerType) && definition.authKind !== 'oauth_token') {
+        throw codecError(source === 'persisted' ? 'invalid_document' : 'invalid_connection_input', 'Onboarding requires a provider with a connection credential');
+    }
     const discovery = decode(() => normalizeConnectionModelDiscoveryResult(input.discovery));
     // Non-empty is the requirement; `source` is write provenance, not a
     // quality bar. A provider without a model-list endpoint runs discovery by
@@ -72,6 +72,9 @@ export function prepareConnectionOnboardingIntent(input, source = 'input') {
         connectionId: decode(() => decodeRuntimePolicyEntityId(input.connectionId)),
         slug: decode(() => decodeConnectionSlug(input.slug)),
         providerType,
+        name: input.name === undefined || input.name === null
+            ? null
+            : decode(() => decodeConnectionName(input.name)),
         suppliedSecret,
         baseUrl,
         enabledModelIds: normalized.enabledModelIds,
@@ -95,6 +98,7 @@ export async function readConnectionOnboardingIntent(root) {
         'connectionId',
         'slug',
         'providerType',
+        'name',
         'suppliedSecret',
         'baseUrl',
         'enabledModelIds',
@@ -110,6 +114,7 @@ export async function readConnectionOnboardingIntent(root) {
         'connectionId',
         'slug',
         'providerType',
+        'name',
         'suppliedSecret',
         'baseUrl',
         'enabledModelIds',
@@ -131,6 +136,7 @@ export async function readConnectionOnboardingIntent(root) {
         providerType: raw.providerType,
         connectionId: raw.connectionId,
         slug: raw.schemaVersion === 1 ? deriveLegacyIntentPlaceholderSlug(raw.providerType) : raw.slug,
+        name: raw.name,
         suppliedSecret: raw.suppliedSecret,
         baseUrl: raw.baseUrl,
         enabledModelIds: raw.enabledModelIds,
@@ -231,7 +237,9 @@ function decodeOAuthTarget(value) {
     throw codecError('invalid_document', 'OAuth enrollment target kind is invalid');
 }
 function isOAuthProvider(providerType) {
-    return providerType === 'openai-codex' || providerType === 'xai-oauth';
+    return (providerType === 'openai-codex' ||
+        providerType === 'xai-oauth' ||
+        providerType === 'github-copilot');
 }
 function decodeOAuthAttemptId(value, source) {
     if (typeof value !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value)) {

package/node_modules/@maka/storage/dist/session-copy-cleanup.js

@@ -261,7 +261,7 @@ class SqliteSessionCopyCleanupStore {
                 creation: {
                     kind: creation.kind,
                     sourceSessionId: creation.sourceSessionId,
-                    sourceTurnId: creation.sourceTurnId,
+                    ...(creation.sourceTurnId === undefined ? {} : { sourceTurnId: creation.sourceTurnId }),
                     ...(creation.intent ? { intent: creation.intent } : {}),
                 },
             };
@@ -365,7 +365,9 @@ function normalizeCreationLease(creation) {
         sessionId: normalizeSessionId(creation.sessionId),
         kind: creation.kind,
         sourceSessionId: normalizeSessionId(creation.sourceSessionId),
-        sourceTurnId: normalizeSessionId(creation.sourceTurnId),
+        ...(creation.sourceTurnId === undefined
+            ? {}
+            : { sourceTurnId: normalizeSessionId(creation.sourceTurnId) }),
         ...(creation.intent === 'side_conversation' ? { intent: creation.intent } : {}),
         ownerId: normalizeOwnerId(creation.ownerId),
     };

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

@@ -221,6 +221,26 @@ class SqliteSessionStore {
             ? message
             : undefined;
     }
+    async readWorkHubStopRequest(delegationId) {
+        const message = await this.readWorkHubCoordinationMessage(`whq_${workHubIdentitySuffix(delegationId)}`);
+        return message?.type === 'workhub_coordination' && message.kind === 'delegation_stop_requested'
+            ? message
+            : undefined;
+    }
+    async readWorkHubStopResolution(delegationId) {
+        const message = await this.readWorkHubCoordinationMessage(`whz_${workHubIdentitySuffix(delegationId)}`);
+        return message?.type === 'workhub_coordination' && message.kind === 'delegation_stop_resolved'
+            ? message
+            : undefined;
+    }
+    async claimWorkHubAction(claim) {
+        await this.ensureReady();
+        return this.metadata.claimWorkHubAction(claim);
+    }
+    async readWorkHubActionClaim(actionId) {
+        await this.ensureReady();
+        return this.metadata.readWorkHubActionClaim(actionId);
+    }
     async readWorkHubCoordinationMessage(messageId) {
         await this.ensureReady();
         const throughSequence = await this.metadata.readTranscriptHighWater(WORKHUB_COORDINATION_SESSION_ID);
@@ -443,6 +463,10 @@ class SqliteSessionStore {
         await this.ensureReady();
         return this.metadata.hasCancelledMessageAdmission(sessionId, messageId);
     }
+    async claimMessageAdmissionCancellation(sessionId, messageId, claimId) {
+        await this.ensureReady();
+        return this.metadata.claimMessageAdmissionCancellation(sessionId, messageId, claimId);
+    }
     async listMessageAdmissions(sessionId) {
         await this.ensureReady();
         return this.metadata.listMessageAdmissions(sessionId);
@@ -784,15 +808,24 @@ function isValidConversationCopyLineage(header) {
         return false;
     }
     if (copy.kind === 'branch') {
-        return (header.parentSessionId === copy.sourceSessionId &&
-            header.branchOfTurnId === copy.sourceTurnId &&
-            header.revisionRootSessionId === undefined &&
+        const revisionClear = header.revisionRootSessionId === undefined &&
             header.revisionParentSessionId === undefined &&
             header.revisionOfTurnId === undefined &&
             header.revisionIndex === undefined &&
-            header.revisionState === undefined);
-    }
-    return (header.revisionParentSessionId === copy.sourceSessionId &&
+            header.revisionState === undefined;
+        if (!revisionClear || header.parentSessionId !== copy.sourceSessionId) {
+            return false;
+        }
+        // An empty copy (absent `sourceTurnId`) records provenance
+        // (`parentSessionId`) but must not fabricate a `branchOfTurnId`, and is only
+        // valid for a side conversation; a through-turn copy must anchor to it.
+        return copy.sourceTurnId === undefined
+            ? header.branchOfTurnId === undefined && copy.intent === 'side_conversation'
+            : header.branchOfTurnId === copy.sourceTurnId;
+    }
+    // Revision copies always carry a turn boundary (enforced at decode).
+    return (copy.sourceTurnId !== undefined &&
+        header.revisionParentSessionId === copy.sourceSessionId &&
         header.revisionOfTurnId === copy.sourceTurnId);
 }
 function isValidSubagentSessionLineage(header) {

package/node_modules/@maka/storage/dist/sqlite-runtime-store.js

@@ -216,19 +216,17 @@ export class SqliteRuntimeStore {
     }
     async importConversationCopyRuntimeEvents(sessionId, batches) {
         assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
-        const runIds = new Set();
         const canonicalBatches = batches.map(({ runId, events }) => {
             assertRuntimeStorageSafeId(runId, 'Invalid run id');
-            if (runIds.has(runId)) {
-                throw new Error(`Conversation copy contains duplicate run ${runId}`);
-            }
-            runIds.add(runId);
             return {
                 runId,
                 events: events.map(canonicalizeRuntimeEventForStorage),
             };
         });
         const canonicalEvents = canonicalBatches.flatMap(({ events }) => events);
+        if (new Set(canonicalEvents.map(({ id }) => id)).size !== canonicalEvents.length) {
+            throw new Error('Conversation copy contains duplicate RuntimeEvents');
+        }
         for (const { runId, events } of canonicalBatches) {
             for (const event of events) {
                 assertNoReservedWorkspaceAuthorityAppend(event);
@@ -245,7 +243,12 @@ export class SqliteRuntimeStore {
             throw new Error(`Conversation copy RuntimeEvent ledger is corrupt: ${scan.issues[0]?.code ?? 'unknown'}`);
         }
         this.transaction(() => {
+            const eventsByRun = new Map();
             for (const { runId, events } of canonicalBatches) {
+                eventsByRun.set(runId, [...(eventsByRun.get(runId) ?? []), ...events]);
+            }
+            const newRunIds = new Set();
+            for (const [runId, events] of eventsByRun) {
                 const existing = this.db
                     .prepare(`
               SELECT event_id, session_id, invocation_id, run_id, turn_id, payload_json
@@ -257,10 +260,14 @@ export class SqliteRuntimeStore {
                 if (existing.length > 0 && !isDeepStrictEqual(existing, events)) {
                     throw new Error(`Conversation copy RuntimeEvent identity conflict for run ${runId}`);
                 }
-                if (existing.length === 0) {
-                    for (const event of events)
-                        this.insertRuntimeEvent(event, event.ts, true);
-                }
+                if (existing.length === 0)
+                    newRunIds.add(runId);
+            }
+            for (const { runId, events } of canonicalBatches) {
+                if (!newRunIds.has(runId))
+                    continue;
+                for (const event of events)
+                    this.insertRuntimeEvent(event, event.ts, true);
             }
             if (canonicalEvents.some(isToolLedgerBearingEvent)) {
                 this.rebuildToolProjectionsFromRuntimeEventsSync(sessionId);

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

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-export const SQLITE_SESSION_METADATA_SCHEMA_VERSION = 36;
+export const SQLITE_SESSION_METADATA_SCHEMA_VERSION = 38;
 export const SQLITE_SESSION_MESSAGE_CHUNK_BYTES = 64 * 1024;
 export const SQLITE_SESSION_MESSAGE_CHUNK_MARKER = '{"$maka":"session-message-chunks-v1"}';
 export const SQLITE_AGENT_GRAPH_CONTROL_TABLES = [
@@ -1237,6 +1237,32 @@ const MIGRATIONS = new Map([
     SELECT 1;
   `,
     ],
+    [
+        37,
+        `
+    ALTER TABLE cancelled_message_admissions
+      ADD COLUMN cancellation_claim_id TEXT;
+  `,
+    ],
+    [
+        38,
+        `
+    -- The one global owner of a WorkHub action identity. It deliberately has no
+    -- Session foreign key: the claim must outlive removal of the target Session
+    -- so a committed destructive claim still converges after that removal.
+    CREATE TABLE IF NOT EXISTS workhub_action_claims (
+      action_id TEXT PRIMARY KEY,
+      operation TEXT NOT NULL CHECK (
+        operation IN (
+          'answer_here', 'clarify', 'delegate_existing', 'create_new', 'replace', 'stop'
+        )
+      ),
+      action_fingerprint TEXT NOT NULL,
+      subject TEXT NOT NULL,
+      claimed_at INTEGER NOT NULL CHECK (claimed_at >= 0)
+    );
+  `,
+    ],
 ]);
 if (MIGRATIONS.size !== SQLITE_SESSION_METADATA_SCHEMA_VERSION) {
     throw new Error('SQLite session metadata migrations contain a duplicate or missing version');
@@ -1282,12 +1308,13 @@ export function migrateSqliteSessionMetadataDatabase(db, options = {}) {
             const sql = MIGRATIONS.get(version);
             if (!sql)
                 throw new Error(`Missing SQLite session metadata migration ${version}`);
-            // Versions 32 and 35 each add one column, and the post-merge convergence
+            // Versions 32, 35, and 37 each add one column, and the post-merge convergence
             // path can replay them onto a database that already carries the current
             // table shape. SQLite has no `ADD COLUMN IF NOT EXISTS`, so the guards
             // live here.
             const columnAlreadyPresent = (version === 32 && hasColumn(db, 'message_admissions', 'submitted_intent_json')) ||
-                (version === 35 && hasColumn(db, 'message_admissions', 'skill_invocation_json'));
+                (version === 35 && hasColumn(db, 'message_admissions', 'skill_invocation_json')) ||
+                (version === 37 && hasColumn(db, 'cancelled_message_admissions', 'cancellation_claim_id'));
             if (!columnAlreadyPresent) {
                 db.exec(sql);
             }

package/node_modules/@maka/storage/dist/sqlite-session-metadata-store.js

@@ -1250,6 +1250,15 @@ export class SqliteSessionMetadataStore {
                     .update(assignment.replacesDelegationId)
                     .digest('hex')
                     .slice(0, 48);
+                const stopRequest = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `whq_${abortSuffix}`);
+                if (stopRequest) {
+                    const stopResolution = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `whz_${abortSuffix}`);
+                    if (stopResolution?.type !== 'workhub_coordination' ||
+                        stopResolution.kind !== 'delegation_stop_resolved' ||
+                        stopResolution.outcome !== 'not_owned') {
+                        throw new SessionMetadataConflictError('WorkHub delegation already has a stop claim');
+                    }
+                }
                 const existingAbort = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `whb_${abortSuffix}`);
                 if (existingAbort) {
                     throw new SessionMetadataConflictError('WorkHub delegation replacement is aborted');
@@ -1348,6 +1357,106 @@ export class SqliteSessionMetadataStore {
             return row !== undefined;
         });
     }
+    /**
+     * Binds one WorkHub action identity to one exact operation, for good.
+     *
+     * Every other durable WorkHub record is keyed by what it is about, so none of
+     * them can see an action id that moved to a second delegation or a second
+     * disposition. This row is the global owner that rejects both, and it is
+     * written before the action's effect so a rejected or recovering attempt can
+     * never leak its identity into a different operation.
+     */
+    async claimWorkHubAction(claim) {
+        this.assertOpen();
+        assertSafeSessionId(claim.actionId);
+        assertSafeSessionId(claim.subject);
+        if (!/^sha256:[a-f0-9]{64}$/u.test(claim.actionFingerprint)) {
+            throw new SessionMetadataConflictError('Invalid WorkHub action fingerprint');
+        }
+        return this.transaction(() => {
+            const existing = this.readWorkHubActionClaimSync(claim.actionId);
+            if (existing) {
+                return existing.operation === claim.operation &&
+                    existing.actionFingerprint === claim.actionFingerprint &&
+                    existing.subject === claim.subject
+                    ? 'same_claim'
+                    : 'conflict';
+            }
+            this.db
+                .prepare(`
+          INSERT INTO workhub_action_claims(
+            action_id, operation, action_fingerprint, subject, claimed_at
+          ) VALUES (?, ?, ?, ?, ?)
+        `)
+                .run(claim.actionId, claim.operation, claim.actionFingerprint, claim.subject, this.now());
+            return 'claimed';
+        });
+    }
+    async readWorkHubActionClaim(actionId) {
+        this.assertOpen();
+        assertSafeSessionId(actionId);
+        return this.readTransaction(() => this.readWorkHubActionClaimSync(actionId));
+    }
+    readWorkHubActionClaimSync(actionId) {
+        const row = this.db
+            .prepare('SELECT operation, action_fingerprint, subject FROM workhub_action_claims WHERE action_id = ?')
+            .get(actionId);
+        if (!row)
+            return undefined;
+        if (!isWorkHubActionOperation(row.operation) ||
+            typeof row.action_fingerprint !== 'string' ||
+            !/^sha256:[a-f0-9]{64}$/u.test(row.action_fingerprint) ||
+            typeof row.subject !== 'string') {
+            throw new SessionMetadataConflictError('Invalid WorkHub action claim row');
+        }
+        return {
+            actionId,
+            operation: row.operation,
+            actionFingerprint: row.action_fingerprint,
+            subject: row.subject,
+        };
+    }
+    async claimMessageAdmissionCancellation(sessionId, messageId, claimId) {
+        this.assertOpen();
+        assertSafeSessionId(sessionId);
+        assertSafeSessionId(messageId);
+        assertSafeSessionId(claimId);
+        return this.transaction(() => {
+            const cancelled = this.db
+                .prepare('SELECT cancellation_claim_id FROM cancelled_message_admissions WHERE session_id = ? AND message_id = ?')
+                .get(sessionId, messageId);
+            if (cancelled) {
+                return cancelled.cancellation_claim_id === claimId ? 'same_claim' : 'already_cancelled';
+            }
+            const admission = this.db
+                .prepare(`
+          SELECT submitted_content_digest, submitted_placement
+          FROM message_admissions
+          WHERE session_id = ? AND message_id = ?
+        `)
+                .get(sessionId, messageId);
+            if (typeof admission?.submitted_content_digest !== 'string' ||
+                (admission.submitted_placement !== 'current_turn' &&
+                    admission.submitted_placement !== 'next_turn')) {
+                throw new SessionMetadataConflictError('Message admission cancellation identity conflict');
+            }
+            this.db
+                .prepare(`
+          INSERT INTO cancelled_message_admissions(
+            session_id, message_id, submitted_content_digest, submitted_placement,
+            cancellation_claim_id
+          ) VALUES (?, ?, ?, ?, ?)
+        `)
+                .run(sessionId, messageId, admission.submitted_content_digest, admission.submitted_placement, claimId);
+            const deleted = this.db
+                .prepare('DELETE FROM message_admissions WHERE session_id = ? AND message_id = ?')
+                .run(sessionId, messageId);
+            if (deleted.changes !== 1) {
+                throw new SessionMetadataConflictError('Message admission cancellation identity conflict');
+            }
+            return 'cancelled_by_claim';
+        });
+    }
     async listMessageAdmissions(sessionId) {
         this.assertOpen();
         assertSafeSessionId(sessionId);
@@ -4938,6 +5047,14 @@ function readStoredMessageRecordJson(db, sessionId, sequence, row) {
     }
     return recordJson;
 }
+function isWorkHubActionOperation(value) {
+    return (value === 'answer_here' ||
+        value === 'clarify' ||
+        value === 'delegate_existing' ||
+        value === 'create_new' ||
+        value === 'replace' ||
+        value === 'stop');
+}
 function sameWorkHubAssignmentRequest(existing, requested) {
     return isDeepStrictEqual({
         actionId: existing.actionId,

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

@@ -117,6 +117,7 @@ class SqliteTelemetryRepo {
             range: { from, to },
             totalRequests: rows.length,
             totalCostUsd: sum(rows.map((row) => row.costUsd)),
+            totalDurationMs: sum(rows.map((row) => row.latencyMs)),
             totalTokens: {
                 input: sum(rows.map((row) => row.inputTokens)),
                 output: sum(rows.map((row) => row.outputTokens)),
@@ -131,6 +132,15 @@ class SqliteTelemetryRepo {
             errorRequests: rows.filter((row) => row.status === 'error').length,
         });
     }
+    toolSummary(query) {
+        this.assertReady();
+        const { from, to } = resolveRange(query.range);
+        const rows = this.filteredToolRows(query, from, to);
+        return detached({
+            requests: rows.length,
+            durationMs: sum(rows.map((row) => row.durationMs)),
+        });
+    }
     buckets(query, groupBy) {
         this.assertReady();
         const { from, to } = resolveRange(query.range);
@@ -226,13 +236,22 @@ class SqliteTelemetryRepo {
         });
     }
     filteredToolRows(query, from, to) {
-        return this.readToolRows().filter((row) => {
-            if (row.ts < from || row.ts > to)
-                return false;
+        // One filter policy for every tool read — summary, buckets, and logs — so
+        // two views of one query cannot disagree. Fields the narrower query types
+        // do not carry simply never match a row out of range.
+        return this.readToolRows(from, to).filter((row) => {
             if (query.toolName && row.toolName !== query.toolName)
                 return false;
             if (query.status && query.status !== 'all' && row.status !== query.status)
                 return false;
+            if ('sessionId' in query && query.sessionId && row.sessionId !== query.sessionId) {
+                return false;
+            }
+            if ('providerId' in query && query.providerId && row.providerId !== query.providerId) {
+                return false;
+            }
+            if ('modelId' in query && query.modelId && row.modelId !== query.modelId)
+                return false;
             return true;
         });
     }
@@ -245,10 +264,14 @@ class SqliteTelemetryRepo {
                WHERE ts >= ? AND ts <= ?`)
             .all(...(sessionId ? [sessionId, from, to] : [from, to])).map((row) => decodePersistedLlmCallRecord(JSON.parse(row.record_json)));
     }
-    readToolRows() {
+    // The ts range goes into the query, not the decode: the invocation ledger
+    // has no retention, and a full-table decode per summary read would only grow
+    // with it. The `(ts, id)` index answers the range; the remaining filters run
+    // over the few decoded rows it returns.
+    readToolRows(from, to) {
         return this.#lease.database
-            .prepare('SELECT record_json FROM usage_tool_invocations')
-            .all().map((row) => decodePersistedToolInvocationRecord(JSON.parse(row.record_json)));
+            .prepare('SELECT record_json FROM usage_tool_invocations WHERE ts >= ? AND ts <= ?')
+            .all(from, to).map((row) => decodePersistedToolInvocationRecord(JSON.parse(row.record_json)));
     }
     enqueueMutation(operation) {
         this.assertReady();

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

@@ -282,12 +282,13 @@ function createWriterFacade(lease, telemetry, modelCalls, pricing) {
         [writerBrand]: true,
         telemetry: {
             summary: (query) => read(() => telemetry.summary(query)),
+            toolSummary: (query) => read(() => telemetry.toolSummary(query)),
             buckets: (query, groupBy) => read(() => telemetry.buckets(query, groupBy)),
             logs: (query, offset, limit) => read(() => telemetry.logs(query, offset, limit)),
             toolLogs: (query, offset, limit) => read(() => telemetry.toolLogs(query, offset, limit)),
             latestLlmRuntimeProbe: (connectionSlug, modelId) => read(() => telemetry.latestLlmRuntimeProbe(connectionSlug, modelId)),
             recordLlmCall: (record) => admitSessionUsageMutation(record.sessionId, () => telemetry.insertLlmCall(record)),
-            recordToolInvocation: (record) => admit(() => run(() => telemetry.insertToolInvocation(record))),
+            recordToolInvocation: (record) => admitSessionUsageMutation(record.sessionId, () => telemetry.insertToolInvocation(record)),
         },
         modelCalls: {
             modelCallAttempts: (range, sessionId) => read(() => modelCalls.read(range, sessionId)),
@@ -313,6 +314,7 @@ function createWriterFacade(lease, telemetry, modelCalls, pricing) {
 function telemetryReader(repo, run) {
     return Object.freeze({
         summary: (query) => run(() => repo.summary(query)),
+        toolSummary: (query) => run(() => repo.toolSummary(query)),
         buckets: (query, groupBy) => run(() => repo.buckets(query, groupBy)),
         logs: (query, offset, limit) => run(() => repo.logs(query, offset, limit)),
         toolLogs: (query, offset, limit) => run(() => repo.toolLogs(query, offset, limit)),

package/package.json

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