newmark-agent 0.4.7 → 0.4.8

package/dist/core/agentKernelRunner.js

@@ -1387,10 +1387,13 @@ function toKernelTools(agent, definitions, provisioning) {
                     throw new Error(rawText);
                 }
                 const visionImage = visualFallbackImageInput(agent, name, rawText);
+                const capturedInput = name === 'screen_capture' ? agent.registerCapturedImageInput(visionImage.image || '', 'active-screenshot.jpg') : null;
                 const directImage = imageInspectDataUrl(name, rawText);
-                const text = spillOversizedToolResult(agent, name, sanitizeVisualToolText(name, rawText));
+                const text = spillOversizedToolResult(agent, name, capturedImageToolText(name, sanitizeVisualToolText(name, rawText), capturedInput?.id));
                 const content = [{ type: 'text', text }];
-                if (visionImage.imagePath)
+                if (name === 'screen_capture' && capturedInput?.dataUrl)
+                    content.push({ type: 'image', image: capturedInput.dataUrl, mimeType: capturedInput.mimeType });
+                else if (visionImage.imagePath)
                     content.push({ type: 'image', imagePath: visionImage.imagePath, mimeType: imageMimeForPath(visionImage.imagePath) });
                 else if (visionImage.image)
                     content.push({ type: 'image', image: visionImage.image, mimeType: visionImage.mimeType });
@@ -1407,7 +1410,7 @@ function toKernelTools(agent, definitions, provisioning) {
                     }
                     catch { }
                 }
-                return { content, details: { tool: name, ok: true, terminate, ...(launchReceipt ? { launchReceipt } : {}), visionImagePath: visionImage.imagePath || undefined, ephemeralVisionImage: !!visionImage.image, displayImage }, terminate };
+                return { content, details: { tool: name, ok: true, terminate, ...(launchReceipt ? { launchReceipt } : {}), visionImagePath: visionImage.imagePath || undefined, ephemeralVisionImage: !!visionImage.image, capturedAttachmentId: capturedInput?.id, displayImage }, terminate };
             },
         };
     }).filter((tool) => !!tool.name);
@@ -1440,7 +1443,7 @@ function boundInlineToolResult(name, text) {
     if (value.length <= INLINE_TOOL_RESULT_MAX_CHARS)
         return value;
     // 结构化结果（JSON/视觉/浏览器/子代理/计划等）不可安全截断，保持原样。
-    if (['computer_use', 'browser_use', 'pdf_read', 'image_inspect', 'image_display', 'task', 'subagent_create', 'SubAgent', 'subagent_send', 'subagent_result', 'subagent_read', 'linked_plan', 'question'].includes(name)) {
+    if (['screen_capture', 'computer_use', 'browser_use', 'pdf_read', 'image_inspect', 'image_display', 'task', 'subagent_create', 'SubAgent', 'subagent_send', 'subagent_result', 'subagent_read', 'linked_plan', 'question'].includes(name)) {
         return value;
     }
     const headChars = Math.floor(INLINE_TOOL_RESULT_MAX_CHARS * 0.6);
@@ -1460,7 +1463,7 @@ function spillOversizedToolResult(agent, name, text) {
     if (value.length <= INLINE_TOOL_RESULT_MAX_CHARS)
         return value;
     // 结构化结果不可安全落盘引用（破坏 JSON 结构），保持原样。
-    if (['computer_use', 'browser_use', 'pdf_read', 'image_inspect', 'image_display', 'task', 'subagent_create', 'SubAgent', 'subagent_send', 'subagent_result', 'subagent_read', 'linked_plan', 'question'].includes(name)) {
+    if (['screen_capture', 'computer_use', 'browser_use', 'pdf_read', 'image_inspect', 'image_display', 'task', 'subagent_create', 'SubAgent', 'subagent_send', 'subagent_result', 'subagent_read', 'linked_plan', 'question'].includes(name)) {
         return value;
     }
     const artifactId = agent.storeToolResultArtifact(name, value);
@@ -1475,11 +1478,11 @@ function spillOversizedToolResult(agent, name, text) {
     ].join('\n');
 }
 function sanitizeVisualToolText(name, text) {
-    if (name !== 'computer_use' && name !== 'browser_use' && name !== 'pdf_read' && name !== 'image_inspect')
+    if (name !== 'screen_capture' && name !== 'computer_use' && name !== 'browser_use' && name !== 'pdf_read' && name !== 'image_inspect')
         return text;
     try {
         const parsed = JSON.parse(text);
-        if (name === 'computer_use' || name === 'browser_use' || name === 'pdf_read') {
+        if (name === 'screen_capture' || name === 'computer_use' || name === 'browser_use' || name === 'pdf_read') {
             delete parsed.vision_image_path;
             delete parsed.vision_image_data_url;
             if (name === 'pdf_read' && parsed.result && typeof parsed.result === 'object') {
@@ -1497,7 +1500,7 @@ function sanitizeVisualToolText(name, text) {
     }
 }
 function discardComputerUseVisionImage(name, text) {
-    if (name !== 'computer_use')
+    if (name !== 'screen_capture' && name !== 'computer_use')
         return;
     try {
         const parsed = JSON.parse(text);
@@ -1519,8 +1522,22 @@ function imageInspectDataUrl(name, text) {
         return '';
     }
 }
+function capturedImageToolText(name, text, attachmentId) {
+    if (name !== 'screen_capture' || !attachmentId)
+        return text;
+    try {
+        const parsed = JSON.parse(text);
+        parsed.attachment_id = attachmentId;
+        parsed.image_input_channel = 'user-image';
+        parsed.inspect_next = { tool: 'image_inspect', actions: ['source_info', 'crop'], max_scale: 4 };
+        return JSON.stringify(parsed, null, 2);
+    }
+    catch {
+        return text;
+    }
+}
 function visualFallbackImageInput(agent, name, text) {
-    if (name !== 'computer_use' && name !== 'browser_use' && name !== 'pdf_read')
+    if (name !== 'screen_capture' && name !== 'computer_use' && name !== 'browser_use' && name !== 'pdf_read')
         return {};
     const model = agent.activeModelConfig();
     if (!model?.vision)
@@ -1685,7 +1702,7 @@ async function executeNewmarkTool(agent, name, args, inputSchema, signal) {
             actorId: agent.runtimeActorId,
             workspaceId: (0, terminalTakeover_1.terminalTakeoverWorkspaceId)(wsDir),
             backend: process.env.NEWMARK_WSL_DISTRO ? 'wsl' : (process.platform === 'win32' ? 'windows' : process.platform),
-            allowEphemeralVisionImage: (name === 'computer_use' || name === 'browser_use' || name === 'pdf_read' || name === 'ocr_read')
+            allowEphemeralVisionImage: (name === 'screen_capture' || name === 'computer_use' || name === 'browser_use' || name === 'pdf_read' || name === 'ocr_read')
                 && !!agent.activeModelConfig()?.vision,
             signal,
         });

package/dist/core/conversationKernel.d.ts

@@ -3,6 +3,16 @@ import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, ConversationImage
 import { AutomationManager } from './automation';
 import { ConversationRuntimeTarget, NormalizedConversationTarget } from './conversationTarget';
 export type ConversationQueueMode = 'steer' | 'followUp';
+export interface ConversationQueueItemSnapshot {
+    id: string;
+    text: string;
+    queueMode: ConversationQueueMode;
+    requestedMode?: string;
+    goalObjective?: string;
+    runId?: string;
+    createdAt: string;
+}
+export type ConversationQueueAction = 'enqueue' | 'update' | 'delete' | 'toggle_pause' | 'guide';
 export interface AgentPromptMessage {
     text: string;
     /** Public transcript text when the execution prompt contains hidden orchestration instructions. */
@@ -176,6 +186,33 @@ export declare class ConversationKernel {
         steering: string[];
         followUp: string[];
     };
+    queueItems(target: ConversationTargetInput): ConversationQueueItemSnapshot[];
+    enqueueNext(target: ConversationTargetInput, input: {
+        id: string;
+        text: string;
+        requestedMode?: string;
+        goalObjective?: string;
+        createdAt?: string;
+    }): ConversationQueueItemSnapshot;
+    updateQueueItem(target: ConversationTargetInput, idInput: string, textInput: string): ConversationQueueItemSnapshot;
+    deleteQueueItem(target: ConversationTargetInput, idInput: string): boolean;
+    setQueuePaused(target: ConversationTargetInput, paused: boolean): boolean;
+    queueAction(target: ConversationTargetInput, action: ConversationQueueAction, input?: {
+        id?: string;
+        text?: string;
+        requestedMode?: string;
+        goalObjective?: string;
+        createdAt?: string;
+    }): {
+        ok: boolean;
+        queueItems: ConversationQueueItemSnapshot[];
+        queuePaused: boolean;
+        queued: {
+            steering: string[];
+            followUp: string[];
+        };
+        receipt?: GuideReceipt;
+    };
     events(target: ConversationTargetInput): AgentWorkEvent[];
     waitForIdle(target: ConversationTargetInput): Promise<void>;
     pendingOptions(target: ConversationTargetInput): OptionQuestion[] | undefined;
@@ -185,6 +222,8 @@ export declare class ConversationKernel {
             steering: string[];
             followUp: string[];
         };
+        queueItems: ConversationQueueItemSnapshot[];
+        queuePaused: boolean;
         workEvents: AgentWorkEvent[];
         runtime: ConversationRuntimeState | null;
         mode: Agent['mode'];
@@ -258,6 +297,7 @@ export declare class ConversationKernel {
     private enqueueSameSession;
     private trackQueuedMessage;
     private consumeQueuedMessage;
+    private replaceTrackedQueuedMessage;
     private emitQueueUpdate;
     private clearQueued;
     private queueState;

package/dist/core/conversationKernel.js

@@ -60,6 +60,173 @@ class ConversationKernel {
             followUp: queued?.followUp.slice() || [],
         };
     }
+    queueItems(target) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            return [];
+        return runtime.pendingNextTurn.flatMap(item => {
+            if (item.queueMode !== 'followUp')
+                return [];
+            if (typeof item.message === 'string')
+                return [];
+            const id = String(item.message.clientMessageId || '');
+            if (!id)
+                return [];
+            return [{
+                    id,
+                    text: String(item.message.visibleUserInput || item.message.text || '').replace(/^\[Next queued while current turn is running\]\n/, ''),
+                    queueMode: item.queueMode,
+                    requestedMode: item.message.visibleMode,
+                    goalObjective: item.message.goalObjective,
+                    runId: item.message.runId,
+                    createdAt: String(item.message.createdAt || ''),
+                }];
+        });
+    }
+    enqueueNext(target, input) {
+        const runtime = this.findRuntime(target);
+        if (!runtime?.activePromise || !runtime.runId)
+            throw new Error('Target conversation is not running');
+        const id = String(input.id || '').trim().slice(0, 200);
+        const text = String(input.text || '').trim();
+        if (!id || !text)
+            throw new Error('Queue item id and text are required');
+        const existing = this.queueItems(runtime.target).find(item => item.id === id);
+        if (existing)
+            return existing;
+        const prompt = `[Next queued while current turn is running]\n${text}`;
+        const createdAt = String(input.createdAt || new Date().toISOString());
+        runtime.pendingNextTurn.push({
+            message: {
+                text: prompt,
+                visibleUserInput: text,
+                visibleMode: String(input.requestedMode || 'build'),
+                goalObjective: String(input.goalObjective || '') || undefined,
+                clientMessageId: id,
+                runId: runtime.runId,
+                createdAt,
+            },
+            queueMode: 'followUp',
+        });
+        runtime.runner.retainConversationContinuations([{
+                content: prompt,
+                queueMode: 'followUp',
+                clientMessageId: id,
+                runId: runtime.runId,
+                createdAt,
+            }]);
+        this.trackQueuedMessage(runtime, prompt, 'followUp');
+        this.emitQueueUpdate(runtime);
+        return this.queueItems(runtime.target).find(item => item.id === id);
+    }
+    updateQueueItem(target, idInput, textInput) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            throw new Error('Target conversation runtime is unavailable');
+        const id = String(idInput || '').trim();
+        const text = String(textInput || '').trim();
+        if (!id || !text)
+            throw new Error('Queue item id and text are required');
+        const pending = runtime.pendingNextTurn.find(item => typeof item.message !== 'string' && item.message.clientMessageId === id);
+        if (!pending || typeof pending.message === 'string')
+            throw new Error('Queue item is no longer editable');
+        const oldPrompt = pending.message.text;
+        pending.message.text = `[Next queued while current turn is running]\n${text}`;
+        pending.message.visibleUserInput = text;
+        runtime.runner.consumeConversationContinuation({ content: oldPrompt, queueMode: pending.queueMode, clientMessageId: id });
+        runtime.runner.retainConversationContinuations([{
+                content: pending.message.text,
+                queueMode: pending.queueMode,
+                clientMessageId: id,
+                runId: pending.message.runId,
+            }]);
+        this.replaceTrackedQueuedMessage(runtime, oldPrompt, pending.message.text, pending.queueMode);
+        this.emitQueueUpdate(runtime);
+        return this.queueItems(runtime.target).find(item => item.id === id);
+    }
+    deleteQueueItem(target, idInput) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            return false;
+        const id = String(idInput || '').trim();
+        const index = runtime.pendingNextTurn.findIndex(item => typeof item.message !== 'string' && item.message.clientMessageId === id);
+        if (index < 0)
+            return false;
+        const [removed] = runtime.pendingNextTurn.splice(index, 1);
+        if (typeof removed.message !== 'string') {
+            runtime.runner.consumeConversationContinuation({ content: removed.message.text, queueMode: removed.queueMode, clientMessageId: id });
+            this.consumeQueuedMessage(runtime, removed.message.text);
+        }
+        this.emitQueueUpdate(runtime);
+        return true;
+    }
+    setQueuePaused(target, paused) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            throw new Error('Target conversation runtime is unavailable');
+        runtime.queuePaused = paused;
+        this.emitQueueUpdate(runtime);
+        if (!paused && !runtime.activePromise && runtime.pendingNextTurn.length) {
+            this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
+        }
+        return runtime.queuePaused;
+    }
+    queueAction(target, action, input = {}) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            throw new Error('Target conversation runtime is unavailable');
+        let receipt;
+        if (action === 'enqueue') {
+            this.enqueueNext(runtime.target, {
+                id: String(input.id || ''),
+                text: String(input.text || ''),
+                requestedMode: input.requestedMode,
+                goalObjective: input.goalObjective,
+                createdAt: input.createdAt,
+            });
+        }
+        else if (action === 'update') {
+            this.updateQueueItem(runtime.target, String(input.id || ''), String(input.text || ''));
+        }
+        else if (action === 'delete') {
+            if (!this.deleteQueueItem(runtime.target, String(input.id || '')))
+                throw new Error('Queue item was not found');
+        }
+        else if (action === 'toggle_pause') {
+            this.setQueuePaused(runtime.target, !runtime.queuePaused);
+        }
+        else if (action === 'guide') {
+            const item = this.queueItems(runtime.target).find(entry => entry.id === String(input.id || ''));
+            if (!item)
+                throw new Error('Queue item was not found');
+            receipt = this.enqueueGuide({
+                clientMessageId: item.id,
+                guideId: (0, crypto_1.randomUUID)(),
+                target: runtime.target,
+                runId: runtime.runId,
+                deliveryMode: 'steer',
+                text: item.goalObjective ? `Goal for the current Build:\n${item.goalObjective}` : item.text,
+                goalObjective: item.goalObjective,
+                createdAt: item.createdAt || new Date().toISOString(),
+            });
+            if (receipt.status === 'rejected')
+                return {
+                    ok: false,
+                    queueItems: this.queueItems(runtime.target),
+                    queuePaused: runtime.queuePaused,
+                    queued: this.queued(runtime.target),
+                    receipt,
+                };
+            this.deleteQueueItem(runtime.target, item.id);
+        }
+        return {
+            ok: true,
+            queueItems: this.queueItems(runtime.target),
+            queuePaused: runtime.queuePaused,
+            queued: this.queued(runtime.target),
+            receipt,
+        };
+    }
     events(target) {
         return this.findRuntime(target)?.events.slice() || [];
     }
@@ -89,6 +256,8 @@ class ConversationKernel {
             workRuns: this.bindWorkRunsToRuntimeTarget(conversationSnapshot.workRuns, normalized),
             target: normalized,
             queued: this.queued(normalized),
+            queueItems: this.queueItems(normalized),
+            queuePaused: runtime?.queuePaused === true,
             workEvents: this.events(normalized),
             runtime: this.runtimeState(normalized),
             mode: runner.mode,
@@ -562,7 +731,7 @@ class ConversationKernel {
                         stopped = true;
                         this.settleCooperativeStop(runtime, runId);
                     }
-                    else if (runtime.pendingNextTurn.length > 0) {
+                    else if (!runtime.queuePaused && runtime.pendingNextTurn.length > 0) {
                         // A renderer/IPC Guide can arrive after the final-drain barrier's
                         // last check but before this promise settles. Do not leave the
                         // deferred continuation queued on an idle runtime.
@@ -605,7 +774,7 @@ class ConversationKernel {
             return this.result(runtime, lastTokens);
         }
         for (;;) {
-            while (runtime.pendingNextTurn.length > 0) {
+            while (!runtime.queuePaused && runtime.pendingNextTurn.length > 0) {
                 if (runtime.stopRequestedRunId === runtime.runId)
                     return this.result(runtime, lastTokens);
                 const next = runtime.pendingNextTurn.shift();
@@ -652,7 +821,8 @@ class ConversationKernel {
                     this.mirrorHostIfTargetActive(runtime);
                     return this.result(runtime, lastTokens);
                 }
-                this.clearQueued(runtime);
+                if (!runtime.pendingNextTurn.length)
+                    this.clearQueued(runtime);
                 const completedRunId = runtime.runId;
                 runtime.runner.finishConversationWorkRun(completedRunId, 'completed');
                 // A Guide can be submitted synchronously by a consumer of the public
@@ -662,6 +832,7 @@ class ConversationKernel {
                 await new Promise(resolve => setImmediate(resolve));
                 if (runtime.runId === completedRunId
                     && runtime.stopRequestedRunId !== completedRunId
+                    && !runtime.queuePaused
                     && runtime.pendingNextTurn.length > 0) {
                     runtime.guideAcceptanceClosedRunId = '';
                     if (!runtime.runner.resumeConversationWorkRun(completedRunId)) {
@@ -757,6 +928,7 @@ class ConversationKernel {
             events: [],
             pendingNextTurn: [],
             queued: { steering: [], followUp: [] },
+            queuePaused: false,
             runId: '',
             generation: this.generations.get(target.runtimeKey) || 0,
             stopRequestedRunId: '',
@@ -874,7 +1046,7 @@ class ConversationKernel {
         }
         setImmediate(() => {
             runtime.pendingContinuationRunId = undefined;
-            if (runtime.runId !== runId || runtime.activePromise || runtime.stopRequestedRunId === runId)
+            if (runtime.runId !== runId || runtime.activePromise || runtime.stopRequestedRunId === runId || runtime.queuePaused)
                 return;
             const next = runtime.pendingNextTurn.shift();
             if (!next)
@@ -1040,8 +1212,39 @@ class ConversationKernel {
         const isSteer = queueMode === 'steer';
         const text = typeof message === 'string' ? message : message.text;
         const prompt = isSteer ? text : `[Next queued while current turn is running]\n${text}`;
-        if (!isSteer)
-            this.trackQueuedMessage(runtime, prompt, queueMode);
+        if (!isSteer) {
+            const structured = typeof message === 'string' ? null : message;
+            const clientMessageId = String(structured?.clientMessageId || (0, crypto_1.randomUUID)());
+            const queuedMessage = {
+                ...(structured || {}),
+                text: prompt,
+                visibleUserInput: structured?.visibleUserInput || text,
+                visibleMode: structured?.visibleMode || runtime.options.mode,
+                clientMessageId,
+                runId: structured?.runId || runtime.runId,
+                createdAt: String(structured?.createdAt || new Date().toISOString()),
+            };
+            if (!runtime.pendingNextTurn.some(item => typeof item.message !== 'string' && item.message.clientMessageId === clientMessageId)) {
+                runtime.pendingNextTurn.push({ message: queuedMessage, queueMode: 'followUp' });
+            }
+            runtime.runner.retainConversationContinuations([{
+                    content: prompt,
+                    queueMode: 'followUp',
+                    clientMessageId,
+                    runId: queuedMessage.runId,
+                    images: queuedMessage.images?.map(image => ({ ...image })),
+                    attachments: queuedMessage.attachments?.map(attachment => ({ ...attachment })),
+                    createdAt: queuedMessage.createdAt,
+                }]);
+            this.trackQueuedMessage(runtime, prompt, 'followUp');
+            runtime.runner.recordWorkStatus(runtime.stopRequestedRunId === runtime.runId
+                ? 'Next message retained while stopping.'
+                : 'Next message queued.');
+            if (runtime.stopRequestedRunId === runtime.runId)
+                runtime.forceStopArmedRunId = '';
+            this.emitQueueUpdate(runtime);
+            return;
+        }
         if (runtime.stopRequestedRunId === runtime.runId) {
             runtime.forceStopArmedRunId = '';
             const structured = typeof message === 'string' ? undefined : message;
@@ -1096,6 +1299,13 @@ class ConversationKernel {
         if (changed)
             this.emitQueueUpdate(runtime);
     }
+    replaceTrackedQueuedMessage(runtime, oldMessage, nextMessage, queueMode) {
+        this.queueState(runtime);
+        const list = queueMode === 'steer' ? runtime.queued.steering : runtime.queued.followUp;
+        const index = list.indexOf(oldMessage);
+        if (index >= 0)
+            list[index] = nextMessage;
+    }
     emitQueueUpdate(runtime) {
         this.queueState(runtime);
         runtime.runner.emitWorkEvent({
@@ -1236,10 +1446,11 @@ class ConversationKernel {
         await Promise.resolve();
         if (runtime.runId !== runId || runtime.stopRequestedRunId === runId)
             return true;
-        if (runtime.pendingNextTurn.length > 0 || runtime.runner.subagents.readRootInbox().length > 0)
+        const hasSteering = runtime.pendingNextTurn.some(item => item.queueMode === 'steer');
+        if (hasSteering || runtime.runner.subagents.readRootInbox().length > 0)
             return false;
         runtime.guideAcceptanceClosedRunId = runId;
-        if (runtime.pendingNextTurn.length > 0 || runtime.runner.subagents.readRootInbox().length > 0) {
+        if (runtime.pendingNextTurn.some(item => item.queueMode === 'steer') || runtime.runner.subagents.readRootInbox().length > 0) {
             runtime.guideAcceptanceClosedRunId = '';
             return false;
         }

package/dist/core/electronUtilityAgentClient.d.ts

@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import { NormalizedConversationTarget } from './conversationTarget';
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
+import { ConversationQueueAction } from './conversationKernel';
 import { UtilityAgentPromptResult, UtilityAutoRouteRatingResult, UtilityAgentSnapshotResult, UtilityAgentStopResult, UtilityConversationRewindResult, UtilityHostToolRequest, UtilityPromptRequest } from './utilityAgentProtocol';
 type WindowsProcessTreeHelperRuntime = {
     kind: 'precompiled' | 'runtime_compile';
@@ -94,6 +95,13 @@ export declare class ElectronUtilityAgentClient {
     rewind(messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(runId?: string): Promise<UtilityAgentStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
+    queueAction(action: ConversationQueueAction, input?: {
+        id?: string;
+        text?: string;
+        requestedMode?: string;
+        goalObjective?: string;
+        createdAt?: string;
+    }): Promise<Record<string, unknown>>;
     checkpoint(): Promise<Record<string, unknown>>;
     contextCompress(options?: {
         keepRecent?: number;

package/dist/core/electronUtilityAgentClient.js

@@ -1023,6 +1023,10 @@ class ElectronUtilityAgentClient {
         await this.start();
         return await this.request('guide', { target: this.target, envelope }, 5_000);
     }
+    async queueAction(action, input = {}) {
+        await this.start();
+        return await this.request('queue_action', { target: this.target, action, input }, 5_000);
+    }
     async checkpoint() {
         await this.start();
         return await this.request('checkpoint', { target: this.target }, 5_000);
@@ -1334,7 +1338,7 @@ class ElectronUtilityAgentClient {
         let result;
         const controller = new AbortController();
         this.hostToolRuns.set(request.requestId, { generation, controller });
-        const allowed = new Set(['browser_control', 'browser_use', 'computer_use', 'automation', 'terminal_takeover']);
+        const allowed = new Set(['browser_control', 'browser_use', 'screen_capture', 'computer_use', 'automation', 'terminal_takeover']);
         if (!allowed.has(request.tool)) {
             result = { requestId: request.requestId, ok: false, error: `Electron host tool is not allowed: ${String(request.tool)}` };
         }

package/dist/core/electronUtilityRuntimePool.d.ts

@@ -1,4 +1,5 @@
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
+import { ConversationQueueAction } from './conversationKernel';
 import { ConversationRuntimeTarget, NormalizedConversationTarget } from './conversationTarget';
 import { UtilityHostToolHandler } from './electronUtilityAgentClient';
 import { UtilityAgentPromptResult, UtilityAutoRouteRatingResult, UtilityConversationRewindResult, UtilityAgentSnapshotResult, UtilityAgentStopResult, UtilityPromptRequest } from './utilityAgentProtocol';
@@ -10,6 +11,13 @@ export interface ElectronTargetRuntimeClient {
     rewind(messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(runId?: string): Promise<UtilityAgentStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
+    queueAction?(action: ConversationQueueAction, input?: {
+        id?: string;
+        text?: string;
+        requestedMode?: string;
+        goalObjective?: string;
+        createdAt?: string;
+    }): Promise<Record<string, unknown>>;
     checkpoint(): Promise<Record<string, unknown>>;
     contextCompress?(options?: {
         keepRecent?: number;
@@ -71,6 +79,13 @@ export declare class ElectronUtilityRuntimePool {
     rewind(target: ConversationRuntimeTarget, messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(target: ConversationRuntimeTarget, runId?: string): Promise<ElectronPoolStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
+    queueAction(target: ConversationRuntimeTarget, action: ConversationQueueAction, input?: {
+        id?: string;
+        text?: string;
+        requestedMode?: string;
+        goalObjective?: string;
+        createdAt?: string;
+    }): Promise<Record<string, unknown>>;
     checkpoint(target: ConversationRuntimeTarget): Promise<Record<string, unknown>>;
     contextCompress(target: ConversationRuntimeTarget, options?: {
         keepRecent?: number;

package/dist/core/electronUtilityRuntimePool.js

@@ -184,6 +184,17 @@ class ElectronUtilityRuntimePool {
             this.release(entry, true);
         }
     }
+    async queueAction(target, action, input = {}) {
+        const entry = await this.acquireExisting(target);
+        if (!entry || !entry.client.queueAction)
+            throw new Error('Target conversation is not running');
+        try {
+            return await entry.client.queueAction(action, input);
+        }
+        finally {
+            this.release(entry, true);
+        }
+    }
     async checkpoint(target) {
         const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
         const entry = await this.acquireExisting(normalized);

package/dist/core/toolPolicy.js

@@ -10,6 +10,7 @@ exports.planModePolicyPrompt = planModePolicyPrompt;
 exports.evaluateDeletionGuard = evaluateDeletionGuard;
 const REQUIRED_TOOLS = new Set(['pwd', 'read', 'glob', 'grep']);
 const MODE_SCOPED_TOOLS = new Set([
+    'screen_capture',
     'image_inspect',
     'image_display',
     'ocr_read',
@@ -42,6 +43,7 @@ const MODE_SCOPED_TOOLS = new Set([
     'branch_create',
 ]);
 const PLAN_READ_ONLY_TOOLS = new Set([
+    'screen_capture',
     'task_read',
     'pwd',
     'read',
@@ -103,6 +105,7 @@ const CONCURRENCY_SAFE_TOOLS = new Set([
     'git_status',
     'file_audit',
     'repo_security_audit',
+    'screen_capture',
     'SubAgent',
 ]);
 /** 判断一个工具是否可参与并行调度。缺省 false（独占）。

package/dist/core/utilityAgentProtocol.d.ts

@@ -1,6 +1,6 @@
 import { BrowserControlRequest, BrowserControlResult } from './browserControl';
 import { BrowserUseRequest } from './browserUse';
-import { AgentPromptMessage, ConversationContextCompressOptions, ConversationKernelRunOptions, ConversationKernelRunResult, ConversationQueueMode, ConversationRuntimeState, ConversationStopResult } from './conversationKernel';
+import { AgentPromptMessage, ConversationContextCompressOptions, ConversationKernelRunOptions, ConversationKernelRunResult, ConversationQueueAction, ConversationQueueMode, ConversationRuntimeState, ConversationStopResult } from './conversationKernel';
 import { ConversationRuntimeTarget, NormalizedConversationTarget } from './conversationTarget';
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
 import type { AutoRouteRatingResult, ConversationSnapshot } from './agent';
@@ -40,6 +40,10 @@ export type UtilityHostToolRequest = (UtilityHostToolRequestBase & {
     tool: 'browser_use';
     args: BrowserUseRequest;
     context: UtilityHostToolContext;
+}) | (UtilityHostToolRequestBase & {
+    tool: 'screen_capture';
+    args: Record<string, unknown>;
+    context: UtilityHostToolContext;
 }) | (UtilityHostToolRequestBase & {
     tool: 'computer_use';
     args: Record<string, unknown>;
@@ -96,6 +100,20 @@ export type UtilityAgentRequest = {
         target: ConversationRuntimeTarget;
         envelope: ConversationInputEnvelope;
     };
+} | {
+    id: string;
+    method: 'queue_action';
+    params: {
+        target: ConversationRuntimeTarget;
+        action: ConversationQueueAction;
+        input?: {
+            id?: string;
+            text?: string;
+            requestedMode?: string;
+            goalObjective?: string;
+            createdAt?: string;
+        };
+    };
 } | {
     id: string;
     method: 'checkpoint';
@@ -210,6 +228,16 @@ export interface UtilityAgentSnapshotResult {
         steering: string[];
         followUp: string[];
     };
+    queueItems?: Array<{
+        id: string;
+        text: string;
+        queueMode: 'steer' | 'followUp';
+        requestedMode?: string;
+        goalObjective?: string;
+        runId?: string;
+        createdAt: string;
+    }>;
+    queuePaused?: boolean;
     workEvents: AgentWorkEvent[];
     [key: string]: unknown;
 }