maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.31.20260913

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

@@ -16,6 +16,8 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { JsonArrayPageBudget } from './json-array-page-budget.js';
+import { resolveConnectionModelCatalog } from '@maka/core/model-catalog';
 import { authenticateRuntimePolicyStoresWriter, RuntimePolicyStoreError, } from '@maka/storage/runtime-policy-stores';
 import { CONNECTION_CATALOG_PAGE_MAX_BYTES, CONNECTION_CATALOG_PAGE_MAX_ITEMS, } from '../protocol/index.js';
 import { buildHostAgentSettingsTools } from './agent-settings-tools.js';
@@ -28,6 +30,7 @@ export class HostRuntimePolicyCoordinator {
     handlers = {
         'runtime.policy.query': () => this.#queryPolicy(),
         'runtime.policy.mutate': (input) => this.#mutatePolicy(input),
+        'runtime.policy.network-proxy.update': (input) => this.#updateNetworkProxy(input),
         'connection.catalog.query': (input) => this.#queryCatalog(input),
         'connection.catalog.create': (input) => this.#createConnection(input),
         'connection.catalog.update': (input) => this.#updateConnection(input),
@@ -64,6 +67,27 @@ export class HostRuntimePolicyCoordinator {
             return projectPolicyMutation(await this.#stores.runtimePolicy.mutate(input));
         });
     }
+    async #updateNetworkProxy(input) {
+        return this.#storeMutation(async () => {
+            try {
+                await this.validateMutation({
+                    expectedRevision: input.expectedPolicyRevision,
+                    operation: { kind: 'set_network_proxy', value: input.networkProxy },
+                });
+            }
+            catch (error) {
+                throw new RuntimePolicyStoreError('invalid_policy_input', 'Network proxy update failed Host validation', { cause: error });
+            }
+            const result = await this.#stores.operations.updateNetworkProxy(input);
+            return result.kind === 'committed'
+                ? {
+                    kind: 'committed',
+                    revision: result.snapshot.revision,
+                    credentialStatus: result.credentialStatus,
+                }
+                : result;
+        });
+    }
     async #queryCatalog(input) {
         const stored = await this.#storeQuery(() => this.#stores.connectionCatalog.getSnapshot());
         if (!stored.ok)
@@ -142,7 +166,9 @@ export class HostRuntimePolicyCoordinator {
     async #setCredential(input) {
         return this.#storeMutation(async () => {
             const result = await this.#stores.credentialVault.set(input);
-            if (result.kind === 'connection_not_found' || result.kind === 'credential_stale') {
+            if (result.kind === 'connection_not_found' ||
+                result.kind === 'connection_stale' ||
+                result.kind === 'credential_stale') {
                 return result;
             }
             const status = result.snapshot.entries.find((entry) => sameLocator(entry.locator, input.locator));
@@ -155,6 +181,9 @@ export class HostRuntimePolicyCoordinator {
     async #deleteCredential(input) {
         return this.#storeMutation(async () => {
             const result = await this.#stores.credentialVault.delete(input);
+            if (result.kind === 'connection_stale') {
+                throw invariantFailure('Credential deletion returned an impossible connection conflict');
+            }
             if (result.kind === 'connection_not_found' || result.kind === 'credential_stale') {
                 return result;
             }
@@ -229,6 +258,7 @@ export class HostRuntimePolicyCoordinator {
                     };
                 case 'invalid_policy_input':
                 case 'invalid_connection_input':
+                case 'revision_conflict':
                     if (mode !== 'mutation') {
                         throw invariantFailure('A read operation admitted invalid runtime policy input');
                     }
@@ -290,51 +320,75 @@ function connectionBasis(connection) {
 function projectCatalogItems(snapshot) {
     const items = [];
     for (const [connectionIndex, connection] of snapshot.connections.entries()) {
-        // Profiles ride on their enabled_model_id item, never in one header
-        // table: a header item is atomic to the paginator, so a long declaration
-        // list would make the whole connection unreadable.
-        const { enabledModelIds, models, relayModelProfiles, ...header } = connection;
+        const { enabledModelIds, models, modelOverrides, 
+        // When the Host last ran discovery, and the marker that invalidates a
+        // test when model facts change: both are the Host's own bookkeeping,
+        // not part of the client-visible catalog protocol.
+        modelsFetchedAt: _modelsFetchedAt, ...header } = connection;
+        // The Host resolves the catalog because it owns the model metadata the
+        // resolution merges in. A client that merged its own bundled copy would
+        // describe a model by the version it happens to ship, so two clients on
+        // one Host could disagree about the same model.
+        const catalogEntries = resolveConnectionModelCatalog({
+            slug: connection.slug,
+            providerType: connection.providerType,
+            defaultModel: snapshot.defaultTarget?.connectionId === connection.connectionId
+                ? snapshot.defaultTarget.modelId
+                : '',
+            enabledModelIds: [...enabledModelIds],
+            models: [...models],
+            ...(connection.modelSource === undefined ? {} : { modelSource: connection.modelSource }),
+            ...(modelOverrides === undefined ? {} : { modelOverrides }),
+        });
         items.push({
             kind: 'connection',
             connectionIndex,
             ...header,
             enabledModelIdCount: enabledModelIds.length,
             modelCount: models.length,
+            catalogEntryCount: catalogEntries.length,
         });
         for (const [itemIndex, modelId] of enabledModelIds.entries()) {
-            const relayProfile = relayModelProfiles?.[modelId];
             items.push({
                 kind: 'enabled_model_id',
                 connectionIndex,
                 itemIndex,
                 modelId,
-                ...(relayProfile === undefined ? {} : { relayProfile }),
             });
         }
         for (const [itemIndex, model] of models.entries()) {
             items.push({ kind: 'model', connectionIndex, itemIndex, model });
         }
+        for (const [itemIndex, entry] of catalogEntries.entries()) {
+            const modelOverride = modelOverrides?.[entry.id];
+            items.push({
+                kind: 'catalog_entry',
+                connectionIndex,
+                itemIndex,
+                entry,
+                ...(modelOverride === undefined ? {} : { modelOverride }),
+            });
+        }
     }
     return items;
 }
 function catalogPage(snapshot, allItems, offset) {
     const items = [];
+    const budget = new JsonArrayPageBudget(CONNECTION_CATALOG_PAGE_MAX_BYTES, {
+        kind: 'page',
+        revision: snapshot.revision,
+        defaultTarget: snapshot.defaultTarget,
+        connectionCount: snapshot.connections.length,
+        items: [],
+        nextCursor: null,
+    });
     const limit = Math.min(allItems.length, offset + CONNECTION_CATALOG_PAGE_MAX_ITEMS);
     for (let index = offset; index < limit; index += 1) {
         const item = allItems[index];
         if (!item)
             throw invariantFailure('Catalog projection index was out of bounds');
-        const candidate = [...items, item];
-        const nextOffset = offset + candidate.length;
-        const result = {
-            kind: 'page',
-            revision: snapshot.revision,
-            defaultTarget: snapshot.defaultTarget,
-            connectionCount: snapshot.connections.length,
-            items: candidate,
-            nextCursor: nextOffset < allItems.length ? cursorForItem(allItems[nextOffset]) : null,
-        };
-        if (Buffer.byteLength(JSON.stringify(result), 'utf8') > CONNECTION_CATALOG_PAGE_MAX_BYTES) {
+        const nextOffset = offset + items.length + 1;
+        if (!budget.tryAppend(item, nextOffset < allItems.length ? cursorForItem(allItems[nextOffset]) : null)) {
             break;
         }
         items.push(item);

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

@@ -23,6 +23,7 @@ import { ShellRunPtyControlClosedError, isShellRunResourceRef, } from '@maka/run
 import { defaultShellPlan, ShellPreferenceError } from '@maka/runtime/shell-detect';
 import { isSessionNotFoundError } from '@maka/storage/execution-stores';
 import { decodeRuntimeResourceControllerAcquireResult, decodeRuntimeResourceControllerControlResult, decodeRuntimeResourceQueryResult, decodeRuntimeResourceStopResult, decodeRuntimeResourceStartResult, RUNTIME_RESOURCE_CONTROLLER_ACQUIRE_RESULT_MAX_BYTES, RUNTIME_RESOURCE_MAX_CONTROL_SEQUENCE, } from '../protocol/index.js';
+import { boundedFailureDiagnostic } from './failure-diagnostic.js';
 import { boundedRuntimeResourceSnapshot, canonicalRuntimeResources, createRuntimeResourcePage, runtimeResourceRevision, runtimeResourceSnapshotFromResult, } from './runtime-resource-projection.js';
 const MAX_CONTROL_REPLAYS = 128;
 /** Owns Host Shell/PTY tools plus the connection-scoped Client controller fence. */
@@ -186,8 +187,7 @@ export class HostRuntimeResourceCoordinator {
                 if (isSessionNotFoundError(error)) {
                     return queryFailure('not_found', 'Session was not found');
                 }
-                this.#requestDrain();
-                return queryFailure('internal_failure', 'Session state is unavailable');
+                return this.#canonicalReadFailure(error, 'Session state is unavailable');
             }
             if (input.kind === 'get') {
                 try {
@@ -206,9 +206,8 @@ export class HostRuntimeResourceCoordinator {
                         }),
                     };
                 }
-                catch {
-                    this.#requestDrain();
-                    return queryFailure('internal_failure', 'Runtime Resource state is unavailable');
+                catch (error) {
+                    return this.#canonicalReadFailure(error, 'Runtime Resource state is unavailable');
                 }
             }
             let updates;
@@ -218,9 +217,8 @@ export class HostRuntimeResourceCoordinator {
                     updates = updates.filter((update) => update.sessionId === input.sessionId);
                 }
             }
-            catch {
-                this.#requestDrain();
-                return queryFailure('internal_failure', 'Runtime Resource state is unavailable');
+            catch (error) {
+                return this.#canonicalReadFailure(error, 'Runtime Resource state is unavailable');
             }
             try {
                 const resources = canonicalRuntimeResources(updates);
@@ -251,6 +249,11 @@ export class HostRuntimeResourceCoordinator {
             ? queryFailure('not_found', 'Session was not found')
             : outcome;
     }
+    #canonicalReadFailure(error, message) {
+        console.error(`[runtime-host] canonical Runtime Resource read failed: ${boundedFailureDiagnostic(error)}`);
+        this.#requestDrain();
+        return queryFailure('internal_failure', message);
+    }
     #guestObservationGrantId(context, sessionId) {
         if (context.principalKind !== 'session_guest')
             return;

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

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { JsonArrayPageBudget } from './json-array-page-budget.js';
 import { createHash } from 'node:crypto';
 import { decodeRuntimeResourceQueryResult, RUNTIME_RESOURCE_PAGE_MAX_ITEMS, RUNTIME_RESOURCE_RESULT_MAX_BYTES, } from '../protocol/index.js';
 const RUNTIME_RESOURCE_SNAPSHOT_MAX_BYTES = 48 * 1024;
@@ -27,32 +28,30 @@ export function canonicalRuntimeResources(resources) {
         left.sourceToolCallId.localeCompare(right.sourceToolCallId));
 }
 function boundedRuntimeResourceUpdate(update) {
-    return {
-        ...structuredClone(update),
-        result: boundedState(update.result),
-    };
+    const bounded = structuredClone(update);
+    shrinkStateToFit(bounded.result);
+    return bounded;
 }
 export function runtimeResourceRevision(resources) {
     return `sha256:${createHash('sha256').update(JSON.stringify(resources)).digest('hex')}`;
 }
 export function createRuntimeResourcePage(sessionId, revision, resources, offset) {
     const pageResources = [];
+    const budget = new JsonArrayPageBudget(RUNTIME_RESOURCE_RESULT_MAX_BYTES, {
+        kind: 'page',
+        sessionId,
+        revision,
+        resources: [],
+        nextCursor: null,
+    });
     for (let index = offset; index < resources.length; index += 1) {
         if (pageResources.length >= RUNTIME_RESOURCE_PAGE_MAX_ITEMS)
             break;
         const resource = resources[index];
         if (!resource)
             throw new Error('Runtime Resource projection index was out of bounds');
-        const candidateResources = [...pageResources, resource];
         const nextOffset = index + 1;
-        const candidate = {
-            kind: 'page',
-            sessionId,
-            revision,
-            resources: candidateResources,
-            nextCursor: nextOffset < resources.length ? String(nextOffset) : null,
-        };
-        if (Buffer.byteLength(JSON.stringify(candidate), 'utf8') > RUNTIME_RESOURCE_RESULT_MAX_BYTES) {
+        if (!budget.tryAppend(resource, nextOffset < resources.length ? String(nextOffset) : null)) {
             break;
         }
         pageResources.push(resource);
@@ -83,11 +82,6 @@ export function runtimeResourceSnapshotFromResult(result) {
     const { operation: _operation, ...snapshot } = result;
     return snapshot;
 }
-function boundedState(state) {
-    const bounded = structuredClone(state);
-    shrinkStateToFit(bounded);
-    return bounded;
-}
 function shrinkStateToFit(state) {
     while (Buffer.byteLength(JSON.stringify(state), 'utf8') > RUNTIME_RESOURCE_SNAPSHOT_MAX_BYTES) {
         const fields = mutableTextFields(state).sort((left, right) => Buffer.byteLength(right.value(), 'utf8') - Buffer.byteLength(left.value(), 'utf8'));

package/node_modules/@maka/runtime-host/dist/server/scheduled-task-coordinator.js

@@ -16,20 +16,35 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { JsonArrayPageBudget } from './json-array-page-budget.js';
 import { randomUUID } from 'node:crypto';
 import { botDisplayLabel } from '@maka/core/bot-events';
 import { isBotDeliveryProvider } from '@maka/core/bot-chat-settings';
 import { messageContentsEqual } from '@maka/core/events';
+import { authorizeConnectionModel } from '@maka/core/llm-connections';
 import { buildAgentScheduledTaskCreatePayload, buildScheduledTaskTool, SCHEDULED_TASK_NATIVE_EFFECT_SERVICE_ID, SCHEDULED_TASK_NATIVE_EFFECT_SERVICE_VERSION, } from '@maka/runtime/scheduled-task-tools';
+import { stableHash } from '@maka/runtime/request-shape';
 import { authenticateInteractiveScheduledTaskStoreWriter, ScheduledTaskStoreError, } from '@maka/storage/scheduled-task-store';
 import { isSessionNotFoundError, } from '@maka/storage/execution-stores';
 import { SCHEDULED_TASK_CATALOG_MAX_ITEMS, SCHEDULED_TASK_PAGE_MAX_ITEMS, SCHEDULED_TASK_RESULT_MAX_BYTES, } from '../protocol/index.js';
+import { DEFAULT_TOOL_MODE } from '@maka/core/tool-mode';
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 const NATIVE_PROVIDER_RETRY_MS = 5_000;
 const SCHEDULED_AGENT_RUN_IDENTITY_REQUIRED = 'ScheduledTask Agent runs require an immutable model connection identity';
 export class HostScheduledTaskSessionBusyError extends Error {
     name = 'HostScheduledTaskSessionBusyError';
 }
+/** Stable Agent ScheduledTask target identity used by root-admission retries. */
+export function scheduledTaskExecutionFingerprint(execution) {
+    if (!execution.llmConnectionId)
+        return undefined;
+    return stableHash([
+        'scheduled-task-agent-run.v1',
+        execution.llmConnectionId,
+        execution.llmConnectionSlug,
+        execution.model,
+    ]);
+}
 /** Host-owned ScheduledTask catalog, scheduler, fire admission, and tool authority. */
 export class HostScheduledTaskCoordinator {
     handlers = {
@@ -58,6 +73,7 @@ export class HostScheduledTaskCoordinator {
     #prepared = false;
     #started = false;
     #draining = false;
+    #handoffHeld = false;
     #closed = false;
     #retiringSessions = new Set();
     constructor(input) {
@@ -96,6 +112,9 @@ export class HostScheduledTaskCoordinator {
             candidate.execution?.sessionId === admission.sessionId &&
             candidate.execution.turnId === admission.turnId);
         const execution = claim?.execution;
+        const fingerprintMatches = claim?.task.effect.kind !== 'agent_run' ||
+            admission.execution.executionFingerprint ===
+                scheduledTaskExecutionFingerprint(claim.task.effect.execution);
         if (!claim && state === 'run_recorded')
             return;
         if (!claim ||
@@ -104,6 +123,7 @@ export class HostScheduledTaskCoordinator {
             execution.turnId !== admission.turnId ||
             execution.runId !== admission.runId ||
             execution.userMessageId !== admission.userMessageId ||
+            !fingerprintMatches ||
             admission.normalizedInput === null ||
             !messageContentsEqual({ text: claim.task.intent.body }, admission.normalizedInput)) {
             throw new Error(`ScheduledTask admission ${admission.turnId} has no matching pending fire`);
@@ -139,6 +159,34 @@ export class HostScheduledTaskCoordinator {
         this.#started = true;
         void this.#refresh().catch((error) => this.#fatal(error));
     }
+    holdForHandoff() {
+        if (this.#draining || this.#handoffHeld)
+            return undefined;
+        this.#handoffHeld = true;
+        this.#stopTimer();
+        let released = false;
+        return {
+            settled: async () => {
+                // An admitted native effect or Agent fire finishes normally. No new
+                // fire may start while the handoff waits for this lane.
+                for (;;) {
+                    const lane = this.#lane;
+                    await lane;
+                    if (lane === this.#lane)
+                        return;
+                }
+            },
+            residencies: () => (this.#residency ? [this.#residency] : []),
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.#handoffHeld = false;
+                if (!this.#draining)
+                    void this.#refresh().catch((error) => this.#fatal(error));
+            },
+        };
+    }
     beginDrain() {
         if (this.#draining)
             return;
@@ -372,24 +420,38 @@ export class HostScheduledTaskCoordinator {
         }
     }
     async #refresh() {
-        await this.#exclusive(async () => {
-            for (const claim of await this.#store.listPendingFires()) {
-                if (claim.nativeState === 'waiting_for_provider') {
-                    await this.#fulfill(claim, true);
+        if (this.#handoffHeld || this.#draining)
+            return;
+        // Cover claim admission, native delivery, and persistence, while an idle
+        // schedule or a read-only catalog query does not claim active work.
+        const residency = this.#acquireResidency();
+        try {
+            await this.#exclusive(async () => {
+                if (this.#handoffHeld || this.#draining)
+                    return;
+                for (const claim of await this.#store.listPendingFires()) {
+                    if (this.#handoffHeld || this.#draining)
+                        break;
+                    if (claim.nativeState === 'waiting_for_provider') {
+                        await this.#fulfill(claim, true);
+                    }
                 }
-            }
-            while (!this.#draining) {
-                const scan = await this.#store.claimNextDue(this.#now());
-                for (const expired of scan.expired)
-                    this.#publish('updated', expired.id);
-                const claim = scan.claim;
-                if (!claim)
-                    break;
-                await this.#refreshResidency();
-                await this.#fulfill(claim, false);
-            }
-            await this.#refreshSchedule();
-        });
+                while (!this.#draining && !this.#handoffHeld) {
+                    const scan = await this.#store.claimNextDue(this.#now());
+                    for (const expired of scan.expired)
+                        this.#publish('updated', expired.id);
+                    const claim = scan.claim;
+                    if (!claim)
+                        break;
+                    await this.#refreshResidency();
+                    await this.#fulfill(claim, false);
+                }
+                await this.#refreshSchedule();
+            });
+        }
+        finally {
+            residency.release();
+        }
     }
     async #fulfill(claim, recovering) {
         const incognito = (await this.#runtimePolicy.runtimePolicy.getSnapshot()).policy.privacy
@@ -435,10 +497,10 @@ export class HostScheduledTaskCoordinator {
                 ? '本地提醒已触发。'
                 : `已投递到 ${botDisplayLabel(task.effect.platform)}。`, 'fired');
         }
-        // Persisted agent-run templates currently identify their model connection
-        // by reusable slug only. Do not resolve that slug to a potentially
-        // different Connection entity. #3927 will make the exact ID durable.
-        if (task.effect.kind === 'agent_run') {
+        // Legacy persisted Agent-run templates may still identify their model
+        // connection by reusable slug only. Never resolve that slug to a
+        // potentially different Connection entity.
+        if (task.effect.kind === 'agent_run' && !task.effect.execution.llmConnectionId) {
             return this.#settleFailure(claim, SCHEDULED_AGENT_RUN_IDENTITY_REQUIRED);
         }
         let execution = claim.execution;
@@ -472,20 +534,21 @@ export class HostScheduledTaskCoordinator {
             await this.#readResumableSession(identity.sessionId);
             return;
         }
+        const execution = task.effect.execution;
+        const connection = await this.#resolveAgentRunConnection(execution);
         try {
-            await this.#sessions.readHeaderSnapshot(identity.sessionId);
+            const existing = await this.#sessions.readHeaderSnapshot(identity.sessionId);
+            if (existing.llmConnectionId !== execution.llmConnectionId ||
+                existing.llmConnectionSlug !== execution.llmConnectionSlug ||
+                existing.model !== execution.model) {
+                throw new Error('ScheduledTask Session model identity changed');
+            }
             return;
         }
         catch (error) {
             if (!isSessionNotFoundError(error) && !isMissingRecord(error))
                 throw error;
         }
-        const execution = task.effect.execution;
-        const catalog = await this.#runtimePolicy.connectionCatalog.getSnapshot();
-        const connection = catalog.connections.find((candidate) => candidate.slug === execution.llmConnectionSlug);
-        if (!connection) {
-            throw new Error('ScheduledTask model connection does not exist');
-        }
         await this.#createSession({
             sessionId: identity.sessionId,
             workspace: execution.projectId != null && execution.projectId !== ''
@@ -499,17 +562,57 @@ export class HostScheduledTaskCoordinator {
                 connectionSlug: execution.llmConnectionSlug,
                 model: execution.model,
             },
-            ...(execution.thinkingLevel === undefined ? {} : { thinkingLevel: execution.thinkingLevel }),
+            ...(execution.thinkingLevel === undefined
+                ? {}
+                : { thinkingLevel: execution.thinkingLevel }),
             permissionMode: execution.permissionMode,
             collaborationMode: execution.collaborationMode,
             orchestrationMode: execution.orchestrationMode,
+        }, execution.toolMode ?? DEFAULT_TOOL_MODE);
+    }
+    async #resolveAgentRunConnection(execution) {
+        if (!execution.llmConnectionId) {
+            throw new Error(SCHEDULED_AGENT_RUN_IDENTITY_REQUIRED);
+        }
+        const resolved = await this.#runtimePolicy.operations.resolveExecutionConnection({
+            kind: 'bound',
+            connectionId: execution.llmConnectionId,
+            connectionSlug: execution.llmConnectionSlug,
         });
+        if (resolved.kind !== 'ready') {
+            throw new Error(resolved.kind === 'identity_mismatch' || resolved.kind === 'not_found'
+                ? 'ScheduledTask model connection identity changed'
+                : resolved.kind === 'disabled'
+                    ? 'ScheduledTask model connection is disabled'
+                    : resolved.kind === 'credential_not_configured'
+                        ? 'ScheduledTask model connection is not ready'
+                        : resolved.kind === 'provider_retired'
+                            ? 'ScheduledTask model connection uses a retired provider'
+                            : 'ScheduledTask model connection is unavailable');
+        }
+        if (!authorizeConnectionModel(resolved.connection, execution.model)) {
+            throw new Error('ScheduledTask model is no longer enabled');
+        }
+        return resolved.connection;
     }
     async #admitAgentRun(task, identity) {
+        if (task.effect.kind === 'agent_run') {
+            // Re-read the bound Connection immediately before admission. The
+            // Session/Connection stores have independent write lanes, so this
+            // second check closes the delete-and-recreate-same-slug window between
+            // Session creation and AgentRun admission.
+            await this.#resolveAgentRunConnection(task.effect.execution);
+        }
         const content = { text: task.intent.body };
         await this.#root.admit({
             ...identity,
-            execution: { kind: 'scheduled_task', scheduledTaskId: task.id },
+            execution: {
+                kind: 'scheduled_task',
+                scheduledTaskId: task.id,
+                ...(task.effect.kind === 'agent_run'
+                    ? { executionFingerprint: scheduledTaskExecutionFingerprint(task.effect.execution) }
+                    : {}),
+            },
             content,
             start: ({ runId, userMessageId, onRunStarted }) => {
                 if (runId !== identity.runId || userMessageId !== identity.userMessageId) {
@@ -560,7 +663,7 @@ export class HostScheduledTaskCoordinator {
     async #refreshSchedule() {
         this.#stopTimer();
         await this.#refreshResidency();
-        if (!this.#started || this.#draining)
+        if (!this.#started || this.#draining || this.#handoffHeld)
             return;
         const [tasks, claims] = await Promise.all([this.#store.list(), this.#store.listPendingFires()]);
         const next = tasks
@@ -570,6 +673,8 @@ export class HostScheduledTaskCoordinator {
             return earliest === null || deadline < earliest ? deadline : earliest;
         }, null);
         const waitingForProvider = claims.some((claim) => claim.nativeState === 'waiting_for_provider');
+        if (this.#draining || this.#handoffHeld)
+            return;
         if (next === null && !waitingForProvider)
             return;
         const nextTaskDelay = next === null
@@ -589,7 +694,7 @@ export class HostScheduledTaskCoordinator {
             (claims.length > 0 ||
                 tasks.some((task) => task.status === 'active' && task.nextFireAt !== null));
         if (shouldHold && !this.#residency)
-            this.#residency = this.#acquireResidency();
+            this.#residency = this.#acquireResidency('idle');
         if (!shouldHold)
             this.#releaseResidency();
     }
@@ -630,34 +735,38 @@ class ScheduledTaskMutationError extends Error {
     }
 }
 function executionTemplateFromHeader(header) {
+    if (!header.llmConnectionId) {
+        throw new Error(SCHEDULED_AGENT_RUN_IDENTITY_REQUIRED);
+    }
     return {
         cwd: header.cwd,
         ...(header.projectId === undefined ? {} : { projectId: header.projectId }),
+        llmConnectionId: header.llmConnectionId,
         llmConnectionSlug: header.llmConnectionSlug,
         model: header.model,
         ...(header.thinkingLevel === undefined ? {} : { thinkingLevel: header.thinkingLevel }),
         permissionMode: header.permissionMode,
         collaborationMode: header.collaborationMode ?? 'agent',
         orchestrationMode: header.orchestrationMode ?? 'default',
+        toolMode: header.toolMode ?? DEFAULT_TOOL_MODE,
     };
 }
 function createScheduledTaskPage(tasks, revision, offset) {
     const page = [];
+    const budget = new JsonArrayPageBudget(SCHEDULED_TASK_RESULT_MAX_BYTES, {
+        kind: 'page',
+        revision,
+        tasks: [],
+        nextCursor: null,
+    });
     for (let index = offset; index < tasks.length; index += 1) {
         if (page.length >= SCHEDULED_TASK_PAGE_MAX_ITEMS)
             break;
         const task = tasks[index];
         if (!task)
             throw new Error('ScheduledTask page index is invalid');
-        const candidate = [...page, task];
-        const nextOffset = offset + candidate.length;
-        const result = {
-            kind: 'page',
-            revision,
-            tasks: candidate,
-            nextCursor: nextOffset < tasks.length ? String(nextOffset) : null,
-        };
-        if (Buffer.byteLength(JSON.stringify(result), 'utf8') > SCHEDULED_TASK_RESULT_MAX_BYTES) {
+        const nextOffset = offset + page.length + 1;
+        if (!budget.tryAppend(task, nextOffset < tasks.length ? String(nextOffset) : null)) {
             break;
         }
         page.push(task);