maka-agent 0.2.0-dev.6.20260830 → 0.2.0-dev.62.20260928

package/node_modules/@maka/runtime-host/dist/server/builtin-external-agent-plugins.js

@@ -0,0 +1,188 @@
+/*
+ * 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 { copyFile, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { extensionPackageDirectoryContentDigest } from './extension-bundle.js';
+const ACP_RUNTIME_PACKAGE_ID = 'acp-executor';
+const ACP_RUNTIME_ENTRY_ID = 'acp-runtime';
+const ANTIGRAVITY_PACKAGE_ID = 'antigravity-acp';
+const ANTIGRAVITY_ENTRY_ID = 'antigravity-acp';
+const STAGING_DIRECTORY = 'builtin-plugin-staging-v1';
+const RUNTIME_ENTRY = 'plugin.mjs';
+const COMPOSITION_PATCH = 'maka.composition.json';
+// Built-in setup entries remain discoverable before their Plugin is installed.
+// Registered Plugins replace these placeholders with their live catalogs.
+const BUILTIN_EXTERNAL_AGENT_CATALOG = Object.freeze([
+    Object.freeze({
+        id: ANTIGRAVITY_ENTRY_ID,
+        displayName: 'Antigravity',
+        readiness: 'unavailable',
+        models: Object.freeze([]),
+        supportsAttachments: false,
+        supportsModelChange: false,
+    }),
+]);
+export function withBuiltinExternalAgentCatalog(catalog) {
+    const registered = new Set(catalog.map((entry) => entry.id));
+    return [
+        ...catalog,
+        ...BUILTIN_EXTERNAL_AGENT_CATALOG.filter((entry) => !registered.has(entry.id)),
+    ];
+}
+/**
+ * Projects durable product settings into reserved Plugin packages and Entries.
+ *
+ * RuntimePolicy remains the owner of setup facts. The generated package layer
+ * is replaceable derived state, so adapter code never reads RuntimePolicy and
+ * repeated reconciliation does not append unbounded user composition overlays.
+ */
+export class HostBuiltinExternalAgentPluginCoordinator {
+    #platform;
+    #controlDirectory;
+    #readPolicy;
+    #entries;
+    #gate = Promise.resolve();
+    constructor(input) {
+        this.#platform = input.platform;
+        this.#controlDirectory = input.controlDirectory;
+        this.#readPolicy = input.readPolicy;
+        this.#entries = input.entries ?? resolveBuiltinExternalAgentPluginEntries();
+    }
+    async recover() {
+        await rm(join(this.#controlDirectory, STAGING_DIRECTORY), { recursive: true, force: true });
+        return await this.reconcile();
+    }
+    reconcile() {
+        const task = this.#gate.then(() => this.#reconcileNow());
+        this.#gate = task.catch(() => undefined);
+        return task;
+    }
+    async #reconcileNow() {
+        const executable = (await this.#readPolicy()).policy.externalAgents.antigravity.executable;
+        if (!executable) {
+            await this.#removeIfInstalled(ANTIGRAVITY_PACKAGE_ID);
+            await this.#removeIfInstalled(ACP_RUNTIME_PACKAGE_ID);
+            return;
+        }
+        await this.#ensurePackage(ACP_RUNTIME_PACKAGE_ID, this.#entries.acpRuntime, acpRuntimeManifest(), [
+            {
+                type: 'insert',
+                rootId: 'profile',
+                entry: {
+                    id: ACP_RUNTIME_ENTRY_ID,
+                    packageId: ACP_RUNTIME_PACKAGE_ID,
+                    isolate: { acp: true },
+                },
+            },
+        ]);
+        await this.#ensurePackage(ANTIGRAVITY_PACKAGE_ID, this.#entries.antigravity, antigravityManifest(), [
+            {
+                type: 'insert',
+                parentId: ACP_RUNTIME_ENTRY_ID,
+                entry: {
+                    id: ANTIGRAVITY_ENTRY_ID,
+                    packageId: ANTIGRAVITY_PACKAGE_ID,
+                    config: { executable },
+                },
+            },
+        ]);
+    }
+    async #ensurePackage(extensionId, runtimeEntry, manifest, operations) {
+        const staged = await stagePackage(this.#controlDirectory, runtimeEntry, manifest, operations);
+        try {
+            const installed = (await this.#platform.packageProjections()).find((candidate) => candidate.extensionId === extensionId);
+            if (installed?.contentDigest === staged.digest)
+                return;
+            await this.#platform.installPackage(staged.root);
+        }
+        finally {
+            await staged.dispose();
+        }
+    }
+    async #removeIfInstalled(extensionId) {
+        const installed = (await this.#platform.packageProjections()).some((candidate) => candidate.extensionId === extensionId);
+        if (installed)
+            await this.#platform.uninstallPackage(extensionId);
+    }
+}
+export function resolveBuiltinExternalAgentPluginEntries() {
+    return Object.freeze({
+        acpRuntime: fileURLToPath(import.meta.resolve('@maka/acp-executor-plugin/plugin')),
+        antigravity: fileURLToPath(import.meta.resolve('@maka/antigravity-acp-plugin/plugin')),
+    });
+}
+async function stagePackage(controlDirectory, runtimeEntry, manifest, operations) {
+    const stagingRoot = join(controlDirectory, STAGING_DIRECTORY);
+    await mkdir(stagingRoot, { recursive: true, mode: 0o700 });
+    const root = await mkdtemp(join(stagingRoot, '.package-'));
+    try {
+        await copyFile(runtimeEntry, join(root, RUNTIME_ENTRY));
+        await writeFile(join(root, 'maka.extension.json'), `${JSON.stringify(manifest, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        await writeFile(join(root, COMPOSITION_PATCH), `${JSON.stringify(operations, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        return Object.freeze({
+            root,
+            digest: await extensionPackageDirectoryContentDigest(root),
+            dispose: () => rm(root, { recursive: true, force: true }),
+        });
+    }
+    catch (error) {
+        await rm(root, { recursive: true, force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+function acpRuntimeManifest() {
+    return Object.freeze({
+        schemaVersion: 1,
+        id: ACP_RUNTIME_PACKAGE_ID,
+        displayName: 'ACP Executor Runtime',
+        description: 'Shared ACP protocol and process runtime for external Agent adapter plugins.',
+        dependencies: Object.freeze([]),
+        configuration: Object.freeze({ properties: Object.freeze({}), required: Object.freeze([]) }),
+        runtime: Object.freeze({ entry: RUNTIME_ENTRY }),
+        composition: Object.freeze({
+            patch: COMPOSITION_PATCH,
+            structuralDependencies: Object.freeze([]),
+        }),
+    });
+}
+function antigravityManifest() {
+    return Object.freeze({
+        schemaVersion: 1,
+        id: ANTIGRAVITY_PACKAGE_ID,
+        displayName: 'Antigravity ACP',
+        description: 'Runs Google Antigravity as an external Agent through ACP.',
+        dependencies: Object.freeze([{ id: ACP_RUNTIME_PACKAGE_ID }]),
+        configuration: Object.freeze({
+            properties: Object.freeze({
+                executable: Object.freeze({ type: 'string', title: 'ACP executable' }),
+            }),
+            required: Object.freeze(['executable']),
+        }),
+        runtime: Object.freeze({ entry: RUNTIME_ENTRY }),
+        composition: Object.freeze({
+            patch: COMPOSITION_PATCH,
+            structuralDependencies: Object.freeze([ACP_RUNTIME_PACKAGE_ID]),
+        }),
+    });
+}

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

@@ -18,10 +18,8 @@
  */
 import { resolveExistingStorageRoot } from '@maka/storage/root-authority';
 import { currentRuntimeHostProcessLaunch, tryAcquireRuntimeHostLaunch, } from '../operator/managed-deployment.js';
-import { RuntimeHostKernel } from './host-kernel.js';
-import { openRuntimeHostAccessAuthority } from './access-authority.js';
-import { startRuntimeHostAuthenticatedListenerSet } from './listener-set.js';
 export async function startInteractiveRuntimeHostCandidate(options, createComposition, dependencies = {}) {
+    const kernelModule = import('./host-kernel.js').then((module) => ({ kind: 'loaded', module }), (error) => ({ kind: 'failed', error }));
     const capability = await resolveExistingStorageRoot({
         path: options.rootPath,
         kind: 'interactive',
@@ -37,9 +35,13 @@ export async function startInteractiveRuntimeHostCandidate(options, createCompos
     const { owner, managedConfig } = ownership;
     try {
         const composition = await createComposition(managedConfig);
+        const loadedKernel = await kernelModule;
+        if (loadedKernel.kind === 'failed')
+            throw loadedKernel.error;
+        const { RuntimeHostKernel } = loadedKernel.module;
         const websocket = managedConfig?.listeners.websocket;
         const accessAuthority = websocket
-            ? await openRuntimeHostAccessAuthority(owner.controlDirectory)
+            ? await import('./access-authority.js').then(({ openRuntimeHostAccessAuthority }) => openRuntimeHostAccessAuthority(owner.controlDirectory))
             : undefined;
         const host = await RuntimeHostKernel.start({
             owner,
@@ -49,12 +51,18 @@ export async function startInteractiveRuntimeHostCandidate(options, createCompos
             handshakeTimeoutMs: options.handshakeTimeoutMs,
             generation: options.generation,
             composition,
+            ...(options.initialClientAdmission
+                ? { initialClientAdmission: options.initialClientAdmission }
+                : {}),
             ...(accessAuthority ? { accessAuthority } : {}),
             ...(websocket && accessAuthority
                 ? {
-                    listenerSetFactory: (input) => startRuntimeHostAuthenticatedListenerSet(input, {
-                        websocket: { ...websocket, accessAuthority },
-                    }),
+                    listenerSetFactory: async (input) => {
+                        const { startRuntimeHostAuthenticatedListenerSet } = await import('./listener-set.js');
+                        return startRuntimeHostAuthenticatedListenerSet(input, {
+                            websocket: { ...websocket, accessAuthority },
+                        });
+                    },
                 }
                 : {}),
         });

package/node_modules/@maka/runtime-host/dist/server/canonical-session-projection.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { isSessionNotFoundError } from '@maka/storage/execution-stores';
 import { decodeSessionContinuitySnapshot, SESSION_CONTINUITY_SCHEMA_VERSION, SESSION_CONTINUITY_SNAPSHOT_MAX_BYTES, } from '../protocol/index.js';
 import { isMissingFile, readCanonicalTurnSnapshot, worstCaseFailedTurnSnapshot, } from './canonical-turn-snapshot.js';
 import { worstCaseMessageQueueProjection } from './message-queue-capacity.js';
@@ -42,7 +43,7 @@ export class CanonicalSessionProjectionReader {
             metadataRevision = record.revision;
         }
         catch (error) {
-            if (isMissingFile(error))
+            if (isMissingFile(error) || isSessionNotFoundError(error))
                 return null;
             throw error;
         }

package/node_modules/@maka/runtime-host/dist/server/canonical-turn-snapshot.js

@@ -16,24 +16,30 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { isContextBudgetExhaustedDetail, } from '@maka/core/events';
 import { truncateUtf8 } from '@maka/core/diagnostic-log';
 import { redactSecrets } from '@maka/core/redaction';
+import { readRunInvocation } from '@maka/core/runtime-event-store';
+import { readLogicalRuntimeExecution } from '@maka/core/runtime-logical-execution';
 import { classifyTerminalRuntimeLedger } from '@maka/runtime/terminal-run-commit';
 import { TURN_FAILURE_MESSAGE_MAX_BYTES } from '../protocol/index.js';
 export async function readCanonicalTurnSnapshot(stores, identity, knownRun) {
     const { sessionId, turnId, runId } = identity;
-    const run = knownRun ?? (await readRunIfPresent(stores, sessionId, runId));
+    const run = knownRun ?? (await readInvocationIfPresent(stores, sessionId, runId));
     if (!run)
         return { sessionId, turnId, runId, status: 'admitted' };
     if (run.turnId !== turnId) {
-        throw new Error('Admitted Turn identity does not match its Run header');
+        throw new Error('Admitted Turn identity does not match its invocation');
     }
-    const [runEvents, runtimeEvents] = await Promise.all([
-        stores.agentRunStore.readEvents(sessionId, runId),
-        stores.runtimeEventStore.readImmutableRuntimeEvents(sessionId, runId),
-    ]);
-    const terminal = classifyTerminalRuntimeLedger(run, runtimeEvents);
+    const logical = await readLogicalRuntimeExecution(stores.runtimeEventStore, identity, run);
+    if (!logical)
+        throw new Error('Admitted logical execution disappeared');
+    const rootExecutionKind = logical.root.opening.root.kind === 'context_compact'
+        ? { rootExecutionKind: 'context_compact' }
+        : {};
+    if (logical.pendingHandoff) {
+        return { sessionId, turnId, runId, status: 'running', ...rootExecutionKind };
+    }
+    const terminal = classifyTerminalRuntimeLedger(logical.tip, logical.events);
     if (terminal.kind === 'fact') {
         const fact = terminal.fact;
         if (fact.runStatus === 'completed') {
@@ -53,7 +59,6 @@ export async function readCanonicalTurnSnapshot(stores, identity, knownRun) {
             const failureMessage = fact.terminalEvent.content?.kind === 'error'
                 ? truncateUtf8(redactSecrets(fact.terminalEvent.content.message), TURN_FAILURE_MESSAGE_MAX_BYTES, '…')
                 : undefined;
-            const contextBudgetExhaustedDetail = readContextBudgetExhaustedDetail(fact.terminalEvent.actions?.stateDelta?.contextBudgetExhaustedDetail);
             return {
                 sessionId,
                 turnId,
@@ -62,7 +67,6 @@ export async function readCanonicalTurnSnapshot(stores, identity, knownRun) {
                 terminalEventId: fact.terminalEvent.id,
                 failureClass: fact.failureClass,
                 ...(failureMessage ? { failureMessage } : {}),
-                ...(contextBudgetExhaustedDetail ? { contextBudgetExhaustedDetail } : {}),
             };
         }
         if (!fact.abortSource)
@@ -79,16 +83,25 @@ export async function readCanonicalTurnSnapshot(stores, identity, knownRun) {
     if (terminal.kind !== 'none') {
         throw new Error('Runtime ledger does not contain one canonical terminal fact');
     }
-    if (run.status === 'completed' || run.status === 'failed' || run.status === 'cancelled') {
-        throw new Error('Terminal Run header has no canonical terminal RuntimeEvent');
-    }
-    if (run.status !== 'created' && !runEvents.some((event) => event.type === 'run_started')) {
-        throw new Error('Non-created Run has no durable start fact');
-    }
-    return { sessionId, turnId, runId, status: run.status };
+    // No terminal event means the run is still open. Whether it is parked is the
+    // pending-interaction store's answer, not something the run restates.
+    const parked = await hasPendingInteraction(stores, sessionId, logical.tip.runId);
+    return {
+        sessionId,
+        turnId,
+        runId,
+        status: parked ? 'waiting_for_user' : 'running',
+        ...rootExecutionKind,
+    };
 }
-function readContextBudgetExhaustedDetail(value) {
-    return isContextBudgetExhaustedDetail(value) ? value : undefined;
+/** Is this run waiting on a request the user has not answered? */
+async function hasPendingInteraction(stores, sessionId, runId) {
+    const [interactions, boundaries] = await Promise.all([
+        stores.interactionStore.listSessionPending(sessionId),
+        stores.sessionStore.listPendingSandboxBoundaryRequests(sessionId),
+    ]);
+    return (interactions.some((request) => request.runId === runId) ||
+        boundaries.some((request) => request.runId === runId));
 }
 function readContextCompactionOutcome(value) {
     if (!value || typeof value !== 'object')
@@ -111,14 +124,11 @@ export function worstCaseFailedTurnSnapshot(identity) {
         terminalEventId: 'x'.repeat(128),
         failureClass: '\0'.repeat(128),
         failureMessage: '\0'.repeat(TURN_FAILURE_MESSAGE_MAX_BYTES),
-        // Keep capacity preflight conservative for every protocol-valid failure
-        // detail, including the longest malformed-summary diagnostic.
-        contextBudgetExhaustedDetail: 'malformed_summary_too_small_for_fold',
     };
 }
-async function readRunIfPresent(stores, sessionId, runId) {
+async function readInvocationIfPresent(stores, sessionId, runId) {
     try {
-        return await stores.agentRunStore.readRun(sessionId, runId);
+        return await readRunInvocation(stores.runtimeEventStore, sessionId, runId);
     }
     catch (error) {
         if (isMissingFile(error))

package/node_modules/@maka/runtime-host/dist/server/canonical-usage-reader.js

@@ -16,33 +16,46 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { resolveUsageRange } from '@maka/core/model-call-usage-projection';
 export class CanonicalUsageProjectionIncompleteError extends Error {
     constructor() {
         super('Canonical Usage projection is incomplete');
         this.name = 'CanonicalUsageProjectionIncompleteError';
     }
 }
-/** Reads and repairs the canonical usage source shared by Host-owned projections. */
-export async function readCanonicalUsage(stores, query, now, repair = true) {
-    // `catchUpModelCallProjection` is a write. Paged log reads call this once per
-    // page, so a caller that already repaired on its first page can pass
-    // `repair: false` on later pages to avoid a redundant repair write per page.
+/**
+ * Repairs the projection, then asks the ledger for one answer.
+ *
+ * `catchUpModelCallProjection` is a write. Paged log reads call this once per
+ * page, so a caller that already repaired on its first page passes
+ * `repair: false` on later pages to avoid a redundant repair write per page.
+ */
+async function readCanonical(stores, query, repair, ask) {
     const repairOutcome = repair
         ? await stores.modelCalls
             .catchUpModelCallProjection(query.sessionId === undefined ? undefined : { sessionId: query.sessionId })
             .catch(() => ({ pendingRuns: 1, unreadableEvents: 0 }))
         : { pendingRuns: 0, unreadableEvents: 0 };
-    const page = await stores.modelCalls.modelCallAttempts(resolveUsageRange(query.range, now), query.sessionId);
+    const answer = await ask();
     return {
-        attempts: page.attempts,
-        unreadableRecords: page.unreadableRecords + repairOutcome.unreadableEvents,
+        projection: answer.projection,
+        unreadableRecords: answer.unreadableRecords + repairOutcome.unreadableEvents,
         pendingRepairs: repairOutcome.pendingRuns,
     };
 }
+export function readCanonicalUsageSummary(stores, query, now, repair = true) {
+    return readCanonical(stores, query, repair, () => stores.modelCalls.modelCallSummary(query, now));
+}
+export function readCanonicalUsageBuckets(stores, query, groupBy, now, repair = true) {
+    return readCanonical(stores, query, repair, () => stores.modelCalls.modelCallBuckets(query, groupBy, now));
+}
+export function readCanonicalUsageLogs(stores, query, now, limit, repair = true) {
+    // Both sources are newest-first, so a merged page can only be drawn from each
+    // source's own first `offset + limit` rows.
+    return readCanonical(stores, query, repair, () => stores.modelCalls.modelCallLogs(query, now, 0, limit));
+}
 /** Runs one bounded repair pass and rejects data still unsafe for durable derivatives. */
-export async function readCompleteCanonicalUsage(stores, query, now) {
-    const source = await readCanonicalUsage(stores, query, now);
+export async function readCompleteCanonicalUsageSummary(stores, query, now) {
+    const source = await readCanonicalUsageSummary(stores, query, now);
     if (source.unreadableRecords > 0 || source.pendingRepairs > 0) {
         throw new CanonicalUsageProjectionIncompleteError();
     }

package/node_modules/@maka/runtime-host/dist/server/child-agent-composition.js

@@ -28,7 +28,7 @@ export function createHostChildAgentToolComposition(input) {
         worktreeChildExecutorAvailable: input.worktreePatchWriteBackAvailable,
     });
     return Object.freeze({
-        parentTools: Object.freeze(buildParentAgentTools({ taskLedger: input.taskLedger, definitions })),
+        parentTools: Object.freeze(buildParentAgentTools({ definitions })),
         childTools: Object.freeze(childTools),
     });
 }
@@ -43,6 +43,7 @@ export function bindHostChildAgentBackend(authority, parentSessionId) {
             },
             agentProfile: input.agentProfile,
             ...(input.subagentId ? { subagentId: input.subagentId } : {}),
+            ...(input.executorId ? { executorId: input.executorId } : {}),
             prompt: input.prompt,
             ...(input.swarm ? { swarm: input.swarm } : {}),
             abortSignal: input.abortSignal,