maka-agent 0.2.0-dev.27.20260910 → 0.2.0-dev.28.20260911

package/node_modules/@maka/runtime/dist/bots/wechat-bridge.js

@@ -172,10 +172,11 @@ export class WechatBridge extends BaseBotAdapter {
         const baseUrl = normalizeWechatBridgeUrl(this.settings.webhookUrl);
         if (!baseUrl)
             return;
+        const cursor = { sinceEpochSeconds };
         while (this.running) {
             this.abortController = new AbortController();
             try {
-                const response = await proxiedFetch(`${baseUrl}/messages/stream?since=${sinceEpochSeconds}`, {
+                const response = await proxiedFetch(`${baseUrl}/messages/stream?since=${cursor.sinceEpochSeconds}`, {
                     method: 'GET',
                     headers: wechatBridgeHeaders(this.settings),
                     signal: this.abortController.signal,
@@ -183,19 +184,8 @@ export class WechatBridge extends BaseBotAdapter {
                 });
                 if (!response.ok || !response.body)
                     throw new Error(`WeChat stream HTTP ${response.status}`);
-                for await (const raw of readSseJsonObjects(response.body)) {
-                    const messages = Array.isArray(raw) ? raw : [raw];
-                    for (const message of messages) {
-                        const event = mapWechatBridgeMessage(message);
-                        if (!event)
-                            continue;
-                        sinceEpochSeconds = Math.max(sinceEpochSeconds, Math.floor(event.receivedAt / 1000));
-                        this.readiness = 'operational';
-                        this.reason = undefined;
-                        this.emitIncomingMessage(event);
-                        this.emitStatusChange();
-                    }
-                }
+                const messages = readSseJsonObjects(response.body);
+                while (await this.processNextLiveMessages(messages, cursor)) { }
                 if (this.running)
                     await sleep(1_000);
             }
@@ -212,6 +202,31 @@ export class WechatBridge extends BaseBotAdapter {
             }
         }
     }
+    async processNextLiveMessages(stream, cursor) {
+        // Keep the iterator result and mapped events out of the next idle read's frame.
+        const next = await stream.next();
+        if (next.done)
+            return false;
+        try {
+            const messages = Array.isArray(next.value) ? next.value : [next.value];
+            for (const message of messages) {
+                const event = mapWechatBridgeMessage(message);
+                if (!event)
+                    continue;
+                cursor.sinceEpochSeconds = Math.max(cursor.sinceEpochSeconds, Math.floor(event.receivedAt / 1000));
+                this.readiness = 'operational';
+                this.reason = undefined;
+                this.emitIncomingMessage(event);
+                this.emitStatusChange();
+            }
+            return true;
+        }
+        catch (error) {
+            // Match for-await: close after processing failures, preserving the original error.
+            await stream.return(undefined).catch(() => { });
+            throw error;
+        }
+    }
     async streamIlinkMessages(cursor) {
         const baseUrl = normalizeWechatIlinkBaseUrl(this.settings.webhookUrl);
         const token = this.settings.token.trim();
@@ -402,24 +417,67 @@ export function mapWechatIlinkMessage(raw) {
 }
 export async function* readSseJsonObjects(body) {
     const decoder = new TextDecoder();
+    const iterator = body[Symbol.asyncIterator]();
     let buffer = '';
-    for await (const chunk of body) {
-        buffer += decoder.decode(chunk, { stream: true });
-        let boundary = findSseBoundary(buffer);
-        while (boundary) {
-            const event = buffer.slice(0, boundary.index);
-            buffer = buffer.slice(boundary.index + boundary.length);
-            const data = event
-                .split(/\r?\n/)
-                .filter((line) => line.startsWith('data:'))
-                .map((line) => line.slice(5).trimStart())
-                .join('\n')
-                .trim();
-            if (data)
-                yield JSON.parse(data);
-            boundary = findSseBoundary(buffer);
+    let closeIterator = false;
+    try {
+        while (true) {
+            // A rejected next() does not close its iterator under for-await semantics.
+            closeIterator = false;
+            let text = await readSseTextChunk(iterator, decoder);
+            if (text === undefined)
+                return;
+            closeIterator = true;
+            buffer += text;
+            text = undefined;
+            let boundary = findSseBoundary(buffer);
+            while (boundary) {
+                let data = sseEventData(buffer.slice(0, boundary.index));
+                buffer = buffer.slice(boundary.index + boundary.length);
+                if (data)
+                    yield JSON.parse(data);
+                data = '';
+                boundary = findSseBoundary(buffer);
+            }
+        }
+    }
+    catch (error) {
+        if (closeIterator) {
+            closeIterator = false;
+            try {
+                await iterator.return?.();
+            }
+            catch { }
         }
+        throw error;
+    }
+    finally {
+        if (closeIterator)
+            await iterator.return?.();
+    }
+}
+async function readSseTextChunk(iterator, decoder) {
+    const next = await iterator.next();
+    if (next.done)
+        return;
+    try {
+        return decoder.decode(next.value, { stream: true });
     }
+    catch (error) {
+        try {
+            await iterator.return?.();
+        }
+        catch { }
+        throw error;
+    }
+}
+function sseEventData(event) {
+    return event
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith('data:'))
+        .map((line) => line.slice(5).trimStart())
+        .join('\n')
+        .trim();
 }
 export async function testWechatBridge(channel) {
     const baseUrl = normalizeWechatBridgeUrl(channel.webhookUrl);

package/node_modules/@maka/runtime/dist/bots/wecom-bridge.js

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { WSClient } from '@wecom/aibot-node-sdk';
+import { createRequire } from 'node:module';
 import { BaseBotAdapter, botReadinessFromSettings } from './base-adapter.js';
 const AUTH_TIMEOUT_MS = 15_000;
 /** Detach bridge callbacks before disconnect can synchronously emit. */
@@ -78,36 +78,39 @@ export class WeComBotBridge extends BaseBotAdapter {
             return;
         }
         this.explicitlyStopped = false;
-        const client = new WSClient({
-            botId,
-            secret,
-            maxReconnectAttempts: -1,
-            logger: quietLogger,
-        });
-        this.client = client;
-        this.wire(client, botId);
-        await new Promise((resolve, reject) => {
-            let settled = false;
-            const onAuthenticated = () => finish(resolve);
-            const onError = (error) => finish(() => reject(error));
-            const cleanup = () => {
-                clearTimeout(timer);
-                client.off('authenticated', onAuthenticated);
-                client.off('error', onError);
-            };
-            const finish = (fn) => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                fn();
-            };
-            const timer = setTimeout(() => finish(() => reject(new Error('WeCom authentication timed out'))), AUTH_TIMEOUT_MS);
-            client.once('authenticated', onAuthenticated);
-            client.once('error', onError);
-            client.connect();
-        })
-            .then(() => {
+        let startedClient;
+        try {
+            const { WSClient } = createRequire(import.meta.url)('@wecom/aibot-node-sdk');
+            const client = new WSClient({
+                botId,
+                secret,
+                maxReconnectAttempts: -1,
+                logger: quietLogger,
+            });
+            startedClient = client;
+            this.client = client;
+            this.wire(client, botId);
+            await new Promise((resolve, reject) => {
+                let settled = false;
+                const onAuthenticated = () => finish(resolve);
+                const onError = (error) => finish(() => reject(error));
+                const cleanup = () => {
+                    clearTimeout(timer);
+                    client.off('authenticated', onAuthenticated);
+                    client.off('error', onError);
+                };
+                const finish = (fn) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    fn();
+                };
+                const timer = setTimeout(() => finish(() => reject(new Error('WeCom authentication timed out'))), AUTH_TIMEOUT_MS);
+                client.once('authenticated', onAuthenticated);
+                client.once('error', onError);
+                client.connect();
+            });
             if (this.explicitlyStopped || this.client !== client)
                 return;
             this.running = true;
@@ -116,17 +119,18 @@ export class WeComBotBridge extends BaseBotAdapter {
             this.reason = undefined;
             this.readiness = 'credentials_valid';
             this.emitStatusChange();
-        })
-            .catch((error) => {
-            if (this.explicitlyStopped || this.client !== client)
+        }
+        catch (error) {
+            if (this.explicitlyStopped || (startedClient && this.client !== startedClient))
                 return;
             this.running = false;
             this.recordFailure(error);
             this.readiness = 'configured';
             this.emitStatusChange();
             this.client = null;
-            closeWeComClient(client);
-        });
+            if (startedClient)
+                closeWeComClient(startedClient);
+        }
     }
     async stop() {
         this.explicitlyStopped = true;

package/node_modules/@maka/runtime/dist/computer-use-tools.js

@@ -945,6 +945,7 @@ export function buildComputerUseTools(deps) {
             release();
             if (invocationQueues.get(sessionId) === current) {
                 invocationQueues.delete(sessionId);
+                presentationGenerations.delete(sessionId);
             }
         }
     }
@@ -2385,7 +2386,9 @@ export function buildComputerUseTools(deps) {
     }
     const tools = [tool];
     tools.clearSession = (sessionId) => {
-        presentationGenerations.set(sessionId, (presentationGenerations.get(sessionId) ?? 0) + 1);
+        if (invocationQueues.has(sessionId)) {
+            presentationGenerations.set(sessionId, (presentationGenerations.get(sessionId) ?? 0) + 1);
+        }
         for (const wake of presentationQueueWaiters.get(sessionId) ?? [])
             wake();
         for (const wake of presentationWaiters.get(sessionId) ?? [])

package/node_modules/@maka/runtime/dist/deep-research-tools.js

@@ -142,14 +142,20 @@ function buildReadArtifactTool(deps) {
             }
             const offset = input.offset_chars ?? 0;
             const maxChars = input.max_chars ?? DEEP_RESEARCH_ARTIFACT_READ_DEFAULT_CHARS;
-            const characters = Array.from(read.text);
-            const end = Math.min(characters.length, offset + maxChars);
-            const chunk = safeResearchArtifactContent(characters.slice(offset, end).join(''));
+            const selected = [];
+            let total = 0;
+            for (const character of read.text) {
+                if (total >= offset && total < offset + maxChars)
+                    selected.push(character);
+                total += 1;
+            }
+            const end = Math.min(total, offset + maxChars);
+            const chunk = safeResearchArtifactContent(selected.join(''));
             return [
-                `<deep-research-artifact id="${ref.artifactId}" role="${ref.role}" offset="${offset}" end="${end}" total="${characters.length}">`,
+                `<deep-research-artifact id="${ref.artifactId}" role="${ref.role}" offset="${offset}" end="${end}" total="${total}">`,
                 `Name: ${normalizeInlineText(ref.name)}`,
                 ...(ref.locator ? [`Locator: ${normalizeInlineText(ref.locator)}`] : []),
-                `Truncated: ${end < characters.length}`,
+                `Truncated: ${end < total}`,
                 '',
                 chunk,
                 '</deep-research-artifact>',

package/node_modules/@maka/runtime/dist/edit-replace.js

@@ -139,10 +139,10 @@ export function computeEditedSource(source, oldString, newString, where) {
     function finish(content, span, replacement, matchedVia) {
         const index = content.indexOf(span);
         const before = content.slice(0, index);
-        const startLine = before.split('\n').length;
+        const startLine = countOccurrences(before, '\n') + 1;
         // A trailing newline in the span is the last line's terminator, not an
         // extra line, so it must not bump endLine.
-        const spanLineCount = span.split('\n').length - (span.endsWith('\n') ? 1 : 0);
+        const spanLineCount = countOccurrences(span, '\n') + 1 - (span.endsWith('\n') ? 1 : 0);
         const endLine = startLine + Math.max(spanLineCount, 1) - 1;
         // slice-join (not String.replace) so `$&`/`$1` in newString are literal.
         const next = before + replacement + content.slice(index + span.length);

package/node_modules/@maka/runtime/dist/filesystem-worker/operations.js

@@ -25,6 +25,7 @@ import { sandboxPathApi } from './sandbox-paths.js';
 import { sandboxBoundaryExpansionAllowsPath } from '@maka/core/sandbox-boundary';
 import { ApplyPatchRejectedError, applyUpdateToContent, createPatchedFile, } from '../apply-patch-file.js';
 import { computeEditedSource } from '../edit-replace.js';
+import { readTextLineWindow } from '../text-line-window.js';
 import { createEditUnifiedDiff, createUnifiedDiff } from '../unified-diff.js';
 import { compareAndDeleteEntry, hostVisibilityAfterWrite, openStableTarget, readModifyWriteThroughHandle, StableWriteFailure, writeThroughHandle, } from '../file-stable-write.js';
 import { isSupportedImagePath, readWorkspaceImage } from '../image-file.js';
@@ -75,12 +76,10 @@ export async function executeFilesystemOperation(operation, operationBoundary, d
                 }
             }
             const content = await fs.readFile(path, 'utf8');
-            if (operation.offset === undefined && operation.limit === undefined)
-                return { kind: 'read', content };
-            const lines = content.split('\n');
-            const start = operation.offset ?? 0;
-            const end = operation.limit ? start + operation.limit : lines.length;
-            return { kind: 'read', content: lines.slice(start, end).join('\n') };
+            return {
+                kind: 'read',
+                content: readTextLineWindow(content, operation.offset, operation.limit),
+            };
         }
         case 'write': {
             const path = await resolveWritableAllowed(operation.cwd, operation.path, 'Write', operationBoundary);

package/node_modules/@maka/runtime/dist/memory-extraction-evidence.js

@@ -273,7 +273,13 @@ function historyRole(event) {
     return event.role === 'model' ? 'assistant' : 'user';
 }
 function sliceCodePoints(value, maximum) {
-    return Array.from(value).slice(0, maximum).join('');
+    const prefix = [];
+    for (const point of value) {
+        if (prefix.length >= maximum)
+            break;
+        prefix.push(point);
+    }
+    return prefix.join('');
 }
 function uniqueSorted(values) {
     return [...new Set(values)].sort((left, right) => left - right);

package/node_modules/@maka/runtime/dist/memory-extraction.js

@@ -369,7 +369,7 @@ export class MemoryExtractionEngine {
                     return undefined;
                 maximumSplitIndex = requestedTurnStart;
             }
-            const split = memoryRangeSplitCandidates(pendingEntries, maximumSplitIndex).find(({ first, second }) => {
+            const split = findMemoryRangeSplit(pendingEntries, maximumSplitIndex, ({ first, second }) => {
                 const firstThroughOrdinal = first.at(-1).ordinal;
                 const firstTrigger = 'extract';
                 const firstPrepared = this.prepareRange({
@@ -924,9 +924,9 @@ function memorySegmentOperationId(operationId, afterOrdinal, throughOrdinal, por
         .update(JSON.stringify({ operationId, afterOrdinal, throughOrdinal }))
         .digest('hex')}`;
 }
-function memoryRangeSplitCandidates(entries, maximumSplitIndex = entries.length - 1) {
+function findMemoryRangeSplit(entries, maximumSplitIndex = entries.length - 1, accepts) {
     if (entries.length < 2)
-        return [];
+        return undefined;
     const weights = entries.map(memoryRangeEventWeight);
     const total = weights.reduce((sum, weight) => sum + weight, 0);
     let prefix = 0;
@@ -942,11 +942,16 @@ function memoryRangeSplitCandidates(entries, maximumSplitIndex = entries.length
         };
     })
         .filter(({ index }) => index <= maximumSplitIndex);
-    return candidates
-        .sort((left, right) => Number(right.turnBoundary) - Number(left.turnBoundary) ||
+    candidates.sort((left, right) => Number(right.turnBoundary) - Number(left.turnBoundary) ||
         left.distance - right.distance ||
-        left.index - right.index)
-        .map(({ index }) => ({ first: entries.slice(0, index), second: entries.slice(index) }));
+        left.index - right.index);
+    // Keep only the candidate being checked; each pair copies the entire range.
+    for (const { index } of candidates) {
+        const split = { first: entries.slice(0, index), second: entries.slice(index) };
+        if (accepts(split))
+            return split;
+    }
+    return undefined;
 }
 function preparedMemoryRangeFits(prepared, trigger) {
     if (!prepared)

package/node_modules/@maka/runtime/dist/openai-responses-websocket.js

@@ -221,11 +221,8 @@ function prepareWireRequest(body, baseline) {
     const { previous_response_id: _previousResponseId, ...currentProperties } = body;
     const fullBody = {
         ...currentProperties,
-        input: [
-            ...structuredClone(baseline.fullBody.input),
-            ...structuredClone(baseline.responseOutput),
-            ...structuredClone(body.input),
-        ],
+        // These JSON values are privately owned; only the combined input array needs to be new.
+        input: [...baseline.fullBody.input, ...baseline.responseOutput, ...body.input],
     };
     const sameProperties = isDeepStrictEqual(requestProperties(baseline.fullBody), requestProperties(fullBody));
     return {

package/node_modules/@maka/runtime/dist/plugin-composition-loader.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+/// <reference lib="es2023.collection" />
 import { Context } from './plugin-kernel.js';
 import { fiberStateName, MakaPluginRuntimeError, MakaPluginTransactionBuffer, validateCompositionEntry, validatePluginPackage, validatePluginRootId, } from './plugin-runtime.js';
 const FIBER_PENDING = 0;
@@ -25,7 +26,13 @@ export class MakaCompositionLoader {
     #packages = new Map();
     #roots = new Map();
     #entries = new Map();
+    // Contexts and services can outlive their entries, so intern by symbol lifetime.
     #isolationLabels = new Map();
+    #isolationLabelFinalizer = new FinalizationRegistry(({ label, reference }) => {
+        // An old finalizer must not evict a newer incarnation of the same label.
+        if (this.#isolationLabels.get(label) === reference)
+            this.#isolationLabels.delete(label);
+    });
     #transaction;
     #compositionGeneration = 0;
     #fiberGeneration = 0;
@@ -675,10 +682,12 @@ export class MakaCompositionLoader {
         });
     }
     #isolationLabel(label) {
-        let symbol = this.#isolationLabels.get(label);
+        let symbol = this.#isolationLabels.get(label)?.deref();
         if (!symbol) {
             symbol = Symbol(label);
-            this.#isolationLabels.set(label, symbol);
+            const reference = new WeakRef(symbol);
+            this.#isolationLabels.set(label, reference);
+            this.#isolationLabelFinalizer.register(symbol, { label, reference });
         }
         return symbol;
     }

package/node_modules/@maka/runtime/dist/request-customization-fetch.js

@@ -27,6 +27,13 @@ export function createRequestCustomizationFetch(upstream, customization) {
         return upstream;
     }
     return async (input, init) => {
+        // A temporary Request's derived signal can lose abort forwarding after GC.
+        // Keep the caller's effective signal; explicit null disconnects input.signal.
+        const signal = init?.signal !== undefined
+            ? init.signal
+            : input instanceof Request
+                ? input.signal
+                : undefined;
         const request = new Request(input, init);
         const nextHeaders = new Headers(request.headers);
         for (const [name, value] of Object.entries(headers)) {
@@ -42,9 +49,9 @@ export function createRequestCustomizationFetch(upstream, customization) {
                 if (customization.finalizeBody) {
                     throw new Error('Request body finalizer requires a JSON object request body');
                 }
-                return upstream(request.url, requestInit(request, nextHeaders, body));
+                return upstream(request.url, requestInit(request, nextHeaders, body, signal));
             }
-            const generatedBody = await parseRequestBody(request, customization.finalizeBody
+            const generatedBody = await parseRequestBody(body, customization.finalizeBody
                 ? 'Request body finalizer requires a JSON object request body'
                 : 'Extra request body can only be applied to a JSON object request');
             for (const key of bodyOverlayKeys) {
@@ -56,15 +63,15 @@ export function createRequestCustomizationFetch(upstream, customization) {
             body = JSON.stringify(customization.finalizeBody ? customization.finalizeBody(customizedBody) : customizedBody);
             nextHeaders.delete('content-length');
         }
-        return upstream(request.url, requestInit(request, nextHeaders, body));
+        return upstream(request.url, requestInit(request, nextHeaders, body, signal));
     };
 }
-function requestInit(request, headers, body) {
+function requestInit(request, headers, body, signal) {
     return {
         method: request.method,
         headers: [...headers.entries()],
         ...(body === null ? {} : { body, duplex: 'half' }),
-        signal: request.signal,
+        signal,
         cache: request.cache,
         credentials: request.credentials,
         integrity: request.integrity,
@@ -81,10 +88,10 @@ function requestHasJsonBody(request) {
     const contentType = request.headers.get('content-type');
     return (contentType === null || /(^|\s|;)application\/(?:[\w.+-]+\+)?json(?:\s*;|$)/i.test(contentType));
 }
-async function parseRequestBody(request, invalidBodyMessage) {
+async function parseRequestBody(body, invalidBodyMessage) {
     let parsed;
     try {
-        parsed = JSON.parse(await request.clone().text());
+        parsed = JSON.parse(new TextDecoder().decode(body));
     }
     catch {
         throw new Error(invalidBodyMessage);

package/node_modules/@maka/runtime/dist/session-export.js

@@ -81,6 +81,7 @@ export async function exportSessionBundle(input) {
                 allowShared: true,
                 destinationRoot: stateRoot,
                 sessionId: input.sessionId,
+                ...(input.lease ? { lease: input.lease } : {}),
                 requireQuiescent: true,
                 includeSubtree: true,
                 omitDiagnostics: true,

package/node_modules/@maka/runtime/dist/session-import.js

@@ -0,0 +1,100 @@
+/*
+ * 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 a `.maka-session` bundle into a workspace.
+ *
+ * The mirror of the export: `hydrate()` verifies and unpacks what `pack()`
+ * sealed, and `importSessionBundleState()` merges what the export policy
+ * prepared. This module is the thin part -- verify, merge, report.
+ *
+ * The bundle names its connection by slug; nothing here resolves it. A Session
+ * whose slug this workspace does not have arrives in the state the app already
+ * shows for that: stale, and routable once the user picks a connection.
+ */
+import { mkdtemp, rm, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { SessionBundleFileError, } from '@maka/storage/session-bundle-contract';
+import { createSessionBundleFileService } from '@maka/storage/session-bundle-file-service';
+import { importSessionBundleState, SessionBundleImportError, } from '@maka/storage/session-bundle-policy';
+import { SESSION_EXPORT_BUNDLE_LIMITS } from './session-export.js';
+export async function importSessionBundle(input) {
+    if (!(await isDirectory(input.workspaceRoot))) {
+        return {
+            ok: false,
+            reason: { kind: 'workspace_not_found', workspaceRoot: input.workspaceRoot },
+        };
+    }
+    const limits = input.limits ?? SESSION_EXPORT_BUNDLE_LIMITS;
+    const staging = await mkdtemp(join(tmpdir(), 'maka-session-import-'));
+    try {
+        const service = createSessionBundleFileService();
+        // Read the identity before hydrating: the codec verifies a bundle against a
+        // Session id, and the bundle is the only thing that knows which one.
+        const inspection = await service.inspect({ source: { path: input.source }, limits });
+        const manifest = readExportManifest(inspection.stateIdentity.bytes);
+        const hydration = await service.hydrate({
+            source: { path: input.source },
+            limits,
+            expectedSessionId: manifest?.rootSessionId ?? inspection.manifest.envelope.sessionId,
+            destinationRoot: join(staging, 'hydrated'),
+        });
+        const merged = await importSessionBundleState({
+            stateRoot: input.workspaceRoot,
+            bundleStateRoot: hydration.stateRoot,
+            ...(input.lease ? { lease: input.lease } : {}),
+        });
+        return { ok: true, ...merged, manifest };
+    }
+    catch (error) {
+        if (error instanceof SessionBundleImportError) {
+            switch (error.code) {
+                case 'session_exists':
+                    return { ok: false, reason: { kind: 'session_exists', message: error.message } };
+                case 'schema_unsupported':
+                    return { ok: false, reason: { kind: 'schema_unsupported', message: error.message } };
+                case 'conflict':
+                    return { ok: false, reason: { kind: 'conflict', message: error.message } };
+                default:
+                    return { ok: false, reason: { kind: 'io_failed', message: error.message } };
+            }
+        }
+        if (error instanceof SessionBundleFileError) {
+            return { ok: false, reason: { kind: 'bundle_unreadable', message: error.message } };
+        }
+        return { ok: false, reason: { kind: 'io_failed', message: String(error) } };
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true }).catch(() => { });
+    }
+}
+function readExportManifest(bytes) {
+    try {
+        const parsed = JSON.parse(Buffer.from(bytes).toString('utf8'));
+        return parsed.format === 'maka.session-export' ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function isDirectory(path) {
+    return stat(path)
+        .then((metadata) => metadata.isDirectory())
+        .catch(() => false);
+}

package/node_modules/@maka/runtime/dist/session-manager.js

@@ -3608,7 +3608,12 @@ function buildAgentOutputCommittedResult(input) {
             truncated: withoutText.omittedArtifactIds > 0,
         };
     }
-    const codePoints = Array.from(text);
+    const codePoints = [];
+    for (const point of text) {
+        if (codePoints.length >= input.maxBytes)
+            break;
+        codePoints.push(point);
+    }
     let low = 0;
     let high = codePoints.length;
     let best = { ...withoutText, textTruncated: true };