maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/node_modules/@maka/runtime/dist/model-history.js

@@ -611,13 +611,16 @@ export function buildRuntimeEventModelReplayPlan(events, options = {}) {
             diagnostics.push(diagnostic(event, 'unsupported_content', 'RuntimeEvent content kind is not model-replayable', { kind: event.content.kind }));
             continue;
         }
-        if (event.role === 'system' && !includeSystemEvents) {
+        const runtimeContextName = event.role === 'system' && event.author === 'host' && event.content.kind === 'text'
+            ? event.content.runtimeContextName
+            : undefined;
+        if (event.role === 'system' && !includeSystemEvents && runtimeContextName === undefined) {
             diagnostics.push(diagnostic(event, 'system_runtime_fact_diagnostic_only', 'system RuntimeEvent content is diagnostic-only unless system replay is enabled'));
             continue;
         }
         switch (event.content.kind) {
             case 'text': {
-                const role = modelTextRole(event.role);
+                const role = runtimeContextName !== undefined ? 'user' : modelTextRole(event.role);
                 if (!role) {
                     diagnostics.push(diagnostic(event, 'unsupported_role', 'text RuntimeEvent role is not model-replayable', {
                         role: event.role,
@@ -636,6 +639,7 @@ export function buildRuntimeEventModelReplayPlan(events, options = {}) {
                         ? buildSteeringEnvelope(formatTextWithInlineRefs(event.content))
                         : formatTextWithInlineRefs(event.content),
                     ...(steeringReplay ? { steering: { eventId: event.id } } : {}),
+                    ...(runtimeContextName !== undefined ? { runtimeContextName } : {}),
                     ...(event.content.attachments ? { attachments: event.content.attachments } : {}),
                     ...(event.content.providerOptions !== undefined
                         ? {
@@ -807,7 +811,13 @@ export function buildRuntimeEventModelReplayPlan(events, options = {}) {
             content: item.content,
             providerOptions: steeringProviderOptions(item.steering.eventId),
         }
-        : { role: item.role, content: item.content });
+        : {
+            role: item.role,
+            content: item.content,
+            ...(item.runtimeContextName !== undefined
+                ? { providerOptions: runtimeContextProviderOptions(item.runtimeContextName) }
+                : {}),
+        });
     return {
         items,
         textMessages,
@@ -815,6 +825,9 @@ export function buildRuntimeEventModelReplayPlan(events, options = {}) {
         hasProviderNativeSemantics: items.some((item) => item.kind !== 'text'),
     };
 }
+export function runtimeContextProviderOptions(name) {
+    return { makaRuntimeContext: { name } };
+}
 function modelTextRole(role) {
     switch (role) {
         case 'user':

package/node_modules/@maka/runtime/dist/openai-codex-history-compactor.js

@@ -18,7 +18,7 @@
  */
 import { HistoryCompactSummarizerError } from './history-compact-error.js';
 import { nonEmpty } from './context-budget-helpers.js';
-import { canContinueHistoryCompactCheckpointForModel, historyCompactCheckpointToModelMessage, isProviderHistoryCompactCheckpoint, } from './history-compact-checkpoint.js';
+import { canContinueHistoryCompactCheckpointForModel, historyCompactCheckpointToModelMessage, isProviderHistoryCompactCheckpoint, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
 import { admitProviderReasoningReplayItems, buildRuntimeEventModelReplayPlan, buildRuntimeEventReplayTimeline, compatibleProviderReasoningReplayEventIds, } from './model-history.js';
 import { withProviderStreamTracking } from './provider-request-telemetry.js';
 import { effectiveReplayToolResultOutput } from './durable-tool-result-projection.js';
@@ -40,14 +40,22 @@ export function buildOpenAiCodexHistoryCompactor(options) {
         try {
             const previous = input.previousCheckpoint;
             const canContinuePrevious = previous &&
-                isProviderHistoryCompactCheckpoint(previous) &&
                 canContinueHistoryCompactCheckpointForModel(previous, { providerType: 'openai-codex' }, options.connectionId, options.modelId);
             const events = canContinuePrevious
                 ? (input.newlyFoldedRuntimeEvents ?? [])
                 : input.source.foldedRuntimeEvents;
+            // Match ordinary replay after a text-compacted session switches to
+            // Codex: summarize the portable checkpoint plus its tail, without
+            // resurrecting the already-folded source history (#6154).
+            const replayEvents = canContinuePrevious && !isProviderHistoryCompactCheckpoint(previous)
+                ? projectHistoryCompactCheckpointReplay(previous, 
+                // The projection finds a mid-turn head anchor by identity. A
+                // historical event count can cut it off after reasoning admission.
+                input.source.foldedRuntimeEvents, events)
+                : events;
             const providerReasoningReplayEventIds = compatibleProviderReasoningReplayEventIds(events, input.source.invocations, options.providerStateIdentity, options.modelId, input.runId);
-            const projectedMessages = openAiCodexCompactionMessages(events, providerReasoningReplayEventIds);
-            if (canContinuePrevious) {
+            const projectedMessages = openAiCodexCompactionMessages(replayEvents, providerReasoningReplayEventIds);
+            if (canContinuePrevious && isProviderHistoryCompactCheckpoint(previous)) {
                 projectedMessages.unshift(historyCompactCheckpointToModelMessage(previous));
             }
             // Whether this input fits the compaction endpoint is its own answer;
@@ -122,7 +130,9 @@ export function shouldFallbackFromOpenAiCodexHistoryCompaction(error, abortSigna
         return false;
     if (!(error instanceof HistoryCompactSummarizerError))
         return false;
-    if (error.reason === 'input_too_large' || error.reason === 'invalid_provider_state')
+    // Capacity errors must reach the planner's same-route accepted-prefix
+    // retry, which preserves native compaction and the uncovered tail.
+    if (error.reason === 'invalid_provider_state')
         return true;
     if (error.reason !== 'provider_error')
         return false;

package/node_modules/@maka/runtime/dist/plan-tools.js

@@ -63,7 +63,6 @@ export function buildSubmitPlanTool(planStore, sourceExecutionId) {
             risks: z.array(boundedTextSchema('Plan risk')).max(PLAN_MAX_RISKS).optional(),
         })
             .refine(isPlanProposalLifecycleAdmissible, 'Plan proposal cannot fit its execution lifecycle projection'),
-        recoveryMode: 'idempotent',
         impl: async (input, context) => {
             const result = await planStore.submitProposal({
                 operationId: planToolOperationId('submit', context),
@@ -90,7 +89,6 @@ export function buildUpdatePlanTool(planStore, executionId) {
             steps: z.array(executionStepSchema).min(1).max(PLAN_MAX_STEPS),
             explanation: boundedTextSchema('Plan progress explanation').optional(),
         }),
-        recoveryMode: 'idempotent',
         impl: async (input, context) => {
             const result = await planStore.updateExecution({
                 operationId: planToolOperationId('update', context),
@@ -109,7 +107,6 @@ export function buildCancelPlanTool(planStore, executionId) {
         parameters: z.object({
             reason: boundedTextSchema('Plan cancellation reason', PLAN_LIFECYCLE_REASON_MAX_BYTES),
         }),
-        recoveryMode: 'idempotent',
         impl: async ({ reason }, context) => {
             const result = await planStore.cancelExecution({
                 operationId: planToolOperationId('cancel', context),

package/node_modules/@maka/runtime/dist/plugin-executor-backend.js

@@ -17,8 +17,10 @@
  * under the License.
  */
 import { randomUUID } from 'node:crypto';
+import { truncateUtf8 } from '@maka/core/diagnostic-log';
 import { redactSecrets } from '@maka/core/redaction';
 import { AsyncEventQueue } from './async-queue.js';
+import { MAX_EXECUTOR_COMPLETION_TEXT_BYTES } from './plugin-executor-service.js';
 /** Converts a small plugin executor contract into Maka's existing Run event stream. */
 export class PluginExecutorBackend {
     kind = 'plugin-executor';
@@ -51,7 +53,7 @@ export class PluginExecutorBackend {
         const queue = new AsyncEventQueue();
         const messageId = this.#newId();
         const producer = this.#produce(input, messageId, abort.signal, queue).finally(() => queue.close());
-        const active = { abort, settled: producer.then(() => undefined) };
+        const active = { abort, settled: producer.then(() => undefined), queue };
         this.#active.add(active);
         let acknowledged = false;
         try {
@@ -90,11 +92,22 @@ export class PluginExecutorBackend {
             this.#active.delete(active);
         }
     }
+    /**
+     * Cancel execution and wait for its queued events to be consumed or the consumer
+     * to detach. Keep consuming send() while stopping: awaiting stop() inside that
+     * consumer loop prevents progress. Start it without awaiting in the loop, then
+     * await it after the loop exits.
+     */
     async stop(reason) {
         const active = [...this.#active];
         for (const execution of active)
             execution.abort.abort(new Error(reason));
-        await Promise.allSettled(active.map((execution) => execution.settled));
+        await Promise.allSettled(active.map(async (execution) => {
+            await execution.settled;
+            // Runtime may seal the ledger when stop returns. Provider settlement
+            // alone does not mean its queued final updates have been persisted.
+            await execution.queue.waitUntilConsumedThroughCurrent();
+        }));
     }
     async respondToSandboxBoundary(_response) {
         throw new Error('Plugin executor does not expose Maka sandbox-boundary requests');
@@ -111,6 +124,9 @@ export class PluginExecutorBackend {
     async #produce(input, messageId, signal, queue) {
         const turnId = input.turnId;
         let thinkingText = '';
+        let outputText = '';
+        let outputBytes = 0;
+        let outputTruncated = false;
         const toolUseIds = new Map();
         const toolOutputSequences = new Map();
         let result;
@@ -140,6 +156,21 @@ export class PluginExecutorBackend {
                 onEvent: (event) => {
                     if (event.type === 'thinking_delta')
                         thinkingText += event.text;
+                    if (event.type === 'output_delta' && !outputTruncated) {
+                        // Bound even a single oversized delta before retaining it. Live
+                        // delivery and the provider's final result remain authoritative.
+                        const chunk = event.text.slice(0, MAX_EXECUTOR_COMPLETION_TEXT_BYTES + 1);
+                        outputText += chunk;
+                        outputBytes += Buffer.byteLength(chunk, 'utf8');
+                        if (outputBytes > MAX_EXECUTOR_COMPLETION_TEXT_BYTES) {
+                            // A surrogate pair split across deltas uses fewer bytes joined.
+                            outputBytes = Buffer.byteLength(outputText, 'utf8');
+                            if (outputBytes > MAX_EXECUTOR_COMPLETION_TEXT_BYTES) {
+                                outputText = truncateUtf8(outputText, MAX_EXECUTOR_COMPLETION_TEXT_BYTES, '\n[Response truncated]');
+                                outputTruncated = true;
+                            }
+                        }
+                    }
                     this.#publishOutputEvent(turnId, messageId, event, toolUseIds, toolOutputSequences, queue);
                 },
                 onPermissionRequest: (request) => this.#requestPermission(input, request, signal, toolUseIds, queue),
@@ -150,6 +181,22 @@ export class PluginExecutorBackend {
             failure = error;
         }
         this.#closeOptionalOutput(turnId, messageId, thinkingText, toolUseIds, queue);
+        // Deltas are only live presentation. Close the interrupted text before the
+        // terminal event seals the ledger, including updates drained during cancel.
+        // Successful results keep their provider-authoritative completion text.
+        // Like successful completions, history stores one text block after tool
+        // results; it does not preserve the live text/tool interleaving.
+        if (outputText && (failed || result?.status !== 'completed')) {
+            queue.push({
+                type: 'text_complete',
+                id: this.#newId(),
+                turnId,
+                ts: this.#now(),
+                messageId,
+                text: outputText,
+                interrupted: true,
+            });
+        }
         if (failed) {
             if (signal.aborted)
                 this.#publishCancellation(turnId, { status: 'cancelled', source: 'caller' }, queue);

package/node_modules/@maka/runtime/dist/plugin-executor-service.js

@@ -23,7 +23,7 @@ import { isExecutorId } from '@maka/core/executor-id';
 import { Service } from './plugin-kernel.js';
 import { MakaPluginRuntimeError, pluginIdentity, registerPluginContribution, } from './plugin-runtime.js';
 import { PluginScopeRegistry } from './plugin-scope-registry.js';
-const MAX_EXECUTOR_COMPLETION_TEXT_BYTES = 256 * 1024;
+export const MAX_EXECUTOR_COMPLETION_TEXT_BYTES = 256 * 1024;
 class ExecutorRetiredAbort extends Error {
     constructor(executorId) {
         super(`Executor was retired: ${executorId}`);
@@ -127,6 +127,15 @@ export class PluginExecutorService extends Service {
             ? [...this.registry.visible(scopeSessionId).values()]
             : [...this.registry.entries('profile')];
         const selected = entries.filter((entry) => !entry.retired && (!input.executorId || entry.provider.id === input.executorId));
+        if (input.listOnly)
+            return selected.map(({ provider }) => ({
+                id: provider.id,
+                displayName: provider.displayName?.trim() || provider.id,
+                readiness: 'unavailable',
+                models: [],
+                supportsAttachments: false,
+                supportsModelChange: false,
+            }));
         if (input.executorId && !selected.length)
             return [
                 {
@@ -170,9 +179,9 @@ export class PluginExecutorService extends Service {
             }
         })));
     }
-    invalidateCatalog() {
+    invalidateCatalog(executorId) {
         for (const entry of this.registry.entries('profile')) {
-            if (!entry.retired)
+            if (!entry.retired && (!executorId || entry.provider.id === executorId))
                 entry.provider.invalidateCatalog?.();
         }
     }

package/node_modules/@maka/runtime/dist/provider-error-classification.js

@@ -38,6 +38,7 @@ const PROVIDER_UNAVAILABLE_PROVIDER_CODES = new Set([
 const OPENAI_CODEX_EDGE_REJECTION_CODE = 'openai_codex_edge_rejection';
 // Node, TLS, and undici codes that identify transport failures before an HTTP response.
 const TRANSPORT_FAILURE_CODES = new Set([
+    'ERR_HTTP2_STREAM_ERROR',
     'ECONNRESET',
     'ECONNREFUSED',
     'ETIMEDOUT',
@@ -52,6 +53,7 @@ const TRANSPORT_FAILURE_CODES = new Set([
 // Unlike pre-response failures, require an explicit interruption code here:
 // neither SDK retryability nor arbitrary TLS/undici errors prove a transient cut.
 const RESPONSE_TRANSPORT_FAILURE_CODES = new Set([
+    'ERR_HTTP2_STREAM_ERROR',
     'ECONNRESET',
     'EPIPE',
     'ETIMEDOUT',

package/node_modules/@maka/runtime/dist/recovery-resolver.js

@@ -42,7 +42,6 @@ export function resolveRuntimeRecovery(events) {
         decisions,
         issues,
         hasCorruption,
-        requiresReconciliation: !hasCorruption && decisions.some((decision) => decision.status === 'indeterminate'),
     };
 }
 function decisionFromOperation(operation, toolBoundaryProtocol, eventOrder) {
@@ -91,6 +90,8 @@ function decisionFromOperation(operation, toolBoundaryProtocol, eventOrder) {
     if (operation.reconcileEvents.length === 0 && operation.decisionEvents.length === 0) {
         return decision;
     }
+    // Historical bundles remain authoritative when reading an existing ledger.
+    // New uncertain calls are sealed as outcome_unknown, never reconciled.
     const recovery = interpretScannedToolRecovery(operation, eventOrder);
     if (recovery.kind !== 'valid') {
         decision.status = 'corruption';

package/node_modules/@maka/runtime/dist/runtime-context.js

@@ -0,0 +1,53 @@
+/*
+ * 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 { runtimeContextProviderOptions } from './model-history.js';
+/** Compare only host-tagged context still present in the effective model history.
+ * Compaction may remove a snapshot; in that case the current value is sent again.
+ */
+export function changedRuntimeContexts(contexts, messages) {
+    const latest = new Map();
+    for (const message of messages) {
+        const name = message.providerOptions?.makaRuntimeContext?.name;
+        if (message.role !== 'user' || typeof name !== 'string')
+            continue;
+        const text = typeof message.content === 'string'
+            ? message.content
+            : message.content
+                .filter((part) => part.type === 'text')
+                .map((part) => part.text)
+                .join('');
+        latest.set(name, text);
+    }
+    const changes = [];
+    for (const context of contexts) {
+        const text = `Runtime context (${context.name}; host metadata, not a user request; later updates supersede earlier values):\n${context.text}`;
+        if (latest.get(context.name) === text)
+            continue;
+        changes.push({ name: context.name, text });
+        latest.set(context.name, text);
+    }
+    return changes;
+}
+export function runtimeContextMessage(context) {
+    return {
+        role: 'user',
+        content: context.text,
+        providerOptions: runtimeContextProviderOptions(context.name),
+    };
+}

package/node_modules/@maka/runtime/dist/runtime-event-read-model.js

@@ -638,6 +638,9 @@ export function classifyRuntimeEventTerminalFact(invocation, events) {
 function projectText(event, state, messages) {
     if (event.content?.kind !== 'text')
         return false;
+    // Claimed by model replay only; internal context has no transcript row.
+    if (event.role === 'system' && event.content.runtimeContextName !== undefined)
+        return true;
     if (event.role === 'user') {
         const message = projectRuntimeEventUserMessage(event, stableMessageId(event, state, 'user'));
         if (!message)

package/node_modules/@maka/runtime/dist/sandbox-boundary-path.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 import { promises as fs } from 'node:fs';
-import { resolve } from 'node:path';
+import { basename, join, resolve } from 'node:path';
 import { realpathAllowMissing } from './path-containment.js';
 import { MAX_SANDBOX_BOUNDARY_PATH_CHARS, validateSandboxBoundaryExpansion, } from '@maka/core/sandbox-boundary';
 /**
@@ -59,8 +59,14 @@ export async function normalizeSandboxBoundaryExpansion(expansion, cwd) {
         if (normalized.scope === 'exact' && normalized.targetType === 'directory') {
             throw new SandboxBoundaryDeclarationError('An exact sandbox boundary cannot target a directory; use subtree for directory access.');
         }
+        // Reading a linked worktree's admin directory is not enough to read the repository, so a
+        // read subtree widens to the shared Git directory it points at. A write boundary keeps the
+        // exact path the caller asked for.
+        const commonDir = normalized.access === 'read' && normalized.scope === 'subtree'
+            ? await linkedWorktreeCommonDir(normalized.enforcementPath)
+            : undefined;
         return {
-            path: normalized.enforcementPath,
+            path: commonDir ?? normalized.enforcementPath,
             access: normalized.access,
             scope: normalized.scope,
         };
@@ -73,6 +79,77 @@ export async function normalizeSandboxBoundaryExpansion(expansion, cwd) {
         throw new SandboxBoundaryDeclarationError(normalized.message);
     return normalized.expansion;
 }
+/** `commondir` holds one short relative path; anything larger is not a pointer we will follow. */
+const MAX_GIT_COMMON_DIR_POINTER_CHARS = 1024;
+/**
+ * Resolve a linked worktree's admin directory to the repository's shared Git directory.
+ *
+ * `.git/worktrees/<name>` keeps only that worktree's HEAD, index and reflog; refs, objects,
+ * `config` and `info/exclude` live in the directory named by its `commondir` file. A read boundary
+ * on the admin directory alone leaves `git status` and `git log` unable to read the repository
+ * they belong to, so the request is widened to that shared directory before it is approved.
+ *
+ * The pointer is repository-controlled text found inside a path the caller asked for, so it is
+ * followed only when the target really is this repository's shared directory: it must hold
+ * `objects` and `refs` as real directories, reached through no symlink, and the requested admin
+ * directory must sit at `<target>/worktrees/<name>`. Anything else leaves the boundary exactly as
+ * requested, rather than widening it into a temp directory, an ancestor, or another repository's
+ * `.git` that only looks like a common directory.
+ */
+async function linkedWorktreeCommonDir(adminPath) {
+    const pointer = join(adminPath, 'commondir');
+    try {
+        if ((await realTargetTypeFor(pointer)) !== 'file')
+            return undefined;
+        const raw = await fs.readFile(pointer, 'utf8');
+        if (raw.length > MAX_GIT_COMMON_DIR_POINTER_CHARS)
+            return undefined;
+        const target = raw.trim();
+        if (!target || target.includes('\0'))
+            return undefined;
+        const resolved = await realpathAllowMissing(resolve(adminPath, target));
+        if (!(await isGitCommonDir(resolved)))
+            return undefined;
+        // Git's own contract for a linked worktree is that the admin directory lives at
+        // `<commondir>/worktrees/<name>`. Proving that relationship is what stops a directory that
+        // merely looks like a Git directory - a temp dir, an ancestor, another repository's `.git` -
+        // from replacing the subtree the caller actually asked for.
+        const [ownAdmin, requestedAdmin] = await Promise.all([
+            fs.realpath(join(resolved, 'worktrees', basename(adminPath))),
+            fs.realpath(adminPath),
+        ]);
+        return ownAdmin === requestedAdmin ? resolved : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function isGitCommonDir(path) {
+    if ((await realTargetTypeFor(path)) !== 'directory')
+        return false;
+    return ((await realTargetTypeFor(join(path, 'objects'))) === 'directory' &&
+        (await realTargetTypeFor(join(path, 'refs'))) === 'directory');
+}
+/**
+ * `lstat`-backed {@link targetTypeFor}: a symlink is not proof that a repository layout is real, so
+ * the `commondir` marker and the entries that qualify its target are inspected without following
+ * links.
+ */
+async function realTargetTypeFor(path) {
+    try {
+        const stat = await fs.lstat(path);
+        if (stat.isFile())
+            return 'file';
+        if (stat.isDirectory())
+            return 'directory';
+        return 'other';
+    }
+    catch (error) {
+        if (isMissingPathError(error))
+            return 'missing';
+        throw error;
+    }
+}
 async function targetTypeFor(path) {
     try {
         const stat = await fs.stat(path);