newmark-agent 0.4.6 → 0.4.8

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/installUpdate.js

@@ -527,7 +527,7 @@ async function applyGitHubUpdate(options) {
         };
     }
 }
-const NEWMARK_PROCESS_NAMES = ['Newmark Agent.exe', 'Newmark.exe'];
+const NEWMARK_PROCESS_NAMES = ['Newmark Agent.exe', 'Newmark.exe', 'Newmark Console Runtime.exe'];
 const NEWMARK_LEGACY_EXECUTABLES = new Set(['newmark.exe', 'newmark agent.exe']);
 function normalizeWindowsPathForCompare(value) {
     return path.resolve(String(value)).toLowerCase();
@@ -547,7 +547,8 @@ function runPowerShellJson(script) {
     return Array.isArray(parsed) ? parsed.map(item => item) : [parsed];
 }
 function listRunningNewmarkProcesses() {
-    const rows = runPowerShellJson(`Get-CimInstance Win32_Process -ErrorAction SilentlyContinue | Where-Object { $_.Name -eq 'Newmark Agent.exe' -or $_.Name -eq 'Newmark.exe' } | Select-Object ProcessId,Name,ExecutablePath | ConvertTo-Json -Compress`);
+    const nameFilter = NEWMARK_PROCESS_NAMES.map(name => `$_.Name -eq '${name.replace(/'/g, "''")}'`).join(' -or ');
+    const rows = runPowerShellJson(`Get-CimInstance Win32_Process -ErrorAction SilentlyContinue | Where-Object { ${nameFilter} } | Select-Object ProcessId,Name,ExecutablePath | ConvertTo-Json -Compress`);
     const skipPid = Number(process.env.NEWMARK_SKIP_PROCESS_PID || process.pid);
     return rows
         .map(row => ({
@@ -621,26 +622,28 @@ function runElevatedMsiExec(args) {
 function uninstallNewmarkProduct(productCode, logPath) {
     const args = ['/x', productCode, '/qn', '/norestart', '/l*v', logPath];
     let result = runMsiExec(args);
-    if (result.exitCode !== 0)
+    if (result.exitCode !== 0 && result.exitCode !== 3010)
         result = runElevatedMsiExec(args);
+    const ok = result.exitCode === 0 || result.exitCode === 3010;
     return {
-        ok: result.exitCode === 0,
+        ok,
         exitCode: result.exitCode,
         logPath,
-        error: result.exitCode === 0 ? undefined : `msiexec uninstall exited ${result.exitCode}`,
+        error: ok ? undefined : `msiexec uninstall exited ${result.exitCode}`,
     };
 }
 function installMsiPackage(msiPath, options = {}) {
     const logPath = path.join(options.logDir || os.tmpdir(), `newmark-msi-install-${process.pid}-${Date.now()}.log`);
     const args = ['/i', path.resolve(msiPath), '/qn', '/norestart', '/l*v', logPath];
     let result = runMsiExec(args);
-    if (result.exitCode !== 0 && options.allowElevate !== false)
+    if (result.exitCode !== 0 && result.exitCode !== 3010 && options.allowElevate !== false)
         result = runElevatedMsiExec(args);
+    const ok = result.exitCode === 0 || result.exitCode === 3010;
     return {
-        ok: result.exitCode === 0,
+        ok,
         exitCode: result.exitCode,
         logPath,
-        error: result.exitCode === 0 ? undefined : `msiexec install exited ${result.exitCode}`,
+        error: ok ? undefined : `msiexec install exited ${result.exitCode}`,
     };
 }
 function findLegacyNewmarkExecutables(excludeRoots = []) {

package/dist/core/mobilePairing.d.ts

@@ -25,6 +25,7 @@ export interface PairingStatus {
 }
 export declare function ensureMobileToken(root: string): string;
 export declare function tailscaleIpv4(): string | null;
+export declare function lanIpv4(): string | null;
 export declare function pairingHost(): string;
 export declare function createPairingSession(root: string, ttlMs?: number): PairingSession;
 export declare function pairingUrl(root: string): string;

package/dist/core/mobilePairing.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOBILE_PAIRING_TTL_MS = exports.MOBILE_PORT = exports.MOBILE_PAIRING_FILENAME = exports.MOBILE_TOKEN_FILENAME = void 0;
 exports.ensureMobileToken = ensureMobileToken;
 exports.tailscaleIpv4 = tailscaleIpv4;
+exports.lanIpv4 = lanIpv4;
 exports.pairingHost = pairingHost;
 exports.createPairingSession = createPairingSession;
 exports.pairingUrl = pairingUrl;
@@ -105,8 +106,21 @@ function tailscaleIpv4() {
         return null;
     }
 }
+function lanIpv4() {
+    const interfaces = os.networkInterfaces();
+    const candidates = [];
+    for (const name of Object.keys(interfaces)) {
+        for (const info of interfaces[name] || []) {
+            if (info.family !== 'IPv4' || info.internal)
+                continue;
+            if (/^(10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.)/.test(info.address))
+                candidates.push(info.address);
+        }
+    }
+    return candidates.sort()[0] || null;
+}
 function pairingHost() {
-    return tailscaleIpv4() || '127.0.0.1';
+    return tailscaleIpv4() || lanIpv4() || '127.0.0.1';
 }
 function buildPairingUrl(session) {
     const query = new URLSearchParams({

package/dist/core/subagent.d.ts

@@ -54,6 +54,10 @@ export interface SubagentInstance {
     name: string;
     conversationId: string;
     createdByAgentId: string;
+    /** Root Build Block that created this peer. Empty only for legacy/direct API records. */
+    buildRunId?: string;
+    /** Intelligence tier captured at creation so the enforced 4/16 ceiling is auditable. */
+    intelligenceTier?: string;
     prompt: string;
     model: string;
     inputMode: string;
@@ -172,7 +176,7 @@ export declare class SubagentManager {
     private running;
     private schedulingPaused;
     private nextSequence;
-    private readonly concurrency;
+    private concurrency;
     private executor?;
     private onChange?;
     private persist?;
@@ -186,9 +190,9 @@ export declare class SubagentManager {
     hasRecords(): boolean;
     reset(): void;
     constructor(options?: SubagentManagerOptions);
-    bind(options: Pick<SubagentManagerOptions, 'executor' | 'onChange' | 'persist' | 'onMailboxMessage' | 'onRootInboxMessage' | 'onSettled'>): void;
+    bind(options: Pick<SubagentManagerOptions, 'concurrency' | 'executor' | 'onChange' | 'persist' | 'onMailboxMessage' | 'onRootInboxMessage' | 'onSettled'>): void;
     removeRootInboxListener(listener: (message: SubagentRootMessage) => boolean): void;
-    create(name: string, prompt: string, model?: string, inputMode?: string, agentMode?: AgentMode, createdByAgentId?: string, flowName?: string, goalObjective?: string, flowPc?: number): string;
+    create(name: string, prompt: string, model?: string, inputMode?: string, agentMode?: AgentMode, createdByAgentId?: string, flowName?: string, goalObjective?: string, flowPc?: number, buildRunId?: string, intelligenceTier?: string): string;
     get(id: string): SubagentInstance | undefined;
     send(id: string, prompt: string): boolean;
     sendMessage(fromAgentId: string, toAgentId: string, body: string, kind?: SubagentMessageKind, details?: {
@@ -231,6 +235,9 @@ export declare class SubagentManager {
     boundedResultTranscript(idOrName: string): string;
     listActive(): SubagentInstance[];
     listAll(): SubagentInstance[];
+    activeCountForBuild(buildRunId: string): number;
+    setConcurrencyLimit(value: number): void;
+    concurrencyLimit(): number;
     pauseScheduling(): void;
     resumeScheduling(): void;
     isSchedulingPaused(): boolean;

package/dist/core/subagent.js

@@ -93,6 +93,8 @@ class SubagentManager {
         queueMicrotask(() => this.pump());
     }
     bind(options) {
+        if (options.concurrency !== undefined)
+            this.setConcurrencyLimit(options.concurrency);
         if (options.executor)
             this.executor = options.executor;
         if (options.onChange)
@@ -115,16 +117,16 @@ class SubagentManager {
     removeRootInboxListener(listener) {
         this.rootInboxListeners.delete(listener);
     }
-    create(name, prompt, model, inputMode, agentMode = 'build', createdByAgentId = this.rootAgentId, flowName = '', goalObjective = '', flowPc = 0) {
+    create(name, prompt, model, inputMode, agentMode = 'build', createdByAgentId = this.rootAgentId, flowName = '', goalObjective = '', flowPc = 0, buildRunId = '', intelligenceTier = '') {
         const id = (0, crypto_1.randomUUID)();
         const shortId = id.replace(/-/g, '').slice(0, 8);
         const slug = natureSlug(name);
-        // The Agent-facing name is the caller's stable, human-readable label and is
-        // deliberately decoupled from the identity. The UUID and its short form are
-        // the only identity-bearing fields; the UI renders the short-id-qualified
-        // display name while Agent tool interactions accept both name and id.
-        const displayName = `${slug}-${shortId}`;
-        const qualifiedName = `${displayName}--${id}`;
+        // The monitoring label is exactly the caller-created human-readable name.
+        // UUID-bearing identity stays in id/qualifiedName and is never appended to
+        // the right-sidebar title.
+        const createdName = String(name || 'SubAgent').replace(/\s+/g, ' ').trim().slice(0, 160) || 'SubAgent';
+        const displayName = createdName;
+        const qualifiedName = `${slug}--${id}`;
         const stamp = now();
         const record = {
             id,
@@ -132,9 +134,11 @@ class SubagentManager {
             natureSlug: slug,
             displayName,
             qualifiedName,
-            name: slug,
+            name: createdName,
             conversationId: this.conversationId,
             createdByAgentId,
+            buildRunId: String(buildRunId || '').trim() || undefined,
+            intelligenceTier: String(intelligenceTier || '').trim() || undefined,
             prompt,
             model: model || 'default',
             inputMode: inputMode || 'guide',
@@ -504,6 +508,17 @@ class SubagentManager {
     }
     listActive() { return this.listAll().filter(item => item.status !== 'closed'); }
     listAll() { return [...this.subs.values()].map(cloneRecord); }
+    activeCountForBuild(buildRunId) {
+        const target = String(buildRunId || '').trim();
+        if (!target)
+            return 0;
+        return [...this.subs.values()].filter(record => record.buildRunId === target && (record.status === 'queued' || record.status === 'working')).length;
+    }
+    setConcurrencyLimit(value) {
+        this.concurrency = Math.max(1, Math.min(16, Math.floor(Number(value) || 4)));
+        this.pump();
+    }
+    concurrencyLimit() { return this.concurrency; }
     pauseScheduling() {
         if (this.schedulingPaused)
             return;

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',
@@ -26,6 +27,10 @@ const MODE_SCOPED_TOOLS = new Set([
     'task_read',
     'task_create',
     'question',
+    'SubAgent',
+    'subagent_create',
+    // Legacy runtime alias. It is no longer published to models because its
+    // generic name collides with the persistent task checklist.
     'task',
     'subagent_list',
     'subagent_read',
@@ -38,6 +43,7 @@ const MODE_SCOPED_TOOLS = new Set([
     'branch_create',
 ]);
 const PLAN_READ_ONLY_TOOLS = new Set([
+    'screen_capture',
     'task_read',
     'pwd',
     'read',
@@ -59,6 +65,8 @@ const PLAN_READ_ONLY_TOOLS = new Set([
     'skill',
     'linked_plan',
     'build_history_query',
+    'SubAgent',
+    'subagent_create',
     'task',
     'subagent_list',
     'subagent_read',
@@ -76,9 +84,10 @@ const PLAN_BROWSER_USE_ACTION_SET = new Set(exports.PLAN_BROWSER_USE_ACTIONS);
 /**
  * 并发安全工具集合（DSH isConcurrencySafe 语义的 Newmark 落地）。
  *
- * 只有确定性无副作用的只读工具才允许与兄弟 tool call 并发执行；任何写入、
- * shell 命令、浏览器交互、子代理编排、以及会改变对话/文件/外部状态的工具
- * 都保持独占串行，避免盲目 Promise.all 引发竞态。缺省保守：不在集合中的
+ * 确定性无副作用的只读工具允许与兄弟 tool call 并发执行。`SubAgent` 创建是
+ * 唯一允许并发的受控写操作：每个调用只追加一个独立 UUID 记录，真正的 worker
+ * 并发由 SubagentManager 的 4/16 槽位及 Build Block 硬上限管理。其他写入、shell、
+ * 浏览器交互、子代理发送/关闭等操作仍保持独占串行。缺省保守：不在集合中的
  * 工具一律视为独占。
  *
  * 注意：read/grep/glob/pwd 是同一进程内的内存/文件系统只读，可安全重叠；
@@ -96,6 +105,8 @@ const CONCURRENCY_SAFE_TOOLS = new Set([
     'git_status',
     'file_audit',
     'repo_security_audit',
+    'screen_capture',
+    'SubAgent',
 ]);
 /** 判断一个工具是否可参与并行调度。缺省 false（独占）。
  *  优先看 toolchain registry 推断的 riskLevel（'read' 工具天然并发安全，