maka-agent 0.2.0-dev.76.20261009 → 0.2.0-dev.78.20261010

package/node_modules/@maka/core/dist/bot-chat-settings.js

@@ -61,12 +61,14 @@ export function createDefaultBotChannel(provider) {
 }
 export function createDefaultBotChatSettings() {
     return {
+        messageHandling: 'task',
         channels: Object.fromEntries(BOT_PROVIDERS.map((provider) => [provider, createDefaultBotChannel(provider)])),
     };
 }
 export function mergeBotChatSettings(current, patch) {
     return {
         ...current,
+        ...(patch?.messageHandling ? { messageHandling: patch.messageHandling } : {}),
         channels: {
             ...current.channels,
             ...Object.fromEntries(Object.entries(patch?.channels ?? {}).map(([provider, channelPatch]) => {
@@ -93,6 +95,7 @@ export function mergeBotChatSettings(current, patch) {
 }
 export function normalizeBotChatSettings(settings, rawSettings) {
     return {
+        messageHandling: rawSettings?.messageHandling === 'workhub' ? 'workhub' : 'task',
         channels: Object.fromEntries(BOT_PROVIDERS.map((provider) => {
             const rawChannel = rawSettings?.channels?.[provider];
             return [provider, normalizeBotChannel(provider, settings.channels[provider], rawChannel)];

package/node_modules/@maka/core/dist/bot-events.js

@@ -130,14 +130,7 @@ export function plaintextHelpReply() {
     ].join('\n');
 }
 export function formatBotMessageForSession(message) {
-    return `[${botDisplayLabel(message.platform)}:${sanitizeBotUserName(message.userName)}] ${message.text.trim()}`;
-}
-function sanitizeBotUserName(value) {
-    return (value
-        .replace(/[\u0000-\u001F\u007F-\u009F]+/g, ' ')
-        .replace(/[\p{Cf}]+/gu, ' ')
-        .replace(/\s+/g, ' ')
-        .trim() || 'unknown');
+    return `[${botDisplayLabel(message.platform)}] ${message.text.trim()}`;
 }
 /**
  * Non-error `BotStatus.reason` values. These states have their own UI surface,

package/node_modules/@maka/core/dist/local-memory.js

@@ -318,8 +318,11 @@ export function findLocalMemoryEntryDraftRange(input, entryId) {
             end: lineStarts[endLineIndex] ?? input.length,
         };
     };
+    const isCodeFenceLine = createMemoryCodeFenceTracker();
     for (let index = 0; index < lines.length; index += 1) {
         const line = lines[index] ?? '';
+        if (isCodeFenceLine(line))
+            continue;
         const heading = /^##\s+(.+?)\s*$/.exec(line);
         if (heading) {
             const matched = matchCurrent(index);
@@ -421,7 +424,12 @@ function parseLocalMemoryMarkdownRaw(input) {
         }
         current = null;
     };
+    const isCodeFenceLine = createMemoryCodeFenceTracker();
     for (const line of lines) {
+        if (isCodeFenceLine(line)) {
+            current?.body.push(line);
+            continue;
+        }
         const heading = /^##\s+(.+?)\s*$/.exec(line);
         if (heading) {
             flush();
@@ -455,8 +463,29 @@ function stripPromptContent(entry) {
     const { promptContent: _promptContent, ...preview } = entry;
     return preview;
 }
+// All entry readers and editors share fence state so code examples cannot split entries.
+function createMemoryCodeFenceTracker() {
+    let fence;
+    return (line) => {
+        const match = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+        if (fence) {
+            if (match &&
+                match[1][0] === fence.marker &&
+                match[1].length >= fence.length &&
+                match[2].trim() === '') {
+                fence = undefined;
+            }
+            return true;
+        }
+        if (!match || (match[1][0] === '`' && match[2].includes('`')))
+            return false;
+        fence = { marker: match[1][0], length: match[1].length };
+        return true;
+    };
+}
 function parseMetaComment(line) {
-    const match = /^<!--\s*maka-memory:\s*(.*?)\s*-->$/.exec(line.trim());
+    // Four-space or tab indentation denotes a code example, not entry identity or state.
+    const match = /^ {0,3}<!--\s*maka-memory:\s*(.*?)\s*-->[ \t]*$/.exec(line);
     if (!match)
         return null;
     const meta = {};
@@ -482,8 +511,11 @@ function findLocalMemoryEntrySection(input, entryId) {
         const proposalId = current.meta?.proposalId;
         return id === entryId || proposalId === entryId ? { id, ...current } : null;
     };
+    const isCodeFenceLine = createMemoryCodeFenceTracker();
     for (let index = 0; index < lines.length; index += 1) {
         const line = lines[index] ?? '';
+        if (isCodeFenceLine(line))
+            continue;
         const heading = /^##\s+(.+?)\s*$/.exec(line);
         if (heading) {
             const matched = matchCurrent();
@@ -534,8 +566,13 @@ function findLocalMemoryEntryFullSection(input, entryId) {
             },
         };
     };
+    const isCodeFenceLine = createMemoryCodeFenceTracker();
     for (let index = 0; index < lines.length; index += 1) {
         const line = lines[index] ?? '';
+        if (isCodeFenceLine(line)) {
+            current?.body.push(line);
+            continue;
+        }
         const heading = /^##\s+(.+?)\s*$/.exec(line);
         if (heading) {
             const matched = matchCurrent(index);

package/node_modules/@maka/core/dist/scheduled-task.js

@@ -493,23 +493,22 @@ function asFiniteNumber(value) {
         return value;
     return null;
 }
+/**
+ * Calendar recurrence uses Date's local-time rules: shift gaps forward and take
+ * the first repeated time. Rebuild from the anchor so gap shifts do not carry
+ * into later cycles; cron instead skips nonexistent local times.
+ */
 function nextCalendarFireAt(schedule, after) {
     const anchor = new Date(schedule.anchorAt);
-    if (schedule.recurrence === 'daily') {
-        const next = new Date(after);
-        next.setHours(anchor.getHours(), anchor.getMinutes(), anchor.getSeconds(), anchor.getMilliseconds());
-        if (next.getTime() <= after)
-            next.setDate(next.getDate() + 1);
-        return next.getTime();
-    }
-    if (schedule.recurrence === 'weekly') {
-        const next = new Date(after);
-        next.setHours(anchor.getHours(), anchor.getMinutes(), anchor.getSeconds(), anchor.getMilliseconds());
-        const dayDelta = (anchor.getDay() - next.getDay() + 7) % 7;
-        next.setDate(next.getDate() + dayDelta);
-        if (next.getTime() <= after)
-            next.setDate(next.getDate() + 7);
-        return next.getTime();
+    if (schedule.recurrence === 'daily' || schedule.recurrence === 'weekly') {
+        const base = new Date(after);
+        const dayOffset = schedule.recurrence === 'daily' ? 0 : (anchor.getDay() - base.getDay() + 7) % 7;
+        const periodDays = schedule.recurrence === 'daily' ? 1 : 7;
+        // Build each occurrence from the anchor: a DST gap may normalize today's
+        // wall time, but that adjusted hour must not carry into another date.
+        const occurrence = (offset) => new Date(base.getFullYear(), base.getMonth(), base.getDate() + offset, anchor.getHours(), anchor.getMinutes(), anchor.getSeconds(), anchor.getMilliseconds()).getTime();
+        const next = occurrence(dayOffset);
+        return next > after ? next : occurrence(dayOffset + periodDays);
     }
     const afterDate = new Date(after);
     for (let offset = 0; offset <= 480; offset += 1) {

package/node_modules/@maka/core/dist/session.js

@@ -467,6 +467,7 @@ const WORKHUB_DELEGATION_ASSIGNED_MESSAGE_SHAPE = defineObjectShape()([
     'attachments',
     'targetAttachments',
     'returnResults',
+    'executionPermissionMode',
     'create',
     'steered',
     'replacesActionId',
@@ -797,6 +798,8 @@ function isWorkHubCoordinationMessage(message) {
         typeof message.targetSessionName === 'string' &&
         message.targetSessionName.trim().length > 0 &&
         (message.returnResults === undefined || message.returnResults === true) &&
+        (message.executionPermissionMode === undefined ||
+            isPermissionMode(message.executionPermissionMode)) &&
         (message.steered === undefined || message.steered === true) &&
         ((message.schemaVersion === WORKHUB_COORDINATION_RECORD_SCHEMA_VERSION &&
             message.replacesActionId === undefined &&

package/node_modules/@maka/core/dist/text-sanitize.js

@@ -84,6 +84,11 @@ const ZERO_WIDTH_REGEX = /[\u200B-\u200D\u2060-\u2064\uFEFF]/g;
  */
 export function sanitizeUnicodeText(text, opts) {
     const suffix = opts.truncatedSuffix ?? '…';
+    // A negative cap is clamped to zero: without it the loop never breaks (the
+    // whole input is expanded) and the slice's negative end keeps nearly the
+    // whole string — the opposite of the "hard cap" this option promises. Same
+    // boundary contract as truncateUtf16Safe's `maxUnits <= 0` guard.
+    const maxCodePoints = Math.max(0, opts.maxCodePoints);
     const cleaned = text
         .normalize('NFC')
         .replace(CONTROL_CHARS_REGEX, ' ')
@@ -95,12 +100,12 @@ export function sanitizeUnicodeText(text, opts) {
     for (const point of cleaned) {
         points.push(point);
         // One extra point detects truncation without expanding the entire input.
-        if (opts.maxCodePoints >= 0 && points.length > opts.maxCodePoints)
+        if (points.length > maxCodePoints)
             break;
     }
-    if (points.length <= opts.maxCodePoints)
+    if (points.length <= maxCodePoints)
         return cleaned;
-    return points.slice(0, opts.maxCodePoints).join('') + suffix;
+    return points.slice(0, maxCodePoints).join('') + suffix;
 }
 /**
  * Truncate to at most `maxUnits` UTF-16 code units without ending on an

package/node_modules/@maka/runtime/dist/agent-graph-supervisor-wake.js

@@ -83,6 +83,10 @@ export class AgentGraphSupervisorWakeCoordinator {
     #tasks = new Set();
     #tasksBySession = new Map();
     #pendingWakeIds = new Set();
+    #sessionAttention = new Map();
+    #parkedWakeIds = new Map();
+    #activityVersions = new Map();
+    #publishedActivity = new Map();
     #abortController = new AbortController();
     #sessionAbortControllers = new Map();
     #sessionWakeSuppressions = new Map();
@@ -95,18 +99,45 @@ export class AgentGraphSupervisorWakeCoordinator {
             throw new Error('Agent graph supervisor wake attempts must be a positive safe integer');
         }
     }
+    /** Includes queued checkpoint delivery before a supervisor Turn is admitted. */
+    readSessionActivity(rootSessionId) {
+        if (this.#closed || this.#sessionWakesSuppressed(rootSessionId))
+            return 'idle';
+        const attention = this.#sessionAttention.get(rootSessionId);
+        if (attention === 'waiting_for_user')
+            return attention;
+        if (this.#tasksBySession.has(rootSessionId))
+            return 'running';
+        return attention ?? 'idle';
+    }
+    #publishSessionActivity(rootSessionId) {
+        const activity = this.readSessionActivity(rootSessionId);
+        if ((this.#publishedActivity.get(rootSessionId) ?? 'idle') === activity)
+            return;
+        if (activity === 'idle')
+            this.#publishedActivity.delete(rootSessionId);
+        else
+            this.#publishedActivity.set(rootSessionId, activity);
+        try {
+            this.#input.onSessionActivityChanged?.(rootSessionId);
+        }
+        catch {
+            // A catalog observer never controls wake delivery.
+        }
+    }
     notify(rootSessionId, result) {
         if (this.#closed ||
             this.#sessionWakesSuppressed(rootSessionId) ||
             (!this.#input.shouldWake && (!result || !isAgentGraphSupervisorMilestone(result)))) {
             return undefined;
         }
-        return this.#runTracked(rootSessionId, async (abortSignal) => {
+        return this.#runTracked(rootSessionId, async (abortSignal, setAttention) => {
             try {
-                await this.#wake(rootSessionId, abortSignal, result);
+                await this.#wake(rootSessionId, abortSignal, setAttention, result);
             }
             catch (error) {
                 if (!this.#closed && !isAbortError(error)) {
+                    setAttention('blocked');
                     await notifyError(this.#input.onError, rootSessionId, error);
                 }
             }
@@ -122,12 +153,15 @@ export class AgentGraphSupervisorWakeCoordinator {
     notifyPermissionResponse(rootSessionId) {
         if (this.#closed || this.#sessionWakesSuppressed(rootSessionId))
             return undefined;
-        return this.#runTracked(rootSessionId, async (abortSignal) => {
+        this.#sessionAttention.delete(rootSessionId);
+        this.#parkedWakeIds.delete(rootSessionId);
+        return this.#runTracked(rootSessionId, async (abortSignal, setAttention) => {
             try {
-                await this.#settlePermissionResponse(rootSessionId, abortSignal);
+                await this.#settlePermissionResponse(rootSessionId, abortSignal, setAttention);
             }
             catch (error) {
                 if (!this.#closed && !isAbortError(error)) {
+                    setAttention('blocked');
                     await notifyError(this.#input.onError, rootSessionId, error);
                 }
             }
@@ -174,6 +208,11 @@ export class AgentGraphSupervisorWakeCoordinator {
         return this.#input.activityRegistry.whenIdle(rootSessionId) !== undefined;
     }
     async retireSessions(rootSessionIds) {
+        for (const rootSessionId of rootSessionIds) {
+            this.#sessionAttention.delete(rootSessionId);
+            this.#parkedWakeIds.delete(rootSessionId);
+            this.#publishSessionActivity(rootSessionId);
+        }
         return this.#input.wakeStore.supersedeAgentGraphSupervisorWakes({
             rootSessionIds,
             reason: 'session_retired',
@@ -184,19 +223,30 @@ export class AgentGraphSupervisorWakeCoordinator {
             return;
         this.#closed = true;
         this.#abortController.abort();
+        for (const sessionId of [...this.#publishedActivity.keys()])
+            this.#publishSessionActivity(sessionId);
     }
     async close() {
         this.beginDrain();
         await this.waitForIdle();
         this.#sessionAbortControllers.clear();
         this.#tasksBySession.clear();
+        this.#sessionAttention.clear();
+        this.#parkedWakeIds.clear();
+        this.#activityVersions.clear();
     }
-    async #wake(rootSessionId, abortSignal, result) {
+    async #wake(rootSessionId, abortSignal, setAttention, result) {
         abortSignal.throwIfAborted();
         if (!(await this.#isSessionDeliverable(rootSessionId)))
             return;
         const snapshot = await this.#input.readSnapshot(rootSessionId);
         abortSignal.throwIfAborted();
+        const parkedWakeId = this.#parkedWakeIds.get(rootSessionId);
+        if (parkedWakeId &&
+            (snapshot.closed || parkedWakeId !== `${snapshot.graphId}:${snapshot.snapshotVersion}`)) {
+            this.#parkedWakeIds.delete(rootSessionId);
+            setAttention('idle');
+        }
         const wakeDecision = await this.#input.shouldWake?.(rootSessionId, result, snapshot);
         abortSignal.throwIfAborted();
         if (wakeDecision === false ||
@@ -217,12 +267,19 @@ export class AgentGraphSupervisorWakeCoordinator {
                 snapshotVersion: snapshot.snapshotVersion,
                 rootSessionId,
             });
-            if (this.#closed ||
-                claimed.wake.status === 'delivered' ||
-                claimed.wake.status === 'exhausted')
+            if (this.#closed || claimed.wake.status === 'exhausted')
+                return;
+            if (claimed.wake.status === 'delivered') {
+                this.#parkedWakeIds.delete(rootSessionId);
+                setAttention('idle');
                 return;
+            }
+            if (claimed.wake.status === 'waiting_permission') {
+                this.#parkedWakeIds.set(rootSessionId, wakeId);
+                setAttention('waiting_for_user');
+            }
             abortSignal.throwIfAborted();
-            await this.#deliverWake(claimed.wake, snapshot, abortSignal, result);
+            await this.#deliverWake(claimed.wake, snapshot, abortSignal, setAttention, result);
         }
         finally {
             this.#pendingWakeIds.delete(wakeId);
@@ -232,12 +289,13 @@ export class AgentGraphSupervisorWakeCoordinator {
         if (this.#closed || this.#pendingWakeIds.has(wake.wakeId))
             return;
         this.#pendingWakeIds.add(wake.wakeId);
-        void this.#runTracked(wake.rootSessionId, async (abortSignal) => {
+        void this.#runTracked(wake.rootSessionId, async (abortSignal, setAttention) => {
             try {
-                await this.#resumeWake(wake, abortSignal);
+                await this.#resumeWake(wake, abortSignal, setAttention);
             }
             catch (error) {
                 if (!this.#closed && !isAbortError(error)) {
+                    setAttention('blocked');
                     await notifyError(this.#input.onError, wake.rootSessionId, error);
                 }
             }
@@ -247,19 +305,39 @@ export class AgentGraphSupervisorWakeCoordinator {
         });
     }
     #runTracked(rootSessionId, operation) {
+        // Duplicate checkpoint notifications share the in-flight generation. They
+        // cannot invalidate the outcome of the attempt already holding the wake.
+        const version = (this.#activityVersions.get(rootSessionId) ?? 0) +
+            (this.#tasksBySession.has(rootSessionId) ? 0 : 1);
+        this.#activityVersions.set(rootSessionId, version);
+        if (this.#sessionAttention.get(rootSessionId) !== 'waiting_for_user') {
+            this.#sessionAttention.delete(rootSessionId);
+        }
+        const setAttention = (activity) => {
+            if (this.#closed ||
+                this.#sessionWakesSuppressed(rootSessionId) ||
+                this.#activityVersions.get(rootSessionId) !== version)
+                return;
+            if (activity === 'idle')
+                this.#sessionAttention.delete(rootSessionId);
+            else
+                this.#sessionAttention.set(rootSessionId, activity);
+            this.#publishSessionActivity(rootSessionId);
+        };
         const residency = this.#input.acquireResidency?.(rootSessionId);
         const abortSignal = this.#sessionAbortSignal(rootSessionId);
         const task = Promise.resolve()
-            .then(() => operation(abortSignal))
+            .then(() => operation(abortSignal, setAttention))
             .finally(() => residency?.release());
         this.#tasks.add(task);
         const sessionTasks = this.#tasksBySession.get(rootSessionId) ?? new Set();
         sessionTasks.add(task);
         this.#tasksBySession.set(rootSessionId, sessionTasks);
+        this.#publishSessionActivity(rootSessionId);
         void task.then(() => this.#forgetTask(rootSessionId, task), () => this.#forgetTask(rootSessionId, task));
         return task;
     }
-    async #resumeWake(wake, abortSignal) {
+    async #resumeWake(wake, abortSignal, setAttention) {
         abortSignal.throwIfAborted();
         if (!(await this.#isSessionDeliverable(wake.rootSessionId))) {
             await this.#supersedeSession(wake.rootSessionId, 'session_unavailable');
@@ -278,9 +356,9 @@ export class AgentGraphSupervisorWakeCoordinator {
             return;
         }
         abortSignal.throwIfAborted();
-        await this.#deliverWake(wake, snapshot, abortSignal);
+        await this.#deliverWake(wake, snapshot, abortSignal, setAttention);
     }
-    async #deliverWake(wake, snapshot, abortSignal, result) {
+    async #deliverWake(wake, snapshot, abortSignal, setAttention, result) {
         if (wake.status === 'exhausted')
             return;
         if (wake.attemptCount >= this.#maxDeliveryAttempts) {
@@ -323,6 +401,8 @@ export class AgentGraphSupervisorWakeCoordinator {
                     }
                     return;
                 }
+                this.#parkedWakeIds.delete(wake.rootSessionId);
+                setAttention('idle');
                 if (this.#sessionWakesSuppressed(wake.rootSessionId))
                     return;
                 if (this.#closed) {
@@ -351,6 +431,8 @@ export class AgentGraphSupervisorWakeCoordinator {
                             attemptId,
                             status: 'delivered',
                         });
+                        this.#parkedWakeIds.delete(wake.rootSessionId);
+                        setAttention('idle');
                         return;
                     }
                     if (outcome.kind === 'superseded') {
@@ -370,6 +452,8 @@ export class AgentGraphSupervisorWakeCoordinator {
                             attemptId,
                             status: 'waiting_permission',
                         });
+                        this.#parkedWakeIds.set(wake.rootSessionId, wake.wakeId);
+                        setAttention('waiting_for_user');
                         return;
                     }
                     lastFailure = wakeOutcomeFailure(outcome);
@@ -501,6 +585,9 @@ export class AgentGraphSupervisorWakeCoordinator {
             `${snapshot.graphId}:${snapshot.snapshotVersion}` === wake.wakeId);
     }
     #supersedeSession(rootSessionId, reason) {
+        this.#sessionAttention.delete(rootSessionId);
+        this.#parkedWakeIds.delete(rootSessionId);
+        this.#publishSessionActivity(rootSessionId);
         return this.#input.wakeStore.supersedeAgentGraphSupervisorWakes({
             rootSessionIds: [rootSessionId],
             reason,
@@ -527,7 +614,7 @@ export class AgentGraphSupervisorWakeCoordinator {
             : `host_restart:${runStatus}`);
         return 1;
     }
-    async #settlePermissionResponse(rootSessionId, abortSignal) {
+    async #settlePermissionResponse(rootSessionId, abortSignal, setAttention) {
         const activity = await this.#input.activityRegistry.acquire(rootSessionId, abortSignal);
         const retryable = [];
         try {
@@ -548,6 +635,8 @@ export class AgentGraphSupervisorWakeCoordinator {
                         attemptId,
                         status: 'delivered',
                     });
+                    this.#parkedWakeIds.delete(rootSessionId);
+                    setAttention('idle');
                     continue;
                 }
                 retryable.push(await this.#markRetryable(wake.graphId, wake.wakeId, attemptId, `permission_waiter_lost:${runStatus}`));
@@ -562,6 +651,10 @@ export class AgentGraphSupervisorWakeCoordinator {
     #beginSessionWakeSuppression(rootSessionId) {
         const count = this.#sessionWakeSuppressions.get(rootSessionId) ?? 0;
         this.#sessionWakeSuppressions.set(rootSessionId, count + 1);
+        this.#activityVersions.set(rootSessionId, (this.#activityVersions.get(rootSessionId) ?? 0) + 1);
+        this.#sessionAttention.delete(rootSessionId);
+        this.#parkedWakeIds.delete(rootSessionId);
+        this.#publishSessionActivity(rootSessionId);
         if (count === 0) {
             const controller = this.#sessionAbortControllers.get(rootSessionId) ?? new AbortController();
             this.#sessionAbortControllers.set(rootSessionId, controller);
@@ -577,6 +670,7 @@ export class AgentGraphSupervisorWakeCoordinator {
             return;
         }
         this.#sessionWakeSuppressions.delete(rootSessionId);
+        this.#publishSessionActivity(rootSessionId);
         if (!this.#tasksBySession.has(rootSessionId)) {
             this.#sessionAbortControllers.delete(rootSessionId);
         }
@@ -601,11 +695,15 @@ export class AgentGraphSupervisorWakeCoordinator {
         this.#tasks.delete(task);
         const sessionTasks = this.#tasksBySession.get(rootSessionId);
         sessionTasks?.delete(task);
-        if (sessionTasks?.size === 0)
+        if (sessionTasks?.size === 0) {
             this.#tasksBySession.delete(rootSessionId);
+            if (!this.#sessionAttention.has(rootSessionId))
+                this.#activityVersions.delete(rootSessionId);
+        }
         if (!this.#sessionWakesSuppressed(rootSessionId) && !this.#tasksBySession.has(rootSessionId)) {
             this.#sessionAbortControllers.delete(rootSessionId);
         }
+        this.#publishSessionActivity(rootSessionId);
     }
 }
 export function isAgentGraphSupervisorMilestone(result) {

package/node_modules/@maka/runtime/dist/agent-run.js

@@ -328,6 +328,17 @@ export class AgentRun {
         const runStore = this.input.runStore;
         if (!this.input.runtimeEventStore || !runStore)
             return;
+        // A stream may have attempted finalization after an earlier stop failed.
+        // Join that write, but let this explicit retry reuse its reserved fact if
+        // the write failed; a rejected promise is not durable terminal evidence.
+        const previousWrite = this.terminalClaim.write;
+        try {
+            await previousWrite;
+        }
+        catch {
+            if (this.terminalClaim.write === previousWrite)
+                this.terminalClaim.write = undefined;
+        }
         await this.flushRuntimePartialBuffer(true);
         // The claim only fences writers inside this Run. Another owner — a Host
         // recovery, a resumed continuation — may have sealed the ledger already,

package/node_modules/@maka/runtime/dist/ai-sdk-backend.js

@@ -90,6 +90,16 @@ export class AiSdkBackend {
      * read back as absent.
      */
     activeTurns = new Set();
+    /**
+     * Deferred-tool activations for this Session backend. `tool_search` only
+     * adds names; Turn end and compaction do not clear them. Clearing at Turn
+     * end would change the provider tool list and miss the prompt cache on the
+     * next Turn. Compaction already invalidates that cache, so clearing there
+     * would change the prefix a second time. Concurrent Runs on this backend
+     * share the map, so a search in one Run is visible on a sibling Run's next
+     * step. A rebuilt backend starts empty.
+     */
+    sessionActiveTools = new Map();
     compaction;
     turnSessionState = {};
     constructor(input) {
@@ -254,6 +264,7 @@ export class AiSdkBackend {
             providerTelemetry: this.providerTelemetry,
             compaction: this.compaction,
             snapshotToolAvailability: () => this.snapshotToolAvailability(),
+            sessionActiveTools: this.sessionActiveTools,
             codeCellAdmission: this.codeCellAdmission,
             resolvedProviderOptions: this.resolvedProviderOptions,
             session: this.turnSessionState,

package/node_modules/@maka/runtime/dist/ai-sdk-turn.js

@@ -37,7 +37,7 @@ import { contextDiagnosticsCompactionOf, } from './context-diagnostics.js';
 import { hasBlockingReplayDiagnostics } from './ai-sdk-compaction.js';
 import { portableApplyPatchTool } from './apply-patch-profile.js';
 import { RunTrace } from './run-trace.js';
-import { REQUEST_SANDBOX_BOUNDARY_TOOL_NAME, SANDBOX_BOUNDARY_DENIED_FOR_TURN, SANDBOX_BOUNDARY_FINALIZATION_PROMPT, } from './sandbox-boundary-tool.js';
+import { REQUEST_SANDBOX_BOUNDARY_TOOL_NAME, SANDBOX_BOUNDARY_DENIED_FOR_TURN, SANDBOX_BOUNDARY_FINALIZATION_PROMPT, requiredSandboxBoundaryToolNames, } from './sandbox-boundary-tool.js';
 import { buildRuntimeEventModelReplayPlan, appendPriorUnknownToolResponses, buildSteeringEnvelope, collectToolActivityTurnIds, compatibleProviderReasoningReplayEventIds, formatTextWithInlineRefs, inspectPriorUnknownToolOutcomes, steeringMessagesMissingFromBase, steeringModelMessage, } from './model-history.js';
 import { toolSchemaCharsForDiagnostics, requestCompositionToolSchemas, stableHash, toolCatalogHash, } from './request-shape.js';
 import { toolAvailabilityHash } from './tool-availability.js';
@@ -374,13 +374,15 @@ function providerRetryDelayMs(failedAttempt, retryAfterMs) {
  *
  * Each turn owns its ToolRuntime for the same reason: gating, the loop gate,
  * the subagent and child-run limiters, durable attempts, and step admission are
- * all per-turn facts.
+ * all per-turn facts. Deferred-tool activation is the exception: it lives on
+ * the Session backend so later Turns — and concurrent Runs on the same
+ * backend — keep the same provider tool list.
  */
 export class AiSdkTurn {
     deps;
     request;
     abortController = new AbortController();
-    activeTools = new Map();
+    activeTools;
     aborted = false;
     loopStopRequested = false;
     loopStopReason;
@@ -412,6 +414,7 @@ export class AiSdkTurn {
             request.orchestration ??
                 resolveEffectiveOrchestration(deps.backend.header.orchestrationMode, undefined);
         this.toolRuntime = deps.createToolRuntime(this);
+        this.activeTools = deps.sessionActiveTools;
     }
     async *run() {
         yield* this.runWithinScope(this.request);
@@ -805,7 +808,7 @@ export class AiSdkTurn {
         }
         // --- Build the provider-visible schema set. Tool execution stays in Runtime. ---
         // Each logical step freezes its own scoped catalog and search projection.
-        // Mutable activation belongs to this turn and follows contribution identity.
+        // Mutable activation is the Session backend map and follows contribution identity.
         const requiredOrchestrationTools = this.orchestration.mode === 'swarm'
             ? new Set([
                 'agent_list',
@@ -834,7 +837,11 @@ export class AiSdkTurn {
             if (toolMode === 'code_mode' && snapshot.hostTools.some((tool) => tool.name === 'exec')) {
                 throw new Error('Tool name "exec" is reserved for Code Mode.');
             }
-            const basePlan = snapshot.runtime.prepare(this.activeTools, requiredOrchestrationTools);
+            const requiredTools = new Set([
+                ...requiredOrchestrationTools,
+                ...requiredSandboxBoundaryToolNames(snapshot.hostTools),
+            ]);
+            const basePlan = snapshot.runtime.prepare(this.activeTools, requiredTools);
             const nestedTools = nestableToolSnapshot(basePlan.providerTools, basePlan.activeTools);
             const plan = projectToolModePlan(basePlan, toolMode, codeModeExecTool);
             const modelTools = {};
@@ -1231,6 +1238,7 @@ export class AiSdkTurn {
                         result = await this.deps.modelAdapter.startStream({
                             model,
                             messages: dispatchMessages,
+                            historyMessageCount: attemptMessages.length,
                             tools: modelTools,
                             activeTools: activeToolsForRequest,
                             onStreamActivity: () => requestWatchdog?.markActivity(),

package/node_modules/@maka/runtime/dist/bots/proxied-fetch.js

@@ -22,6 +22,11 @@ import { buildProxyDispatcher } from '../network/proxy-dispatcher.js';
 import { resolveActiveProxy } from '../network/active-proxy-state.js';
 import { FETCH_PROXY_SNAPSHOT } from '../network/scoped-fetch-transport.js';
 const DEFAULT_TIMEOUT_MS = 15_000;
+// Bounded wait for dispatcher teardown in the error path: a graceful close
+// that never settles must not delay the rejection the caller is owed. The
+// success path keeps its fire-and-forget close, which owns the streaming
+// body lifecycle and is not bounded here.
+const DISPATCHER_CLOSE_GRACE_MS = 1_000;
 export async function proxiedFetch(input, init = {}) {
     const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
     const proxy = resolveActiveProxy();
@@ -70,8 +75,31 @@ export async function proxiedFetch(input, init = {}) {
     catch (error) {
         if (timer)
             clearTimeout(timer);
+        // Mirror the shared transport teardown ordering: begin dispatcher
+        // teardown before aborting so the graceful close can retire live
+        // CONNECT tunnels, with abort still cancelling pending connects. Keep
+        // the wait bounded so a stalled close cannot hold the rejection.
+        const teardown = disposeDispatcher(timedOut);
         controller.abort(error);
-        await disposeDispatcher(timedOut);
+        let graceTimer;
+        const graceExpired = await Promise.race([
+            teardown.then(() => false),
+            new Promise((resolve) => {
+                graceTimer = setTimeout(() => resolve(true), DISPATCHER_CLOSE_GRACE_MS);
+            }),
+        ]);
+        if (graceTimer)
+            clearTimeout(graceTimer);
+        if (graceExpired) {
+            // The graceful close never settled within the grace, so destroy the
+            // dispatcher instead of leaking it. Fire-and-forget with the error
+            // swallowed: teardown must never replace the rejection the caller is
+            // owed.
+            const disposable = dispatcher;
+            if (typeof disposable.destroy === 'function') {
+                void Promise.resolve(disposable.destroy.call(dispatcher, new Error('Dispatcher close grace expired'))).catch(() => { });
+            }
+        }
         throw error;
     }
     // Headers are in: return the original Fetch Response now. close() is