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

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

@@ -0,0 +1,178 @@
+/*
+ * 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.
+ */
+/**
+ * Export one Session, and the subagent subtree under it, as a portable bundle.
+ *
+ * The preparation is `exportSessionBundleState()` in `@maka/storage`, which
+ * already takes a consistent database snapshot, keeps writers out, filters the
+ * copy down to the exported Sessions, carries the context-offload closure, and
+ * proves the result with `PRAGMA foreign_key_check`. This module is the thin
+ * part: point it at a workspace, ask for a quiescent Session, and seal what
+ * comes back with the bundle codec.
+ *
+ * What it adds on top is the manifest — the Sessions carried, the schema
+ * versions the SOURCE database registers, and the connection by slug and model
+ * so an importer can resolve it locally. No credential is carried: the state
+ * allow-list in the export policy decides what is copied, and configuration is
+ * not on it.
+ */
+import { mkdir, 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 { exportSessionBundleState, SessionBundleExportError, SESSION_BUNDLE_OMITTED_EVENT_TYPES, } from '@maka/storage/session-bundle-policy';
+export const SESSION_EXPORT_MEDIA_TYPE = 'application/vnd.maka.session-export+json;version=1';
+/** Generous by design; the codec is what enforces them. */
+export const SESSION_EXPORT_BUNDLE_LIMITS = {
+    maxCompressedBytes: 2 * 1024 ** 3,
+    maxDecompressedTarBytes: 8 * 1024 ** 3,
+    maxPayloadBytes: 8 * 1024 ** 3,
+    maxFileBytes: 2 * 1024 ** 3,
+    maxEntryCount: 1_000_000,
+    maxManifestBytes: 4 * 1024 ** 2,
+    maxStateIdentityBytes: 4 * 1024 ** 2,
+    maxPathBytes: 4096,
+    maxPathDepth: 32,
+};
+export async function exportSessionBundle(input) {
+    if (!(await isDirectory(input.workspaceRoot))) {
+        return {
+            ok: false,
+            reason: { kind: 'workspace_not_found', workspaceRoot: input.workspaceRoot },
+        };
+    }
+    if (await exists(input.destination)) {
+        return { ok: false, reason: { kind: 'destination_exists' } };
+    }
+    const staging = await mkdtemp(join(tmpdir(), 'maka-session-export-'));
+    try {
+        const stateRoot = join(staging, 'state');
+        const workspaceRoot = join(staging, 'workspace');
+        // The codec seals a state tree beside a workspace tree. A Session's own
+        // files are the state; the user's project directory is not part of the
+        // conversation and is deliberately absent.
+        await mkdir(workspaceRoot, { recursive: true });
+        let plan;
+        try {
+            plan = await exportSessionBundleState({
+                stateRoot: input.workspaceRoot,
+                // Maka's desktop layout keeps state and configuration in one directory,
+                // so these are shared on purpose. Configuration stays out of the bundle
+                // because the policy copies an allow-list of state entries, not because
+                // the roots are apart.
+                configRoot: input.workspaceRoot,
+                allowShared: true,
+                destinationRoot: stateRoot,
+                sessionId: input.sessionId,
+                ...(input.lease ? { lease: input.lease } : {}),
+                requireQuiescent: true,
+                includeSubtree: true,
+                omitDiagnostics: true,
+            });
+        }
+        catch (error) {
+            const failure = asExportFailure(error, input.workspaceRoot);
+            if (failure)
+                return { ok: false, reason: failure };
+            throw error;
+        }
+        const manifest = {
+            format: 'maka.session-export',
+            formatVersion: 1,
+            exportedAt: (input.now ?? Date.now)(),
+            rootSessionId: plan.sessionId,
+            sessionIds: plan.sessionIds,
+            schema: plan.sourceSchema,
+            connection: plan.connection,
+            includedEntries: plan.includedEntries,
+            excludedEntries: plan.excludedEntries,
+            diagnosticsOmitted: true,
+            omittedEventTypes: SESSION_BUNDLE_OMITTED_EVENT_TYPES,
+        };
+        const stateIdentity = {
+            mediaType: SESSION_EXPORT_MEDIA_TYPE,
+            bytes: Buffer.from(`${JSON.stringify(manifest)}\n`, 'utf8'),
+        };
+        const artifact = await createSessionBundleFileService().pack({
+            snapshot: { stateRoot, workspaceRoot, stateIdentity },
+            envelope: { sessionId: plan.sessionId },
+            destination: input.destination,
+            limits: input.limits ?? SESSION_EXPORT_BUNDLE_LIMITS,
+        });
+        return { ok: true, artifact, export: manifest };
+    }
+    catch (error) {
+        if (error instanceof SessionBundleFileError) {
+            if (error.details?.quota !== undefined) {
+                return { ok: false, reason: { kind: 'bundle_limit', details: error.details } };
+            }
+            // The precheck fails fast, but the packer publishes atomically and can
+            // still lose the race. Reporting that as a generic IO failure would give
+            // a caller a different exit code for the same outcome.
+            if (error.code === 'destination_exists') {
+                return { ok: false, reason: { kind: 'destination_exists' } };
+            }
+            return { ok: false, reason: { kind: 'io_failed', message: error.message } };
+        }
+        const failure = asExportFailure(error, input.workspaceRoot);
+        if (failure)
+            return { ok: false, reason: failure };
+        return { ok: false, reason: { kind: 'io_failed', message: String(error) } };
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true }).catch(() => { });
+    }
+}
+function asExportFailure(error, workspaceRoot) {
+    if (!(error instanceof SessionBundleExportError))
+        return undefined;
+    switch (error.code) {
+        case 'session_active':
+            return { kind: 'session_active', message: error.message };
+        case 'schema_unsupported':
+            return { kind: 'schema_unsupported', message: error.message };
+        case 'symlink':
+        case 'path_escape':
+        case 'unsupported_entry':
+            return { kind: 'artifact_unsafe', message: error.message };
+        case 'missing_entry':
+            return { kind: 'artifact_missing', message: error.message };
+        case 'invalid_root':
+            // The policy reports a missing Session through this code too, and only
+            // the message separates it from a directory that is not a workspace.
+            return /session does not exist/i.test(error.message)
+                ? { kind: 'session_not_found' }
+                : { kind: 'workspace_not_found', workspaceRoot };
+        case 'destination_not_empty':
+            return { kind: 'destination_exists' };
+        default:
+            return { kind: 'io_failed', message: error.message };
+    }
+}
+async function isDirectory(path) {
+    return stat(path)
+        .then((metadata) => metadata.isDirectory())
+        .catch(() => false);
+}
+async function exists(path) {
+    return stat(path)
+        .then(() => true)
+        .catch(() => false);
+}

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 };

package/node_modules/@maka/runtime/dist/shell-run-manager.js

@@ -1677,13 +1677,16 @@ function normalizeBackgroundTimeoutMs(value) {
     }
     return value;
 }
-function splitPtyData(data) {
-    const codePoints = Array.from(data);
-    const chunks = [];
-    for (let offset = 0; offset < codePoints.length; offset += PTY_RAW_INPUT_CHUNK_CODE_POINTS) {
-        chunks.push(codePoints.slice(offset, offset + PTY_RAW_INPUT_CHUNK_CODE_POINTS).join(''));
+function* splitPtyData(data) {
+    // Bound each published piece without materializing the entire callback as code points.
+    let offset = 0;
+    while (offset < data.length) {
+        const start = offset;
+        for (let count = 0; count < PTY_RAW_INPUT_CHUNK_CODE_POINTS && offset < data.length; count++) {
+            offset += data.codePointAt(offset) > 0xffff ? 2 : 1;
+        }
+        yield data.slice(start, offset);
     }
-    return chunks;
 }
 function encodedPtyDataBytes(data) {
     return Buffer.byteLength(JSON.stringify(data), 'utf8');

package/node_modules/@maka/runtime/dist/shell-run-tool-result.js

@@ -212,16 +212,23 @@ function takeTailText(text, budget) {
     return { text: `${TRUNCATED_MARKER}\n${tail}`, truncated: true };
 }
 function sliceUtf8Tail(text, budget) {
-    const characters = Array.from(text);
-    let result = '';
+    const characters = [];
     let bytes = 0;
-    for (let index = characters.length - 1; index >= 0; index -= 1) {
-        const character = characters[index];
+    for (let end = text.length; end > 0;) {
+        let start = end - 1;
+        const last = text.charCodeAt(start);
+        if (last >= 0xdc00 && last <= 0xdfff && start > 0) {
+            const previous = text.charCodeAt(start - 1);
+            if (previous >= 0xd800 && previous <= 0xdbff)
+                start -= 1;
+        }
+        const character = text.slice(start, end);
         const size = Buffer.byteLength(character, 'utf8');
         if (bytes + size > budget)
             break;
-        result = character + result;
+        characters.push(character);
         bytes += size;
+        end = start;
     }
-    return result;
+    return characters.reverse().join('');
 }

package/node_modules/@maka/runtime/dist/stream-graph-coordinator.js

@@ -286,17 +286,30 @@ export class AgentGraphCoordinator {
     /** Reconcile now and surface any host-level failure to explicit callers. */
     async reconcile(rootSessionId) {
         await this.#assertRootSupervisor(rootSessionId);
-        const driver = await this.#driver(rootSessionId);
-        driver.lastError = undefined;
-        driver.paused = false;
-        this.#requestDrive(driver);
-        await this.waitForIdle(rootSessionId);
-        if (driver.lastError !== undefined)
-            throw driver.lastError;
-        if (!driver.lastResult) {
-            throw new Error(`Agent graph ${driver.graphId} produced no reconciliation result`);
+        let driver = await this.#driver(rootSessionId);
+        // A lookup started before handover can return after its driver retired.
+        while (driver.closed && !this.#closed)
+            driver = await this.#driver(rootSessionId);
+        driver.reconciliationReaders += 1;
+        try {
+            driver.lastError = undefined;
+            driver.paused = false;
+            this.#requestDrive(driver);
+            // An epoch handover must not redirect this caller to the next driver.
+            while (driver.task)
+                await driver.task;
+            if (driver.lastError !== undefined)
+                throw driver.lastError;
+            if (!driver.lastResult) {
+                throw new Error(`Agent graph ${driver.graphId} produced no reconciliation result`);
+            }
+            return driver.lastResult;
+        }
+        finally {
+            driver.reconciliationReaders -= 1;
+            if (driver.closed && driver.reconciliationReaders === 0)
+                driver.lastResult = undefined;
         }
-        return driver.lastResult;
     }
     async waitForIdle(rootSessionId) {
         const driver = await this.#driver(rootSessionId);
@@ -1014,15 +1027,32 @@ export class AgentGraphCoordinator {
             const latest = await this.currentGraphEpoch(rootSessionId);
             if (latest.graphId !== current.graphId) {
                 selected = latest;
+                if (driver)
+                    void this.#retireDriver(driver);
                 return;
             }
             if ((await this.#readSessionStateForGraph(rootSessionId, current.graphId)) !== 'terminal') {
                 return;
             }
             selected = await this.advanceGraphEpoch(rootSessionId, current);
+            if (driver)
+                void this.#retireDriver(driver);
         });
         return selected;
     }
+    async #retireDriver(driver) {
+        // Tool closures can outlive their epoch. Fence them and let already
+        // admitted operations finish before releasing their complete snapshots.
+        // Cleanup belongs to the old epoch; its teardown I/O must not block the next.
+        driver.closed = true;
+        driver.requested = false;
+        await Promise.allSettled([driver.task, driver.stopTask]);
+        await this.#waitForClientProjectionUpdates(driver);
+        if (driver.reconciliationReaders === 0)
+            driver.lastResult = undefined;
+        driver.runtimeFailureRunIds.clear();
+        // Keep the lightweight driver for projection repair and close diagnostics.
+    }
     async #readSessionStateForGraph(rootSessionId, graphId) {
         const snapshot = buildAgentGraphClientSnapshot(await this.#readClientModelInputForGraph(rootSessionId, graphId));
         if (snapshot.scheduleRevision === 0)
@@ -1094,6 +1124,7 @@ export class AgentGraphCoordinator {
             stopGeneration: 0,
             driveGeneration: 0,
             closed: false,
+            reconciliationReaders: 0,
             clientProjectionDirty: false,
             runtimeFailureRunIds: new Set(),
             yieldWaiters: new Set(),
@@ -1125,6 +1156,8 @@ export class AgentGraphCoordinator {
         this.#requestDrive(driver);
     }
     #requestDrive(driver) {
+        if (driver.closed || this.#closed)
+            return;
         driver.requested = true;
         if (driver.task)
             return;

package/node_modules/@maka/runtime/dist/stream-graph-handoff.js

@@ -143,7 +143,12 @@ function truncateUtf8(text, maxBytes) {
     const ellipsisBytes = Buffer.byteLength(ellipsis, 'utf8');
     if (maxBytes < ellipsisBytes)
         return '';
-    const codePoints = Array.from(text);
+    const codePoints = [];
+    for (const point of text) {
+        if (codePoints.length >= maxBytes)
+            break;
+        codePoints.push(point);
+    }
     let low = 0;
     let high = codePoints.length;
     let best = ellipsis;

package/node_modules/@maka/runtime/dist/subscription-model-fetch.js

@@ -151,10 +151,7 @@ async function checkedOpenAiCodexFetch(fetchFn, url, init, refreshOAuthAccessTok
         const response = await fetchFn(url, requestInit);
         if (response.ok)
             return response;
-        const detail = await response
-            .clone()
-            .text()
-            .catch(() => '');
+        const detail = await response.text().catch(() => '');
         if (response.status === 401 &&
             !authorizationReplayUsed &&
             refreshOAuthAccessToken &&

package/node_modules/@maka/runtime/dist/system-prompt/workspace-instructions.js

@@ -112,12 +112,12 @@ async function readWorkspaceInstructions(rootCandidate, scope) {
             if (seenDigests.has(digest))
                 continue;
             seenDigests.add(digest);
-            const chars = Array.from(cleaned).length;
+            const text = truncateCodepoints(cleaned, MAX_WORKSPACE_INSTRUCTION_FILE_CHARS);
             out.push({
                 file,
                 scope,
-                text: truncateCodepoints(cleaned, MAX_WORKSPACE_INSTRUCTION_FILE_CHARS),
-                truncated: chars > MAX_WORKSPACE_INSTRUCTION_FILE_CHARS,
+                text,
+                truncated: text.length < cleaned.length,
             });
         }
         catch {
@@ -130,8 +130,13 @@ function cleanPromptText(text) {
     return text.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, '');
 }
 function truncateCodepoints(text, max) {
-    const chars = Array.from(text);
-    if (chars.length <= max)
+    if (text.length <= max)
         return text;
-    return chars.slice(0, Math.max(0, max)).join('');
+    const chars = [];
+    for (const char of text) {
+        if (chars.length >= max)
+            return chars.join('');
+        chars.push(char);
+    }
+    return text;
 }

package/node_modules/@maka/runtime/dist/tavily-search.js

@@ -126,9 +126,9 @@ function mapTavilyRows(raw, limit) {
             continue;
         rows.push({
             provider: 'tavily',
-            title: safeString(rawRow.title, location.url).slice(0, TAVILY_RESULT_TITLE_MAX_CHARS),
+            title: truncateResultText(safeString(rawRow.title, location.url), TAVILY_RESULT_TITLE_MAX_CHARS),
             url: location.url,
-            snippet: safeString(rawRow.content).slice(0, TAVILY_RESULT_SNIPPET_MAX_CHARS),
+            snippet: truncateResultText(safeString(rawRow.content), TAVILY_RESULT_SNIPPET_MAX_CHARS),
             source: location.source,
         });
         if (rows.length >= limit)
@@ -166,6 +166,12 @@ async function readBoundedJson(response, maxBytes) {
 function safeString(value, fallback = '') {
     return typeof value === 'string' ? value : fallback;
 }
+function truncateResultText(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    // Detach bounded results from large provider strings, preserving even unpaired UTF-16 surrogates.
+    return Buffer.from(value.slice(0, maxChars), 'utf16le').toString('utf16le');
+}
 function normalizeResultLocation(value) {
     if (typeof value !== 'string' || value.length > TAVILY_RESULT_URL_MAX_CHARS)
         return null;

package/node_modules/@maka/runtime/dist/text-line-window.js

@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+// Match split('\n').slice(offset, end).join('\n'), without creating entries
+// for lines outside the requested window. Empty and trailing lines count too.
+// A missing or zero limit is unbounded: end is the total line count.
+export function readTextLineWindow(content, offset, limit) {
+    if (offset === undefined && limit === undefined)
+        return content;
+    let lineCount = 1;
+    for (let cursor = content.indexOf('\n'); cursor !== -1; cursor = content.indexOf('\n', cursor + 1)) {
+        lineCount++;
+    }
+    const start = offset ?? 0;
+    const end = limit ? start + limit : lineCount;
+    const from = sliceIndex(start, lineCount);
+    const to = sliceIndex(end, lineCount);
+    if (from >= to)
+        return '';
+    const selected = [];
+    let cursor = 0;
+    for (let line = 0; line < to; line++) {
+        const newline = content.indexOf('\n', cursor);
+        const lineEnd = newline === -1 ? content.length : newline;
+        if (line >= from)
+            selected.push(content.slice(cursor, lineEnd));
+        cursor = lineEnd + 1;
+    }
+    return selected.join('\n');
+}
+function sliceIndex(value, length) {
+    const integer = Math.trunc(value) || 0;
+    return integer < 0 ? Math.max(length + integer, 0) : Math.min(integer, length);
+}