maka-agent 0.2.0-dev.31.20260913 → 0.2.0-dev.32.20260914

package/node_modules/@maka/storage/dist/claude-code-transcript-lineage.js

@@ -20,6 +20,102 @@ function stringField(record, key) {
     const value = record[key];
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
+/**
+ * Incremental lineage index used by large transcript imports.
+ *
+ * It retains only graph identity, never complete transcript records. Once the
+ * first pass is complete, independent filters can replay the fixed source
+ * snapshot while applying the same de-duplication and rewind selection as
+ * {@link resolveTranscriptLineage}.
+ */
+export class TranscriptLineageIndexer {
+    #nodes = new Map();
+    #duplicates = 0;
+    #compactBoundaries = 0;
+    accept(record) {
+        const uuid = stringField(record, 'uuid');
+        if (uuid !== undefined && this.#nodes.has(uuid)) {
+            this.#duplicates += 1;
+            return;
+        }
+        if (record.subtype === 'compact_boundary')
+            this.#compactBoundaries += 1;
+        if (uuid === undefined)
+            return;
+        const parentUuid = transcriptParentUuid(record);
+        this.#nodes.set(uuid, {
+            uuid,
+            ...(parentUuid !== undefined ? { parentUuid } : {}),
+            isPrompt: isPromptRecord(record),
+            isSidechain: record.isSidechain === true,
+        });
+    }
+    finish() {
+        const main = [...this.#nodes.values()].filter((node) => !node.isSidechain);
+        const present = new Set(main.map((node) => node.uuid));
+        const childrenOf = new Map();
+        const promptsOf = new Map();
+        for (const node of main) {
+            const key = node.parentUuid !== undefined && present.has(node.parentUuid) ? node.parentUuid : ROOT_KEY;
+            const children = childrenOf.get(key);
+            if (children)
+                children.push(node.uuid);
+            else
+                childrenOf.set(key, [node.uuid]);
+            if (node.isPrompt) {
+                const prompts = promptsOf.get(key);
+                if (prompts)
+                    prompts.push(node.uuid);
+                else
+                    promptsOf.set(key, [node.uuid]);
+            }
+        }
+        const withdrawn = [];
+        for (const prompts of promptsOf.values()) {
+            if (prompts.length > 1)
+                withdrawn.push(...prompts.slice(0, -1));
+        }
+        const dropped = new Set();
+        const stack = [...withdrawn];
+        while (stack.length > 0) {
+            const uuid = stack.pop();
+            if (dropped.has(uuid))
+                continue;
+            dropped.add(uuid);
+            for (const child of childrenOf.get(uuid) ?? [])
+                stack.push(child);
+        }
+        return new FinishedTranscriptLineageIndex(dropped, withdrawn.length, this.#duplicates, this.#compactBoundaries);
+    }
+}
+class FinishedTranscriptLineageIndex {
+    withdrawnPrompts;
+    duplicates;
+    compactBoundaries;
+    #dropped;
+    abandoned;
+    constructor(dropped, withdrawnPrompts, duplicates, compactBoundaries) {
+        this.withdrawnPrompts = withdrawnPrompts;
+        this.duplicates = duplicates;
+        this.compactBoundaries = compactBoundaries;
+        this.#dropped = dropped;
+        this.abandoned = this.#dropped.size;
+    }
+    createFilter() {
+        const seen = new Set();
+        return {
+            keep: (record) => {
+                const uuid = stringField(record, 'uuid');
+                if (uuid === undefined)
+                    return true;
+                if (seen.has(uuid))
+                    return false;
+                seen.add(uuid);
+                return !this.#dropped.has(uuid);
+            },
+        };
+    }
+}
 /**
  * The parent a record hangs from: `parentUuid`, and nothing else.
  *
@@ -52,86 +148,19 @@ export function isPromptRecord(record) {
         block !== null &&
         block.type === 'tool_result');
 }
-/**
- * Drop repeats of a `uuid` already seen, keeping the first.
- *
- * A record written twice replays whatever identity it carries — a prompt, a
- * turn boundary, a tool call. Measured: 3 repeats across 1130 local
- * transcripts. Rare enough to be invisible in testing, permanent once it is
- * persisted as canonical history.
- */
-function deduplicate(records) {
-    const seen = new Set();
-    const kept = [];
-    let duplicates = 0;
-    for (const record of records) {
-        const uuid = stringField(record, 'uuid');
-        if (uuid !== undefined) {
-            if (seen.has(uuid)) {
-                duplicates += 1;
-                continue;
-            }
-            seen.add(uuid);
-        }
-        kept.push(record);
-    }
-    return { kept, duplicates };
-}
 const ROOT_KEY = ' root';
 export function resolveTranscriptLineage(rawRecords) {
-    const { kept: records, duplicates } = deduplicate(rawRecords);
-    const compactBoundaries = records.filter((r) => r.subtype === 'compact_boundary').length;
-    const main = records.filter((r) => r.isSidechain !== true && stringField(r, 'uuid') !== undefined);
-    if (main.length === 0) {
-        return { records, abandoned: 0, withdrawnPrompts: 0, duplicates, compactBoundaries };
-    }
-    const present = new Set(main.map((r) => stringField(r, 'uuid')));
-    const childrenOf = new Map();
-    for (const record of main) {
-        const parent = transcriptParentUuid(record);
-        // A parent outside this file is no parent: the record roots its own
-        // segment rather than being orphaned into nothing.
-        const key = parent !== undefined && present.has(parent) ? parent : ROOT_KEY;
-        const siblings = childrenOf.get(key);
-        if (siblings)
-            siblings.push(record);
-        else
-            childrenOf.set(key, [record]);
-    }
-    // Among sibling prompts the last written is the one that was asked; the
-    // earlier ones were withdrawn by the edit that replaced them.
-    const withdrawn = [];
-    for (const [, siblings] of childrenOf) {
-        const prompts = siblings.filter(isPromptRecord);
-        if (prompts.length < 2)
-            continue;
-        withdrawn.push(...prompts.slice(0, -1));
-    }
-    if (withdrawn.length === 0) {
-        return { records, abandoned: 0, withdrawnPrompts: 0, duplicates, compactBoundaries };
-    }
-    // A withdrawn prompt takes its subtree: the answer to a question that was
-    // never asked is not conversation either.
-    const dropped = new Set();
-    const stack = [...withdrawn];
-    while (stack.length > 0) {
-        const record = stack.pop();
-        const uuid = stringField(record, 'uuid');
-        if (dropped.has(uuid))
-            continue;
-        dropped.add(uuid);
-        for (const child of childrenOf.get(uuid) ?? [])
-            stack.push(child);
-    }
-    const resolved = records.filter((record) => {
-        const uuid = stringField(record, 'uuid');
-        return uuid === undefined || !dropped.has(uuid);
-    });
+    const indexer = new TranscriptLineageIndexer();
+    for (const record of rawRecords)
+        indexer.accept(record);
+    const index = indexer.finish();
+    const filter = index.createFilter();
+    const resolved = rawRecords.filter((record) => filter.keep(record));
     return {
         records: resolved,
-        abandoned: dropped.size,
-        withdrawnPrompts: withdrawn.length,
-        duplicates,
-        compactBoundaries,
+        abandoned: index.abandoned,
+        withdrawnPrompts: index.withdrawnPrompts,
+        duplicates: index.duplicates,
+        compactBoundaries: index.compactBoundaries,
     };
 }

package/node_modules/@maka/storage/dist/legacy-run-header.js

@@ -232,7 +232,7 @@ export function invocationOpeningFromLegacyRunHeader(header) {
     };
 }
 function invocationRouteFromLegacyRunHeader(header) {
-    if (header.llmConnectionId === undefined) {
+    if (header.llmConnectionId === undefined || header.backendKind === 'plugin-executor') {
         return {
             provenance: 'unknown',
             backendKind: header.backendKind,
@@ -320,7 +320,7 @@ function isLegacyContinuationSource(value) {
 }
 /** `'fake'` stays accepted: runs written by builds that shipped FakeBackend must keep decoding (#3211). */
 function isPersistedBackendKind(value) {
-    return value === 'ai-sdk' || value === 'fake';
+    return value === 'ai-sdk' || value === 'plugin-executor' || value === 'fake';
 }
 function isSha256Digest(value) {
     return typeof value === 'string' && /^sha256:[0-9a-f]{64}$/.test(value);

package/node_modules/@maka/storage/dist/model-call-usage-sql.js

@@ -34,7 +34,7 @@ export const CACHE_READ_TOKENS = `
  * when the price was simply never resolved.
  */
 export const PRICED_COST = `CASE WHEN cost_basis = 'priced' THEN COALESCE(cost_usd, 0) ELSE 0 END`;
-/** Mirrors `usageStatusForAttempt`: only a provider failure is an error. */
+/** Only a provider failure is an error. */
 const ERROR_ROW = `status = 'failed'`;
 export const TOKEN_SUMS = `
   SUM(COALESCE(input_tokens, 0)) AS input,

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

@@ -22,6 +22,7 @@ import { createSqliteSessionMetadataStore, SessionMetadataVersionConflictError,
 import { isDiscardableConversationCopy } from './session-conversation-copy.js';
 import { acquireOperationalStateDatabase, OPERATIONAL_STATE_DATABASE_NAME, } from './operational-state-store.js';
 import { DEFAULT_SESSION_NAME, normalizeUserSessionName } from '@maka/core/session-name';
+import { isExecutorId } from '@maka/core/executor-id';
 import { decodeCanonicalMessage, deriveTurnRecords, isSessionBlockedReason, isSessionConversationCopy, isSubagentSessionParent, isSubagentSessionRuntime, isSubagentSessionSpawn, isSessionStatus, isWorkHubCoordinationSessionId, subagentSessionRuntimeSummary, WORKHUB_COORDINATION_SESSION_ID, WORKHUB_COORDINATION_SESSION_ROLE, } from '@maka/core/session';
 import { isCollaborationMode } from '@maka/core/collaboration';
 import { isOrchestrationMode } from '@maka/core/orchestration';
@@ -609,7 +610,8 @@ function buildSessionHeader(workspaceRoot, input, sessionId = randomUUID(), conv
         ...(input.revisionIndex !== undefined ? { revisionIndex: input.revisionIndex } : {}),
         ...(input.revisionState ? { revisionState: input.revisionState } : {}),
         hasUnread: false,
-        backend: 'ai-sdk',
+        backend: input.executorId ? 'plugin-executor' : 'ai-sdk',
+        ...(input.executorId ? { executorId: input.executorId } : {}),
         ...(input.llmConnectionId === undefined ? {} : { llmConnectionId: input.llmConnectionId }),
         llmConnectionSlug: input.llmConnectionSlug,
         // A subagent Session's route is chosen by the spawn that created it and is
@@ -669,6 +671,7 @@ export function normalizeSessionHeader(header, sessionId = header.id) {
         (header.lastReadMessageId === undefined || typeof header.lastReadMessageId === 'string') &&
         typeof header.hasUnread === 'boolean' &&
         isPersistedBackendKind(header.backend) &&
+        isValidExecutorSelection(header) &&
         (header.llmConnectionId === undefined ||
             (typeof header.llmConnectionId === 'string' && header.llmConnectionId.length > 0)) &&
         typeof header.llmConnectionSlug === 'string' &&
@@ -805,7 +808,13 @@ function isValidSubagentSessionLineage(header) {
  * FakeBackend fail `normalizeSessionHeader` and read back as malformed (#3211).
  */
 function isPersistedBackendKind(value) {
-    return value === 'ai-sdk' || value === 'fake';
+    return value === 'ai-sdk' || value === 'plugin-executor' || value === 'fake';
+}
+function isValidExecutorSelection(header) {
+    if (header.backend === 'plugin-executor') {
+        return isExecutorId(header.executorId);
+    }
+    return header.executorId === undefined;
 }
 function isFiniteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value);
@@ -871,6 +880,7 @@ function toSummary(header) {
         ...(header.revisionIndex !== undefined ? { revisionIndex: header.revisionIndex } : {}),
         ...(header.revisionState ? { revisionState: header.revisionState } : {}),
         backend: header.backend,
+        ...(header.executorId ? { executorId: header.executorId } : {}),
         ...(header.llmConnectionId === undefined ? {} : { llmConnectionId: header.llmConnectionId }),
         llmConnectionSlug: header.llmConnectionSlug,
         connectionLocked: header.connectionLocked,

package/node_modules/@maka/storage/dist/sqlite-long-term-memory-store.js

@@ -555,14 +555,12 @@ export class SqliteMemoryItemStore {
         });
         return this.#readSnapshot(() => {
             const rows = this.#database.prepare(query.sql).all(...query.parameters);
-            return rows.map((row) => {
+            const itemIds = rows.map((row) => {
                 if (typeof row.item_id !== 'string')
                     throw new Error('Invalid Memory Item search result');
-                const record = this.#readItemRecord(row.item_id);
-                if (!record)
-                    throw new Error(`Memory Item ${row.item_id} disappeared during read`);
-                return record;
+                return row.item_id;
             });
+            return this.#readItemRecords(itemIds);
         });
     }
     async readOperation(operationId) {
@@ -685,13 +683,55 @@ export class SqliteMemoryItemStore {
          FROM memory_item_sources WHERE item_id = ? ORDER BY event_id ASC
          LIMIT ${MAX_SOURCES_PER_ITEM + 1}`)
             .all(itemId);
-        assertChildCardinality('keys', keys.length, MAX_KEYS_PER_ITEM);
-        assertChildCardinality('sources', sources.length, MAX_SOURCES_PER_ITEM);
-        return {
-            item: decodeItem(row),
-            keys: keys.map(decodeKey),
-            sources: sources.map(decodeSource),
-        };
+        return decodeItemRecord(row, keys, sources);
+    }
+    #readItemRecords(itemIds) {
+        if (itemIds.length === 0)
+            return [];
+        if (itemIds.length === 1) {
+            const record = this.#readItemRecord(itemIds[0]);
+            if (!record)
+                throw new Error(`Memory Item ${itemIds[0]} disappeared during read`);
+            return [record];
+        }
+        const rows = this.#database
+            .prepare(`SELECT * FROM memory_items WHERE item_id IN (${placeholders(itemIds.length)})`)
+            .all(...itemIds);
+        const items = new Map(rows.map((row) => [row.item_id, row]));
+        const keys = this.#readItemChildren('keys', itemIds, ([, key_text, normalized_key, key_type, key_origin]) => ({
+            key_text,
+            normalized_key,
+            key_type,
+            key_origin,
+        }));
+        const sources = this.#readItemChildren('sources', itemIds, ([, session_id, run_id, turn_id, event_id]) => ({ session_id, run_id, turn_id, event_id }));
+        // IN queries need not return search order; preserve the ranked ID sequence.
+        return itemIds.map((itemId) => {
+            const row = items.get(itemId);
+            if (!row)
+                throw new Error(`Memory Item ${itemId} disappeared during read`);
+            return decodeItemRecord(row, keys.get(itemId) ?? [], sources.get(itemId) ?? []);
+        });
+    }
+    #readItemChildren(child, itemIds, toRow) {
+        const statement = this.#database.prepare(buildMemoryChildBatchQuery(child, itemIds.length));
+        // Native array results avoid SQLite's per-column object property construction
+        // for as many as 25,700 sources. Column validation still happens in search order.
+        statement.setReturnArrays(true);
+        const rows = statement.all(...itemIds);
+        const grouped = new Map();
+        let previousItemId;
+        let children;
+        for (const row of rows) {
+            const itemId = row[0];
+            if (!children || itemId !== previousItemId) {
+                children = [];
+                grouped.set(itemId, children);
+                previousItemId = itemId;
+            }
+            children.push(toRow(row));
+        }
+        return grouped;
     }
     #requireItemRecord(itemId) {
         const record = this.#readItemRecord(itemId);
@@ -796,6 +836,31 @@ export function buildSqliteMemoryKeySearchQuery(input) {
         parameters,
     };
 }
+function buildMemoryChildBatchQuery(child, itemCount) {
+    const table = child === 'keys' ? 'memory_item_keys' : 'memory_item_sources';
+    const orderColumn = child === 'keys' ? 'normalized_key' : 'event_id';
+    const columns = child === 'keys'
+        ? 'c.key_text, c.normalized_key, c.key_type, c.key_origin'
+        : 'c.session_id, c.run_id, c.turn_id, c.event_id';
+    const maximum = child === 'keys' ? MAX_KEYS_PER_ITEM : MAX_SOURCES_PER_ITEM;
+    // Each composite primary key supplies at most maximum + 1 children per Item,
+    // including the overflow sentinel used by cardinality validation. A missing
+    // sentinel falls back to the last child, keeping corrupt child sets bounded.
+    // Fix Items as the outer loop so both indexes supply order without a temp sort.
+    return `
+    SELECT i.item_id, ${columns}
+    FROM memory_items i
+    CROSS JOIN ${table} c
+      ON c.item_id = i.item_id
+      AND c.${orderColumn} <= COALESCE(
+        (SELECT ${orderColumn} FROM ${table}
+         WHERE item_id = i.item_id ORDER BY ${orderColumn} ASC LIMIT 1 OFFSET ${maximum}),
+        (SELECT ${orderColumn} FROM ${table}
+         WHERE item_id = i.item_id ORDER BY ${orderColumn} DESC LIMIT 1)
+      )
+    WHERE i.item_id IN (${placeholders(itemCount)})
+    ORDER BY i.item_id ASC, c.${orderColumn} ASC`;
+}
 function normalizeMutations(mutations) {
     if (!Array.isArray(mutations) || mutations.length === 0) {
         throw new Error('Memory operation requires at least one mutation');
@@ -1108,6 +1173,15 @@ function mutationResult(mutationIndex, mutationType, item, outcome) {
         outcome,
     };
 }
+function decodeItemRecord(row, keys, sources) {
+    assertChildCardinality('keys', keys.length, MAX_KEYS_PER_ITEM);
+    assertChildCardinality('sources', sources.length, MAX_SOURCES_PER_ITEM);
+    return {
+        item: decodeItem(row),
+        keys: keys.map(decodeKey),
+        sources: sources.map(decodeSource),
+    };
+}
 function decodeItem(row) {
     const kind = requiredString(row.kind, 'kind');
     const statementType = requiredString(row.statement_type, 'statement_type');

package/node_modules/@maka/storage/dist/work-board-store.js

@@ -18,7 +18,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import { resolve } from 'node:path';
-import { WORK_BOARD_DEFAULT_PAGE_SIZE, applyWorkBoardItemPatch, archiveWorkBoardItem, decodeWorkBoardItem, isSafeWorkBoardId, normalizeCreateWorkBoardItemInput, normalizeUpdateWorkBoardItemInput, normalizeWorkBoardListQuery, unarchiveWorkBoardItem, } from '@maka/core/work-board';
+import { WORK_BOARD_DEFAULT_PAGE_SIZE, applyWorkBoardItemPatch, archiveWorkBoardItem, decodeWorkBoardItem, isSafeWorkBoardId, normalizeCreateWorkBoardItemInput, normalizeWorkBoardLinkedSession, normalizeUpdateWorkBoardItemInput, normalizeWorkBoardListQuery, unarchiveWorkBoardItem, } from '@maka/core/work-board';
 import { buildWorkBoardListStatement, encodeWorkBoardCursor, workBoardFilterFingerprint, } from './work-board-list-query.js';
 import { acquireOperationalStateDatabase, } from './operational-state-store.js';
 import { chainWrite } from './write-queue.js';
@@ -78,6 +78,7 @@ class SqliteWorkBoardStore {
             archived: false,
             creator: value.creator,
             provenance: value.provenance,
+            linkedSessions: [],
             createdAt: now,
             updatedAt: now,
         };
@@ -172,6 +173,41 @@ class SqliteWorkBoardStore {
             });
         });
     }
+    async linkSession(id, link, options = {}, now = Date.now()) {
+        const normalized = normalizeWorkBoardLinkedSession(link);
+        if (!normalized.ok)
+            throw storeError('invalid_input', normalized.message);
+        const expectedRevision = normalizeExpectedRevision(options);
+        assertValidNow(now);
+        let result;
+        await chainWrite(this.writeQueues, WORK_BOARD_WRITE_KEY, async () => {
+            this.#lease.transaction('write', () => {
+                const current = this.#requireItem(id);
+                assertExpectedRevision(expectedRevision, current);
+                const key = linkedSessionKey(normalized.value);
+                const linkedSessions = current.linkedSessions ?? [];
+                if (linkedSessions.some((entry) => linkedSessionKey(entry) === key)) {
+                    result = current;
+                    return;
+                }
+                const effectiveNow = Math.max(now, current.updatedAt);
+                // Single-link contract ({@link WORK_BOARD_MAX_LINKED_SESSIONS}): a
+                // board item owns at most one started Session at a time, so a freshly
+                // started Session replaces any previous link. This keeps
+                // `linkedSessions` bounded instead of growing without limit on
+                // repeated starts.
+                const next = {
+                    ...current,
+                    linkedSessions: [normalized.value],
+                    updatedAt: effectiveNow,
+                    revision: current.revision + 1,
+                };
+                this.#writeItem(next);
+                result = next;
+            });
+        });
+        return result;
+    }
     #readRow(id) {
         if (!isSafeWorkBoardId(id)) {
             throw storeError('invalid_input', 'Work Board item id is invalid');
@@ -261,3 +297,6 @@ function assertExpectedRevision(expected, item) {
 function storeError(code, message) {
     return new WorkBoardStoreError(code, message);
 }
+function linkedSessionKey(link) {
+    return `${link.profileId}\u0000${link.hostId}\u0000${link.sessionId}`;
+}

package/package.json

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