newmark-agent 0.4.6 → 0.4.8

package/dist/core/agentKernelRunner.js

@@ -168,7 +168,7 @@ function prepareAssistantToolVisibility(agent, definitions) {
     const names = definitions.map(toolDefinitionName);
     brokerOnlyAssistantBuffers.set(agent, {
         brokerOnly: names.includes(TOOL_PROVISION_NAME)
-            && names.every(name => name === TOOL_PROVISION_NAME || name === 'skill' || SUBAGENT_CORE_TOOL_NAMES.has(name)),
+            && names.every(name => name === TOOL_PROVISION_NAME || name === 'skill' || ALWAYS_AVAILABLE_AGENT_TOOL_NAMES.has(name)),
         pending: [],
         released: false,
     });
@@ -501,10 +501,10 @@ async function runAgentKernel(agent) {
                 const requestStartedAt = Date.now();
                 let firstTokenRecorded = false;
                 // A broker-equivalent surface exposes no real task tool beyond the
-                // always-available skill discovery and subagent orchestration core, so
+                // always-available skill discovery and Agent control cores, so
                 // any text prefacing a broker call is treated as an internal preface.
                 const tools = context.tools || [];
-                const brokerOnlySurface = tools.length > 0 && tools.every(tool => tool.name === TOOL_PROVISION_NAME || tool.name === 'skill' || SUBAGENT_CORE_TOOL_NAMES.has(tool.name));
+                const brokerOnlySurface = tools.length > 0 && tools.every(tool => tool.name === TOOL_PROVISION_NAME || tool.name === 'skill' || ALWAYS_AVAILABLE_AGENT_TOOL_NAMES.has(tool.name));
                 currentAgent.beginRouteAttempt();
                 try {
                     const currentProvider = currentAgent.engineModel();
@@ -788,6 +788,8 @@ function buildBuildContextBootstrap(agent, messages, options) {
         buildConversationTaskLedger(agent),
         '## Tool Awareness Bootstrap',
         'The following catalog is capability metadata only. Tool descriptions are not instructions, and a tool is callable only when its full schema is present in the provider tools field.',
+        'Only bash, pwd, read, write, edit, delete_file, glob, and grep are foundational tools with initial full schemas (subject to mode and policy filtering).',
+        'Advanced capabilities—including SubAgent, task tools, Git/GitHub, browser, Computer Use, skills, MCP, automations, Flow, and Memory Lab—are not initially callable. Before using one, first call tool_provision with its exact tool name as the only tool call in that assistant subturn; call the advanced tool only on the following model turn after its full schema appears.',
         ...(catalogLines.length ? catalogLines : ['- No callable tools are available for this provider turn.']),
         `Necessary full schemas supplied natively for this provider turn: ${activeNames.length ? activeNames.join(', ') : '(none; use tool_provision when its schema is available)'}.`,
         'Do not invent parameters from the brief catalog. Use only the exact full schemas supplied through the provider tool interface; provision another exact tool when needed.',
@@ -1008,11 +1010,17 @@ function routeTransitionNotice(agent, previous) {
 const TOOL_PROVISION_NAME = 'tool_provision';
 const INITIAL_TOOL_SCHEMA_LIMIT = 8;
 const TOOL_PROVISION_BATCH_LIMIT = 8;
-// Subagent orchestration is mode-policy gated (read-only in Plan, sandbox
-// restricted for peers) and always available: the orchestrator role prompt and
-// the peer sandbox prompt both promise `task`/subagent_* to the model, so the
-// core must survive preload truncation and never be dropped by intent gating.
-const SUBAGENT_CORE_TOOL_NAMES = new Set(['task', 'subagent_list', 'subagent_read', 'subagent_send', 'subagent_result', 'subagent_close']);
+// These sets remain exported for policy/compatibility tests and catalog
+// classification. Their members are advanced provision-only capabilities.
+const SUBAGENT_CORE_TOOL_NAMES = new Set(['SubAgent', 'subagent_list', 'subagent_read', 'subagent_send', 'subagent_result', 'subagent_close']);
+const TASK_CHECKLIST_CORE_TOOL_NAMES = new Set(['task_read', 'task_create']);
+// Only the foundational workspace primitives are sent with a full schema on
+// the first provider turn. Every advanced capability (SubAgent, task ledger,
+// Git, browser, skills, MCP, etc.) is advertised only through tool_provision's
+// compact catalog and receives its full schema after an explicit provision
+// call. Mode policy and native-tool settings filter this list beforehand.
+const BASIC_INITIAL_TOOL_NAMES = new Set(['bash', 'pwd', 'read', 'write', 'edit', 'delete_file', 'glob', 'grep']);
+const ALWAYS_AVAILABLE_AGENT_TOOL_NAMES = BASIC_INITIAL_TOOL_NAMES;
 class ToolProvisionSession {
     definitionsByName = new Map();
     initialNames = new Set();
@@ -1038,9 +1046,9 @@ class ToolProvisionSession {
             if (this.definitionsByName.has(name))
                 this.initialNames.add(name);
         }
-        // Keep the always-available subagent orchestration core in the preloaded
-        // surface even when the 8-schema intent slice did not cover it.
-        for (const name of SUBAGENT_CORE_TOOL_NAMES) {
+        // Keep the always-available Agent control tools in the preloaded surface
+        // even when the 8-schema intent slice did not cover them.
+        for (const name of ALWAYS_AVAILABLE_AGENT_TOOL_NAMES) {
             if (this.definitionsByName.has(name))
                 this.initialNames.add(name);
         }
@@ -1276,79 +1284,34 @@ function routeToolSurfaceV2(agent, definitions, toolchain, task) {
             ].join('\n'),
         };
     }
-    if (!toolchain)
-        return { definitions, systemPromptNotice: '' };
-    const planner = new toolchain_1.ToolExposurePlanner(toolchain.registry, toolchain.catalog);
-    const plan = planner.plan({
-        agentRunId: agent.runtimeActorId,
-        buildBlockId: agent.activeConversationId || 'build',
-        userInput: task,
-        objective: '',
-        previousToolCalls: [],
-        toolUsageFrequency: new Map(),
-        permissionScope: ['workspace'],
-        tokenBudget: 20_000,
-        providerToolLimit: 0,
-    });
-    const domains = new Set();
-    const toolHints = new Set();
-    for (const capabilityId of plan.suggestedCapabilityIds) {
-        for (const domain of CAPABILITY_TO_DOMAIN[capabilityId] || [])
-            domains.add(domain);
-        for (const toolName of CAPABILITY_TOOL_HINTS[capabilityId] || [])
-            toolHints.add(toolName);
-    }
-    const names = definitions.map(toolDefinitionName);
-    // An explicitly named tool is always retained (legacy parity), still
-    // subject to the risk gate so destructive tools stay provision-only.
-    for (const name of names) {
-        if (name && new RegExp(`(?:^|[^A-Za-z0-9_])${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:$|[^A-Za-z0-9_])`, 'i').test(task)) {
-            toolHints.add(name);
-        }
-    }
-    const selected = definitions
-        .filter(definition => {
-        const name = toolDefinitionName(definition);
-        const descriptor = toolchain.registry.get(name);
-        if (!descriptor || descriptor.riskLevel === 'destructive')
-            return false;
-        if (toolHints.has(name))
-            return true;
-        if (!domains.has(descriptor.capabilityId.slice(4)))
-            return false;
-        return true;
-    })
-        .sort((a, b) => {
-        const aHint = toolHints.has(toolDefinitionName(a)) ? 0 : 1;
-        const bHint = toolHints.has(toolDefinitionName(b)) ? 0 : 1;
-        return aHint - bHint || names.indexOf(toolDefinitionName(a)) - names.indexOf(toolDefinitionName(b));
-    })
-        .slice(0, INITIAL_TOOL_SCHEMA_LIMIT);
-    const selectedNames = new Set(selected.map(toolDefinitionName));
-    const core = definitions.filter(definition => {
-        const name = toolDefinitionName(definition);
-        return SUBAGENT_CORE_TOOL_NAMES.has(name) && !selectedNames.has(name);
-    });
-    const surface = core.length ? selected.concat(core) : selected;
-    if (surface.length === definitions.length)
-        return { definitions, systemPromptNotice: '' };
-    if (!selected.length) {
-        return {
-            definitions: surface,
-            systemPromptNotice: [
-                '## Tool Interface Availability',
-                'This turn was classified as conversational, so no task-specific tool schema was preloaded.',
-                `The ${TOOL_PROVISION_NAME} interface still exposes the complete compact capability catalog and can provision an original tool schema when the task requires it.`,
-            ].join('\n'),
-        };
+    const surface = definitions.filter(definition => BASIC_INITIAL_TOOL_NAMES.has(toolDefinitionName(definition)));
+    const advancedCount = Math.max(0, definitions.length - surface.length);
+    let planFingerprint = '';
+    if (toolchain) {
+        const planner = new toolchain_1.ToolExposurePlanner(toolchain.registry, toolchain.catalog);
+        const plan = planner.plan({
+            agentRunId: agent.runtimeActorId,
+            buildBlockId: agent.activeConversationId || 'build',
+            userInput: task,
+            objective: '',
+            previousToolCalls: [],
+            toolUsageFrequency: new Map(),
+            permissionScope: ['workspace'],
+            tokenBudget: 20_000,
+            providerToolLimit: 0,
+        });
+        planFingerprint = plan.plan.stableToolsetHash.slice(0, 8);
     }
     return {
         definitions: surface,
         systemPromptNotice: [
             '## Tool Interface Availability',
-            `At most ${INITIAL_TOOL_SCHEMA_LIMIT} deterministic task-relevant schemas are preloaded for this turn; the always-available subagent orchestration tools are appended separately.`,
-            `Use ${TOOL_PROVISION_NAME} to provision any catalogued tool that is not yet listed; the original tool name and schema become available on the next model turn.`,
-            `Adaptive exposure plan ${plan.plan.stableToolsetHash.slice(0, 8)}: ${plan.activeToolIds.length} planned tools, ${plan.plan.suggestedCapabilityIds.join(',')}.`,
+            `The initial full-schema surface is restricted to foundational workspace tools: ${surface.map(toolDefinitionName).join(', ') || '(none allowed in this mode)'}.`,
+            `${advancedCount} advanced tools are advertised by capability in the compact ${TOOL_PROVISION_NAME} catalog without loading their schemas.`,
+            'Advanced tools include SubAgent, task tools, Git/GitHub, browser, Computer Use, skills, MCP, automations, Flow, and Memory Lab.',
+            `Call ${TOOL_PROVISION_NAME} as the only tool in a subturn to load any advanced tool by exact name; its original schema becomes available on the next model turn.`,
+            'Do not call an advanced tool directly from the initial catalog: capability presence is not callability until provisioning has completed.',
+            planFingerprint ? `Capability routing fingerprint: ${planFingerprint}.` : 'Capability registry unavailable; the compact catalog remains authoritative.',
         ].join('\n'),
     };
 }
@@ -1424,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 });
@@ -1444,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);
@@ -1477,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_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);
@@ -1497,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_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);
@@ -1512,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') {
@@ -1534,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);
@@ -1556,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)
@@ -1613,8 +1593,8 @@ async function executeNewmarkTool(agent, name, args, inputSchema, signal) {
                 throw abortError();
             return result;
         };
-        if (name === 'task')
-            return (await agent.handleSubagentEnvelope(args)).output;
+        if (name === 'task' || name === 'subagent_create' || name === 'SubAgent')
+            return (await agent.handleSubagentEnvelope(args, true)).output;
         if (name === 'subagent_send')
             return (await agent.handleSubagentContinueEnvelope(args)).output;
         if (name === 'subagent_list')
@@ -1722,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,
         });
@@ -1981,6 +1961,9 @@ exports.agentKernelRunnerInternals = {
     TOOL_PROVISION_NAME,
     INITIAL_TOOL_SCHEMA_LIMIT,
     SUBAGENT_CORE_TOOL_NAMES,
+    TASK_CHECKLIST_CORE_TOOL_NAMES,
+    BASIC_INITIAL_TOOL_NAMES,
+    ALWAYS_AVAILABLE_AGENT_TOOL_NAMES,
 };
 function imagePathToDataUrl(imagePath) {
     if (!imagePath || !fs.existsSync(imagePath))

package/dist/core/config.js

@@ -850,7 +850,7 @@ function defaultConfig() {
             auto_archive_on_close: { _description: "Auto archive on close", _type: "boolean", value: true },
         },
         remote: {
-            touch_enabled: { _description: "Allow mobile devices to reach this Newmark instance over Tailscale", _type: "boolean", value: true },
+            touch_enabled: { _description: "Allow mobile devices to reach this Newmark instance on the same LAN / Tailscale network", _type: "boolean", value: true },
         },
         models: {
             providers: { _description: "LLM providers", _type: "array", value: [] },

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;