maka-agent 0.2.0-dev.46.20260922 → 0.2.0-dev.48.20260923

package/node_modules/@maka/storage/dist/mcp-config-store.js

@@ -16,9 +16,10 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { watch } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { MCP_CONFIG_VERSION, createDefaultMcpConfig, isNonLoopbackCleartextHttp, } from '@maka/core/mcp';
+import { basename, dirname, join } from 'node:path';
+import { MCP_CONFIG_VERSION, createDefaultMcpConfig, isNonLoopbackCleartextHttp, mcpConfigChangeRetiresCredentials, } from '@maka/core/mcp';
 import { writeAtomicFile } from './atomic-file-write.js';
 import { withProcessLifetimeFileUpdateLock } from './process-lifetime-file-update-lock.js';
 import { hardenDirectory } from './stable-storage.js';
@@ -30,6 +31,9 @@ const MAX_ID_LENGTH = 128;
 const MAX_STRING_LENGTH = 8_192;
 const MAX_CONFIG_BYTES = 1_048_576;
 const FORBIDDEN_KEYS = new Set(['__proto__', 'prototype', 'constructor']);
+// An atomic replace is a temp write plus a rename; one settle window turns
+// that burst into one notification.
+const CHANGE_SETTLE_MS = 150;
 export class McpConfigSourceError extends Error {
     reason;
     version;
@@ -54,6 +58,64 @@ export class McpServerExistsError extends Error {
 export function createMcpConfigStore(workspaceRoot) {
     return new FileMcpConfigStore(join(workspaceRoot, 'mcp.json'));
 }
+/** Watches the directory, not the file: an atomic replace renames a new
+ * inode over the old one, which ends a watch on the file itself. */
+export function subscribeMcpConfigFileChanges(path, listener) {
+    const name = basename(path);
+    let timer;
+    let watcher;
+    const settle = () => {
+        clearTimeout(timer);
+        timer = setTimeout(() => listener(), CHANGE_SETTLE_MS);
+    };
+    try {
+        watcher = watch(dirname(path), { persistent: false }, (_event, filename) => {
+            if (filename === null || filename.toString() === name)
+                settle();
+        });
+    }
+    catch (error) {
+        queueMicrotask(() => listener(error));
+        return () => { };
+    }
+    settle();
+    const stop = () => {
+        clearTimeout(timer);
+        watcher.close();
+    };
+    watcher.on('error', (error) => {
+        stop();
+        listener(error);
+    });
+    return stop;
+}
+export class McpConfigurationValidationError extends Error {
+    constructor(cause) {
+        super(cause instanceof Error ? cause.message : 'Invalid MCP configuration', { cause });
+        this.name = 'McpConfigurationValidationError';
+    }
+}
+/** Validate before retiring credentials, and retire before publishing the
+ * replacement. Both effects run under the config file's cross-process lock. */
+export function updateMcpConfiguration(store, prepare, retireCredentials) {
+    return store.transform(async (current) => {
+        const proposed = prepare(current);
+        let next;
+        try {
+            next = normalizeMcpConfig(proposed);
+            assertMcpEndpointPolicyOnChanges(current, next);
+        }
+        catch (error) {
+            throw new McpConfigurationValidationError(error);
+        }
+        for (const [serverId, previous] of Object.entries(current.mcpServers)) {
+            if (mcpConfigChangeRetiresCredentials(previous, next.mcpServers[serverId])) {
+                await retireCredentials(serverId, previous);
+            }
+        }
+        return next;
+    });
+}
 export function normalizeMcpConfig(value) {
     if (!isRecord(value))
         throw new Error('MCP config must be an object');
@@ -114,6 +176,21 @@ class FileMcpConfigStore {
             return this.withUpdateLock(() => this.readOrCreate());
         }
     }
+    subscribeChanges(listener) {
+        let stop;
+        let stopped = false;
+        void this.ensureDirectory().then(() => {
+            if (!stopped)
+                stop = subscribeMcpConfigFileChanges(this.path, listener);
+        }, (error) => {
+            if (!stopped)
+                listener(error);
+        });
+        return () => {
+            stopped = true;
+            stop?.();
+        };
+    }
     async transform(apply) {
         return this.withUpdateLock(async () => {
             const current = await this.readOrCreate();
@@ -280,6 +357,18 @@ function normalizeOAuth(value, serverId) {
     if (!isRecord(value))
         throw new Error(`${serverId}.oauth must be an object`);
     const result = {};
+    if (value.issuer !== undefined) {
+        const issuer = nonEmptyString(value.issuer, `${serverId}.oauth.issuer`);
+        const parsed = new URL(issuer);
+        if (!['https:', 'http:'].includes(parsed.protocol) ||
+            parsed.username ||
+            parsed.password ||
+            parsed.search ||
+            parsed.hash) {
+            throw new Error(`${serverId}.oauth.issuer must be an HTTP(S) issuer URL without credentials, query or fragment`);
+        }
+        result.issuer = issuer;
+    }
     if (value.clientId !== undefined) {
         result.clientId = nonEmptyString(value.clientId, `${serverId}.oauth.clientId`);
     }

package/node_modules/@maka/storage/dist/operational-state-store.js

@@ -138,6 +138,8 @@ class OperationalStateDatabaseOwner {
     references = 0;
     closed = false;
     transactionDepth = 0;
+    transactionWrote = false;
+    writeViewRevisionValue = 0;
     settledCallbacks = [];
     constructor(databasePath, options) {
         this.databasePath = databasePath;
@@ -173,6 +175,7 @@ class OperationalStateDatabaseOwner {
         return {
             database: this.database,
             databasePath: this.databasePath,
+            writeViewRevision: () => this.writeViewRevisionValue,
             transaction: (mode, operation) => this.transaction(mode, operation),
             onTransactionSettled: (callback) => {
                 if (this.transactionDepth === 0)
@@ -220,22 +223,33 @@ class OperationalStateDatabaseOwner {
     transaction(mode, operation) {
         if (this.closed)
             throw new Error('Operational state database is closed');
-        if (this.transactionDepth > 0)
+        if (this.transactionDepth > 0) {
+            if (mode === 'write')
+                this.transactionWrote = true;
             return operation();
+        }
         this.database.exec(mode === 'write' ? 'BEGIN IMMEDIATE' : 'BEGIN');
         this.transactionDepth += 1;
+        this.transactionWrote = mode === 'write';
         let result;
         try {
             result = operation();
             this.database.exec('COMMIT');
         }
         catch (error) {
+            const transactionWrote = this.transactionWrote;
             rollback(this.database);
             this.transactionDepth -= 1;
+            this.transactionWrote = false;
+            if (transactionWrote)
+                this.writeViewRevisionValue += 1;
             this.settle(false);
             throw error;
         }
         this.transactionDepth -= 1;
+        if (this.transactionWrote)
+            this.writeViewRevisionValue += 1;
+        this.transactionWrote = false;
         this.settle(true);
         return result;
     }

package/node_modules/@maka/storage/dist/plan-authority.js

@@ -53,6 +53,7 @@ export function observeInteractivePlanStoreWriter(source, onChanged, onPublicati
         access: writer.access,
         [writerBrand]: true,
         readState: (sessionId) => writer.readState(sessionId),
+        listPlanRecoverySessionIds: () => writer.listPlanRecoverySessionIds(),
         readOperationReceipt: (sessionId, operationId, operationInput) => writer.readOperationReceipt(sessionId, operationId, operationInput),
         submitProposal: (input) => publish(input.sessionId, () => writer.submitProposal(input)),
         requestRevision: (input) => publish(input.sessionId, () => writer.requestRevision(input)),
@@ -136,6 +137,7 @@ function createWriterFacade(lease, store) {
         access: 'write',
         [writerBrand]: true,
         readState: (sessionId) => run(() => store.readState(sessionId)),
+        listPlanRecoverySessionIds: () => run(() => store.listPlanRecoverySessionIds()),
         readOperationReceipt: (sessionId, operationId, operationInput) => run(() => store.readOperationReceipt(sessionId, operationId, structuredClone(operationInput))),
         submitProposal: (input) => run(() => store.submitProposal(cloneSubmit(input))),
         requestRevision: (input) => run(() => store.requestRevision(cloneInput(input))),

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

@@ -43,6 +43,36 @@ class SqlitePlanStoreImpl {
     async readState(sessionId) {
         return (await this.readLedger(sessionId)).state;
     }
+    async listPlanRecoverySessionIds() {
+        const rows = this.#lease.database
+            .prepare(`
+        WITH lifecycle AS (
+          SELECT
+            session_id,
+            json_extract(record_json, '$.type') AS event_type,
+            ROW_NUMBER() OVER (PARTITION BY session_id ORDER BY sequence DESC) AS position
+          FROM workflow_plan_events
+          WHERE json_extract(record_json, '$.type') IN (
+            'plan_approved',
+            'plan_execution_completed',
+            'plan_execution_cancelled',
+            'plan_execution_interrupted',
+            'plan_execution_resumed'
+          )
+        )
+        SELECT session_id
+        FROM lifecycle
+        WHERE position = 1
+          AND event_type IN ('plan_approved', 'plan_execution_resumed')
+        ORDER BY session_id
+      `)
+            .all();
+        return rows.map((row) => {
+            if (typeof row.session_id !== 'string')
+                throw new Error('Invalid SQLite Plan row');
+            return row.session_id;
+        });
+    }
     async readOperationReceipt(sessionId, operationId, operationInput) {
         assertSafeId(sessionId);
         assertSafeId(operationId);

package/node_modules/@maka/storage/dist/runtime-event-persistence.js

@@ -40,6 +40,7 @@ export async function openRuntimeEventReadPersistence(input) {
         kind: 'sqlite',
         runtimeEventStore: Object.freeze({
             listSessionInvocations: (sessionId) => store.listSessionInvocations(sessionId),
+            listInvocationRecoveryInventory: (sessionIds) => store.listInvocationRecoveryInventory(sessionIds),
             readRunInvocation: (sessionId, runId) => store.readRunInvocation(sessionId, runId),
             listSessionInvocationsBounded: (sessionId, limit) => store.listSessionInvocationsBounded(sessionId, limit),
             listSessionInvocationsPage: (sessionId, input) => store.listSessionInvocationsPage(sessionId, input),

package/node_modules/@maka/storage/dist/runtime-policy/credential-vault-document.js

@@ -237,7 +237,8 @@ function sameLocator(left, right) {
     if (left.scope === 'web_search' && right.scope === 'web_search') {
         return left.provider === right.provider;
     }
-    return left.scope === 'network_proxy' && right.scope === 'network_proxy';
+    return ((left.scope === 'network_proxy' && right.scope === 'network_proxy') ||
+        (left.scope === 'jev' && right.scope === 'jev'));
 }
 function locatorKey(locator) {
     switch (locator.scope) {
@@ -245,6 +246,8 @@ function locatorKey(locator) {
             return `connection:${locator.connectionId}:${locator.kind}`;
         case 'web_search':
             return `web_search:${locator.provider}:api_key`;
+        case 'jev':
+            return 'jev:api_key';
         case 'network_proxy':
             return 'network_proxy:password';
     }

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

@@ -84,6 +84,8 @@ export function policySnapshot(document) {
 }
 function applyMutation(policy, operation) {
     switch (operation.kind) {
+        case 'set_jev':
+            return { ...policy, jev: operation.value };
         case 'set_network_proxy':
             return { ...policy, networkProxy: operation.value };
         case 'set_personalization':

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

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { isExecutorConfiguration } from '@maka/core/executor-catalog';
 import { randomUUID } from 'node:crypto';
 import { DEFAULT_SESSION_NAME, normalizeUserSessionName } from '@maka/core/session-name';
 import { isExecutorId } from '@maka/core/executor-id';
@@ -72,7 +73,12 @@ export function buildSessionHeader(workspaceRoot, input, sessionId = randomUUID(
         ...(input.revisionState ? { revisionState: input.revisionState } : {}),
         hasUnread: false,
         backend: input.executorId ? 'plugin-executor' : 'ai-sdk',
-        ...(input.executorId ? { executorId: input.executorId } : {}),
+        ...(input.executorId
+            ? {
+                executorId: input.executorId,
+                ...(input.executorConfig ? { executorConfig: input.executorConfig } : {}),
+            }
+            : {}),
         ...(input.llmConnectionId === undefined ? {} : { llmConnectionId: input.llmConnectionId }),
         llmConnectionSlug: input.llmConnectionSlug,
         // A subagent Session's route is chosen by the spawn that created it and is
@@ -273,9 +279,10 @@ function isPersistedBackendKind(value) {
 }
 function isValidExecutorSelection(header) {
     if (header.backend === 'plugin-executor') {
-        return isExecutorId(header.executorId);
+        return (isExecutorId(header.executorId) &&
+            (header.executorConfig === undefined || isExecutorConfiguration(header.executorConfig)));
     }
-    return header.executorId === undefined;
+    return header.executorId === undefined && header.executorConfig === undefined;
 }
 function isFiniteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value);
@@ -314,7 +321,12 @@ export function toSummary(header) {
         ...(header.revisionIndex !== undefined ? { revisionIndex: header.revisionIndex } : {}),
         ...(header.revisionState ? { revisionState: header.revisionState } : {}),
         backend: header.backend,
-        ...(header.executorId ? { executorId: header.executorId } : {}),
+        ...(header.executorId
+            ? {
+                executorId: header.executorId,
+                ...(header.executorConfig ? { executorConfig: header.executorConfig } : {}),
+            }
+            : {}),
         ...(header.llmConnectionId === undefined ? {} : { llmConnectionId: header.llmConnectionId }),
         llmConnectionSlug: header.llmConnectionSlug,
         connectionLocked: header.connectionLocked,

package/node_modules/@maka/storage/dist/shell-run-authority.js

@@ -97,6 +97,7 @@ function createWriterFacade(lease, store) {
         },
         readShellRun: (sessionId, shellRunId) => run(() => store.readShellRun(sessionId, shellRunId)),
         listSessionShellRuns: (sessionId) => run(() => store.listSessionShellRuns(sessionId)),
+        listShellRunRecoverySessionIds: () => run(() => store.listShellRunRecoverySessionIds()),
         close: () => {
             if (closed)
                 return;

package/node_modules/@maka/storage/dist/shell-run-store.js

@@ -90,6 +90,21 @@ class SqliteShellRunStore {
             return normalizeShellRunRecord(JSON.parse(row.record_json), sessionId, row.shell_run_id);
         });
     }
+    async listShellRunRecoverySessionIds() {
+        const rows = this.#lease.database
+            .prepare(`
+        SELECT DISTINCT session_id
+        FROM core_shell_runs
+        WHERE json_extract(record_json, '$.status') IN ('starting', 'running')
+        ORDER BY session_id
+      `)
+            .all();
+        return rows.map((row) => {
+            if (typeof row.session_id !== 'string')
+                throw new Error('Invalid SQLite ShellRun row');
+            return row.session_id;
+        });
+    }
     close() {
         this.#lease.close();
     }

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

@@ -20,7 +20,7 @@ import { decodePersistedLegacyRunHeader, invocationOpeningFromLegacyRunHeader, }
 import { encodeCanonicalRuntimeEvent } from '@maka/core/canonical-runtime-event';
 import { rebuildTranscriptTurnExtents, TERMINAL_RUNTIME_EVENT_SQL, } from './runtime-transcript-query.js';
 import { buildInvocationOpenedEvent, buildSyntheticTerminalRuntimeEvent, } from '@maka/core/runtime-invocation';
-export const SQLITE_RUNTIME_SCHEMA_VERSION = 19;
+export const SQLITE_RUNTIME_SCHEMA_VERSION = 20;
 export const RUNTIME_RECOVERY_AUTHORITY_CAPABILITY = 'runtime_recovery_authority';
 export const RUNTIME_RECOVERY_AUTHORITY_CAPABILITY_VERSION = 1;
 export const RUNTIME_CONTINUATION_AUTHORITY_CAPABILITY = 'runtime_continuation_authority';
@@ -624,6 +624,79 @@ const MIGRATIONS = new Map([
       ON runtime_session_turn_extents(session_id, first_ordinal, last_ordinal);
   `,
     ],
+    [
+        20,
+        `
+    CREATE INDEX runtime_events_recovery_user_message
+      ON runtime_events(
+        session_id,
+        turn_id,
+        event_id,
+        event_kind,
+        CASE
+          WHEN json_valid(payload_json)
+          THEN json_extract(payload_json, '$.partial')
+        END,
+        CASE
+          WHEN json_valid(payload_json)
+          THEN json_extract(payload_json, '$.role')
+        END,
+        coalesce(CASE
+          WHEN json_valid(payload_json)
+          THEN json_extract(payload_json, '$.content.steering')
+        END, 0)
+      )
+      WHERE event_kind = 'text'
+        AND CASE
+          WHEN json_valid(payload_json)
+          THEN json_extract(payload_json, '$.partial')
+        END = 0
+        AND CASE
+          WHEN json_valid(payload_json)
+          THEN json_extract(payload_json, '$.role')
+        END = 'user'
+        AND coalesce(CASE
+          WHEN json_valid(payload_json)
+          THEN json_extract(payload_json, '$.content.steering')
+        END, 0) = 0;
+
+    -- Historical duplicates must remain readable so the affected identity can
+    -- fail closed. This is intentionally non-unique. CASE keeps a malformed
+    -- legacy payload from aborting the whole schema migration.
+    CREATE INDEX runtime_events_steering_message
+      ON runtime_events(
+        session_id,
+        CASE
+          WHEN json_valid(payload_json)
+          THEN json_extract(payload_json, '$.refs.providerEventId')
+        END
+      )
+      WHERE event_kind = 'text'
+        AND CASE
+          WHEN json_valid(payload_json)
+          THEN json_extract(payload_json, '$.partial')
+        END = 0
+        AND CASE
+          WHEN json_valid(payload_json)
+          THEN json_extract(payload_json, '$.content.steering')
+        END = 1;
+
+    CREATE INDEX runtime_events_tool_dispatch_operation
+      ON runtime_events(
+        CASE
+          WHEN json_valid(payload_json)
+          THEN json_extract(payload_json, '$.actions.toolDispatch.operationId')
+        END
+      )
+      WHERE event_kind = 'tool_dispatch';
+
+    CREATE INDEX tool_operations_unsettled
+      ON tool_operations(invocation_id, operation_id)
+      WHERE current_state = 'prepared'
+        AND result_event_id IS NULL
+        AND dispatch_event_id IS NOT NULL;
+    `,
+    ],
 ]);
 /**
  * Data migrations that a SQL statement cannot express, applied inside the same