newmark-agent 0.3.11 → 0.4.0

package/dist/preload.js

@@ -12,6 +12,7 @@ contextBridge.exposeInMainWorld('api', {
     sendMessage: (message, target) => ipcRenderer.invoke('agent:send', message, target),
     enqueueGuide: (envelope) => ipcRenderer.invoke('agent:enqueueGuide', envelope),
     checkpointConversation: (request) => ipcRenderer.invoke('agent:checkpointConversation', request),
+    compressContext: (request) => ipcRenderer.invoke('agent:compressContext', request),
     rateAutoRoute: (request) => ipcRenderer.invoke('agent:rateAutoRoute', request),
     stopConversation: (request) => ipcRenderer.invoke('agent:stopConversation', request),
     setWorkRunExpanded: (request) => ipcRenderer.invoke('agent:setWorkRunExpanded', request),
@@ -32,12 +33,16 @@ contextBridge.exposeInMainWorld('api', {
     getConversationPlan: (conversationId) => ipcRenderer.invoke('agent:getConversationPlan', conversationId),
     updateConversationPlan: (plan, conversationId) => ipcRenderer.invoke('agent:updateConversationPlan', plan, conversationId),
     setConversationPinned: (id, pinned) => ipcRenderer.invoke('agent:setConversationPinned', id, pinned),
+    setConversationBranchCommunication: (target, enabled) => ipcRenderer.invoke('agent:setConversationBranchCommunication', target, enabled),
     renameConversation: (id, title) => ipcRenderer.invoke('agent:renameConversation', id, title),
     reorderConversations: (ids) => ipcRenderer.invoke('agent:reorderConversations', ids),
     browserRegisterGuest: (guestContentsId, target) => ipcRenderer.invoke('browser:registerGuest', guestContentsId, target),
     onBrowserEnsureGuest: (callback) => {
         ipcRenderer.on('browser:ensureGuest', (_event, target) => callback(target));
     },
+    onKeyboardCommand: (callback) => {
+        ipcRenderer.on('keyboard:command', (_event, payload) => callback(payload));
+    },
     browserControl: (request) => ipcRenderer.invoke('browser:control', request),
     computerUseState: (target) => ipcRenderer.invoke('agent:computerUseState', target),
     setComputerUseEnabled: (target, enabled) => ipcRenderer.invoke('agent:setComputerUseEnabled', target, enabled),
@@ -72,6 +77,10 @@ contextBridge.exposeInMainWorld('api', {
     readWorkspacePrompt: () => ipcRenderer.invoke('workspace:readPrompt'),
     saveWorkspacePrompt: (content) => ipcRenderer.invoke('workspace:savePrompt', content),
     editorComplete: (request) => ipcRenderer.invoke('agent:editorComplete', request),
+    editorCompleteCancel: () => ipcRenderer.invoke('agent:editorCompleteCancel'),
+    onEditorCompletionDelta: (callback) => {
+        ipcRenderer.on('agent:editorCompletionDelta', (_event, payload) => callback(payload));
+    },
     editorAssist: (request) => ipcRenderer.invoke('agent:editorAssist', request),
     filePathForFile: (file) => {
         try {
@@ -85,6 +94,7 @@ contextBridge.exposeInMainWorld('api', {
     selectFolder: () => ipcRenderer.invoke('dialog:selectFolder'),
     executeBash: (cmd, shell, cwd) => ipcRenderer.invoke('agent:executeBash', cmd, shell, cwd),
     openExternal: (path) => ipcRenderer.invoke('agent:openExternal', path),
+    openWebUrl: (url) => ipcRenderer.invoke('app:openWebUrl', url),
     selectWorkspace: (id) => ipcRenderer.invoke('agent:selectWorkspace', id),
     createWorkspace: (name) => ipcRenderer.invoke('agent:createWorkspace', name),
     createExternalWorkspace: (name, dirPath) => ipcRenderer.invoke('agent:createExternalWorkspace', name, dirPath),
@@ -113,6 +123,7 @@ contextBridge.exposeInMainWorld('api', {
     removeSkill: (name) => ipcRenderer.invoke('skills:remove', name),
     refreshSkills: () => ipcRenderer.invoke('skills:refresh'),
     listMcpServers: () => ipcRenderer.invoke('mcp:list'),
+    discoverDshCompatibility: () => ipcRenderer.invoke('dsh:discover'),
     upsertMcpServer: (input) => ipcRenderer.invoke('mcp:upsert', input),
     setMcpServerEnabled: (id, enabled) => ipcRenderer.invoke('mcp:setEnabled', id, enabled),
     removeMcpServer: (id) => ipcRenderer.invoke('mcp:remove', id),
@@ -173,6 +184,12 @@ contextBridge.exposeInMainWorld('api', {
     onAgentWorkEvent: (callback) => {
         ipcRenderer.on('agent:workEvent', callback);
     },
+    onWorkspaceChanged: (callback) => {
+        ipcRenderer.on('workspace:changed', (_event, payload) => callback(payload));
+    },
+    removeWorkspaceChangedListener: () => {
+        ipcRenderer.removeAllListeners('workspace:changed');
+    },
     removeAgentWorkEventListener: () => {
         ipcRenderer.removeAllListeners('agent:workEvent');
     },

package/dist/providers/chat-completions.adapter.js

@@ -48,6 +48,10 @@ class ChatCompletionsAdapter {
         };
         if (request.reasoningEffort)
             body.reasoning_effort = request.reasoningEffort;
+        // 会话标识透传：仅当上层（支持 session_id 语义的 provider）显式填充时写进
+        // body，否则省略，避免严格 API 拒绝未知字段。
+        if (request.sessionId)
+            body.session_id = request.sessionId;
         const base = request.baseUrl.replace(/\/+$/, '');
         return {
             url: `${base}/chat/completions`,
@@ -90,17 +94,16 @@ class ChatCompletionsAdapter {
         }
         const decoder = new TextDecoder();
         let buffer = '';
-        let currentToolCall = null;
+        const toolCalls = new Map();
+        const toolCallOrder = [];
+        let syntheticToolIndex = 0;
+        let lastToolIndex = 0;
         let contentPolicyBlocked = false;
         let emittedContent = false;
         let emittedTool = false;
         try {
             while (true) {
-                if (signal.aborted)
-                    throw (0, provider_events_1.providerAbortError)(signal);
-                const readPromise = reader.read();
-                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Stream read timeout')), 30000));
-                const { done, value } = await Promise.race([readPromise, timeoutPromise]);
+                const { done, value } = await (0, provider_events_1.readProviderStreamChunk)(reader, signal);
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });
@@ -141,32 +144,51 @@ class ChatCompletionsAdapter {
                         emittedContent = true;
                         yield { type: 'text.delta', delta: textDelta };
                     }
-                    const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
-                    for (const raw of toolCalls) {
+                    const deltaToolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+                    for (const raw of deltaToolCalls) {
                         const tc = raw;
                         const fn = tc.function && typeof tc.function === 'object' ? tc.function : {};
-                        if (tc.id) {
-                            if (currentToolCall) {
-                                emittedTool = true;
-                                yield { type: 'tool_call.completed', id: currentToolCall.id, name: currentToolCall.name, arguments: currentToolCall.arguments };
-                            }
+                        const rawIndex = Number(tc.index);
+                        const index = Number.isInteger(rawIndex) && rawIndex >= 0
+                            ? rawIndex
+                            : (tc.id ? syntheticToolIndex++ : lastToolIndex);
+                        lastToolIndex = index;
+                        let currentToolCall = toolCalls.get(index);
+                        if (!currentToolCall && tc.id) {
                             currentToolCall = {
                                 id: String(tc.id || ''),
                                 name: (0, chat_messages_1.openAIToolName)(String(fn.name || '')),
-                                arguments: String(fn.arguments || ''),
+                                argumentParts: [],
                             };
+                            toolCalls.set(index, currentToolCall);
+                            toolCallOrder.push(index);
                             yield { type: 'tool_call.started', id: currentToolCall.id, name: currentToolCall.name };
                         }
-                        else if (fn.arguments && currentToolCall) {
-                            currentToolCall.arguments += String(fn.arguments);
-                            yield { type: 'tool_call.arguments.delta', id: currentToolCall.id, delta: String(fn.arguments) };
+                        if (currentToolCall && fn.name && !currentToolCall.name)
+                            currentToolCall.name = (0, chat_messages_1.openAIToolName)(String(fn.name));
+                        if (currentToolCall && fn.arguments !== undefined && fn.arguments !== null) {
+                            const argumentDelta = String(fn.arguments);
+                            if (argumentDelta) {
+                                currentToolCall.argumentParts.push(argumentDelta);
+                                yield { type: 'tool_call.arguments.delta', id: currentToolCall.id, delta: argumentDelta };
+                            }
                         }
                     }
                 }
             }
-            if (currentToolCall && currentToolCall.arguments) {
-                emittedTool = true;
-                yield { type: 'tool_call.completed', id: currentToolCall.id, name: currentToolCall.name, arguments: currentToolCall.arguments };
+            if (toolCallOrder.length) {
+                for (const index of toolCallOrder) {
+                    const currentToolCall = toolCalls.get(index);
+                    if (!currentToolCall)
+                        continue;
+                    emittedTool = true;
+                    yield {
+                        type: 'tool_call.completed',
+                        id: currentToolCall.id,
+                        name: currentToolCall.name,
+                        arguments: currentToolCall.argumentParts.join(''),
+                    };
+                }
             }
             else if (!emittedContent && !emittedTool && contentPolicyBlocked) {
                 yield { type: 'response.failed', error: '[Error] Content policy refusal (content_filter).' };

package/dist/providers/provider-adapter.d.ts

@@ -55,6 +55,9 @@ export interface NormalizedAgentRequest {
     reasoningEffort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     apiKey: string;
     baseUrl: string;
+    /** 可选的会话标识。仅当目标 provider 显式支持 session_id 语义的上下文缓存
+     *  时才由上层填充；adapter 在存在时透传，否则省略该字段（避免严格 API 拒绝未知字段）。 */
+    sessionId?: string;
 }
 export interface TokenEstimate {
     inputTokens: number;

package/dist/providers/provider-events.d.ts

@@ -12,6 +12,13 @@ export declare function defaultProviderTransport(request: SerializedProviderRequ
  * (`name === 'AbortError'`, preserves the abort reason when present).
  */
 export declare function providerAbortError(signal?: AbortSignal): Error;
+export declare function providerStreamTimeoutError(timeoutMs: number): Error;
+/**
+ * Read one SSE chunk with both user cancellation and an inactivity deadline.
+ * Cancelling the reader is important: rejecting the race alone leaves the
+ * provider socket alive and lets later requests accumulate behind it.
+ */
+export declare function readProviderStreamChunk(reader: ReadableStreamDefaultReader<Uint8Array>, signal: AbortSignal, timeoutMs?: number): Promise<ReadableStreamReadResult<Uint8Array>>;
 export declare function parseProviderSse(raw: string): Array<{
     event?: string;
     data: string;

package/dist/providers/provider-events.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultProviderTransport = defaultProviderTransport;
 exports.providerAbortError = providerAbortError;
+exports.providerStreamTimeoutError = providerStreamTimeoutError;
+exports.readProviderStreamChunk = readProviderStreamChunk;
 exports.parseProviderSse = parseProviderSse;
 exports.isContentPolicyBlocked = isContentPolicyBlocked;
 exports.normalizeProviderUsage = normalizeProviderUsage;
@@ -34,6 +36,48 @@ function providerAbortError(signal) {
         error.name = 'AbortError';
     return error;
 }
+function providerStreamTimeoutError(timeoutMs) {
+    const error = new Error('Stream read timeout');
+    error.name = 'TimeoutError';
+    error.message = `Stream read timeout after ${timeoutMs}ms`;
+    return error;
+}
+/**
+ * Read one SSE chunk with both user cancellation and an inactivity deadline.
+ * Cancelling the reader is important: rejecting the race alone leaves the
+ * provider socket alive and lets later requests accumulate behind it.
+ */
+async function readProviderStreamChunk(reader, signal, timeoutMs = 30_000) {
+    if (signal.aborted)
+        throw providerAbortError(signal);
+    let timer;
+    let onAbort;
+    const abortPromise = new Promise((_, reject) => {
+        onAbort = () => reject(providerAbortError(signal));
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+    const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(providerStreamTimeoutError(timeoutMs)), timeoutMs);
+    });
+    try {
+        return await Promise.race([reader.read(), abortPromise, timeoutPromise]);
+    }
+    catch (error) {
+        if (signal.aborted || (error instanceof Error && error.name === 'TimeoutError')) {
+            try {
+                await reader.cancel(error);
+            }
+            catch { }
+        }
+        throw error;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (onAbort)
+            signal.removeEventListener('abort', onAbort);
+    }
+}
 function parseProviderSse(raw) {
     const events = [];
     for (const block of String(raw || '').replace(/\r\n/g, '\n').split(/\n\n+/)) {

package/dist/providers/responses.adapter.js

@@ -132,9 +132,7 @@ class ResponsesAdapter {
         let streamError = '';
         try {
             while (true) {
-                if (signal.aborted)
-                    throw (0, provider_events_1.providerAbortError)(signal);
-                const { done, value } = await reader.read();
+                const { done, value } = await (0, provider_events_1.readProviderStreamChunk)(reader, signal);
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, '\n');

package/dist/toolchain/registry/tool-registry.d.ts

@@ -1,4 +1,4 @@
-import { ToolDescriptor, ToolIdempotency, RiskLevel } from '../../context/domain/types';
+import { ToolDescriptor, ToolIdempotency, RiskLevel, ToolExecuteFn, ToolConcurrencySafeFn, ToolRenderFn, ToolPresentationMetaFn, ToolFinalizeContentFn, ToolPresentCallFn, ToolPresentResultFn } from '../../context/domain/types';
 export interface ToolDescriptorInput {
     toolId: string;
     capabilityId: string;
@@ -15,6 +15,18 @@ export interface ToolDescriptorInput {
     supportedScopes?: string[];
     cacheGroup?: string;
     implementationHash?: string;
+    /** DSH ToolDefinition.execute：命令式功能实现引用（cordis 核功能承载）。 */
+    execute?: ToolExecuteFn;
+    /** DSH ToolDefinition.isConcurrencySafe：运行时并发分类。 */
+    isConcurrencySafe?: ToolConcurrencySafeFn;
+    /** DSH ToolOutputDefinition.render / presentationMeta。 */
+    render?: ToolRenderFn;
+    presentationMeta?: ToolPresentationMetaFn;
+    /** DSH ToolDefinition.finalizeContent / timeoutMs / presentCall / presentResult。 */
+    finalizeContent?: ToolFinalizeContentFn;
+    timeoutMs?: number;
+    presentCall?: ToolPresentCallFn;
+    presentResult?: ToolPresentResultFn;
 }
 /**
  * Tool Registry: the authoritative set of ToolDescriptors. Schemas are

package/dist/toolchain/registry/tool-registry.js

@@ -28,6 +28,14 @@ class ToolRegistry {
             implementationHash: input.implementationHash,
             cacheGroup: input.cacheGroup || `${input.namespace}.${input.name}`,
             enabled: true,
+            execute: input.execute,
+            isConcurrencySafe: input.isConcurrencySafe,
+            render: input.render,
+            presentationMeta: input.presentationMeta,
+            finalizeContent: input.finalizeContent,
+            timeoutMs: input.timeoutMs,
+            presentCall: input.presentCall,
+            presentResult: input.presentResult,
         };
         this.tools.set(input.toolId, descriptor);
         return descriptor;

package/dist/toolchain/registry-seeder.js

@@ -60,15 +60,28 @@ function inferRiskLevel(name, description, annotations) {
         return 'external';
     if (READ_TOOL_PATTERN.test(name))
         return 'read';
+    // DSH 读工具命名惯例（get_/list_/query_/inspect_/read_ 前缀）：这些动词本质只读，
+    // 避免被启发式误判为 write（例如 DSH 的 get_goal / cordis_inspect_list）。
+    if (/^(get_|list_|query_|inspect_|read_)/.test(name) && !/_(create|update|set|write|delete|remove|run|execute|send|save|push|edit|toggle|define|stop|start)$/.test(name))
+        return 'read';
     return 'write';
 }
 function inferIdempotency(name) {
-    if (/^(bash|computer_use|browser_use|run|exec|execute|task)$/.test(name))
+    // shell 命令工具每次执行都可能改变外部状态，本质非幂等（DSH pwsh/bash/terminal 等）。
+    if (/^(bash|pwsh|powershell|cmd|shell|terminal|computer_use|browser_use|run|exec|execute|task)$/.test(name))
         return 'non_idempotent';
     if (/^(write|edit|append|send|save|create|update|set|put|register|patch)/.test(name))
         return 'conditionally_idempotent';
     return undefined;
 }
+/** 从真实 tool description 提取简洁 shortDescription（首句或截断），保 cordis 核可读。 */
+function compactDescription(description, fallback) {
+    const clean = String(description || '').replace(/\s+/g, ' ').trim();
+    if (!clean)
+        return fallback;
+    const firstSentence = clean.split(/(?<=[.!?])\s+/)[0] || clean;
+    return firstSentence.slice(0, 120);
+}
 function resolveDefinition(definition) {
     if (!definition || typeof definition !== 'object')
         return null;
@@ -82,11 +95,35 @@ function resolveDefinition(definition) {
         };
     }
     if (typeof record.name === 'string') {
+        // 兼容两种字段名：Newmark 的 SeededToolDefinition 用 inputSchema，
+        // DSH 的 ToolSchema 用 parameters（dsh-llm ToolSchema：{name, description, parameters}）。
+        const rawParameters = record.inputSchema ?? record.parameters;
+        const rawExecute = record.execute;
+        const rawConcurrencySafe = record.isConcurrencySafe;
+        // DSH ToolOutputDefinition 是嵌套对象 {schema, render, presentationMeta}；
+        // outputSchema 从 output.schema 提取。
+        const rawOutput = record.output;
+        const outputSchema = record.outputSchema ?? rawOutput?.schema;
+        const render = rawOutput?.render;
+        const presentationMeta = rawOutput?.presentationMeta;
+        const finalizeContent = record.finalizeContent;
+        const timeoutMs = record.timeoutMs;
+        const presentCall = record.presentCall;
+        const presentResult = record.presentResult;
         return {
             name: record.name,
             description: typeof record.description === 'string' ? record.description : '',
-            parameters: record.inputSchema,
+            parameters: rawParameters,
+            outputSchema,
             annotations: record.annotations,
+            execute: typeof rawExecute === 'function' ? rawExecute : undefined,
+            isConcurrencySafe: typeof rawConcurrencySafe === 'function' ? rawConcurrencySafe : undefined,
+            render: typeof render === 'function' ? render : undefined,
+            presentationMeta: typeof presentationMeta === 'function' ? presentationMeta : undefined,
+            finalizeContent: typeof finalizeContent === 'function' ? finalizeContent : undefined,
+            timeoutMs: typeof timeoutMs === 'number' ? timeoutMs : undefined,
+            presentCall: typeof presentCall === 'function' ? presentCall : undefined,
+            presentResult: typeof presentResult === 'function' ? presentResult : undefined,
         };
     }
     return null;
@@ -135,7 +172,7 @@ function seedToolchainFromDefinitions(definitions, options) {
         if (riskLevel === 'destructive' || (riskLevel === 'external' && entry.input.riskLevel !== 'destructive')) {
             entry.input.riskLevel = riskLevel;
         }
-        entry.resolved.push({ name: definition.name, riskLevel, parameters: definition.parameters });
+        entry.resolved.push({ ...definition, riskLevel, domain });
     }
     for (const [domain, entry] of byDomain) {
         const requiredPermissions = entry.input.riskLevel === 'destructive'
@@ -166,13 +203,22 @@ function seedToolchainFromDefinitions(definitions, options) {
                 namespace,
                 name: tool.name,
                 version,
-                shortDescription: tool.name,
-                fullDescription: `${tool.name} (${domain})`,
+                shortDescription: compactDescription(tool.description, tool.name),
+                fullDescription: tool.description && tool.description.trim() ? tool.description : `${tool.name} (${domain})`,
                 inputSchema: tool.parameters ?? { type: 'object', properties: {}, required: [] },
+                outputSchema: tool.outputSchema,
                 riskLevel: tool.riskLevel,
                 idempotency,
                 requiredPermissions: required,
                 implementationHash: (0, deterministic_1.sha256)(tool.name),
+                execute: tool.execute,
+                isConcurrencySafe: tool.isConcurrencySafe,
+                render: tool.render,
+                presentationMeta: tool.presentationMeta,
+                finalizeContent: tool.finalizeContent,
+                timeoutMs: tool.timeoutMs,
+                presentCall: tool.presentCall,
+                presentResult: tool.presentResult,
             };
             core.registry.register(input);
             toolIds.push(tool.name);

package/dist/tools/index.js

@@ -349,9 +349,9 @@ class ToolExecutor {
             t('subagent_result', 'Return the persisted transcript, mailbox summary, status, and latest result for a peer agent. Target by exact id (preferred) or name.', { id: { type: 'string', description: 'Exact peer id from subagent_list.' }, name: { type: 'string', description: 'Convenience peer name.' } }, []),
             t('subagent_close', 'Close a same-conversation peer. Root can close any peer; a peer can close only itself. Target by exact id (preferred) or name.', { id: { type: 'string', description: 'Exact peer id from subagent_list.' }, name: { type: 'string', description: 'Convenience peer name.' } }, []),
             t('linked_plan', 'Read or update the current conversation linked Markdown plan. Update requires the current expected_revision.', { action: { type: 'string', enum: ['get', 'update'] }, markdown: { type: 'string' }, expected_revision: { type: 'number' } }, ['action']),
-            t('build_history_query', 'Read the concrete public work details of one historical Build Block. The prompt already exposes user input, final summary, and completion status; call this read-only tool only when the user asks what specifically happened. Select by newest-to-oldest history_index, or by run_id returned from an earlier query.', { history_index: { type: 'number', minimum: 1, description: '1-based historical Build Block index from the request ledger; 1 is the newest previous task.' }, run_id: { type: 'string', description: 'Exact run id returned by an earlier build_history_query result.' }, max_events: { type: 'number', minimum: 1, maximum: 200, description: 'Maximum trailing public work events; defaults to 80.' } }, []),
+            t('build_history_query', 'Read the concrete public work details of one historical Build Block. The prompt already exposes user input, final summary, and completion status; call this read-only tool only when the user asks what specifically happened. Select by newest-to-oldest history_index, or by run_id returned from an earlier query. Every activity/guide content is bounded to max_chars (default 2000) to keep the read lean and cache-friendly.', { history_index: { type: 'number', minimum: 1, description: '1-based historical Build Block index from the request ledger; 1 is the newest previous task.' }, run_id: { type: 'string', description: 'Exact run id returned by an earlier build_history_query result.' }, max_events: { type: 'number', minimum: 1, maximum: 200, description: 'Maximum trailing public work events; defaults to 80.' }, max_chars: { type: 'number', minimum: 100, maximum: 4000, description: 'Per-event/per-guide content character bound; defaults to 2000.' } }, []),
             t('context_compress', 'Actively compress the LLM context history for this conversation. This collapses older history entries into a concise summary while preserving the recent tail, which reduces context tokens and cost. IMPORTANT: it affects only the LLM context (what the model sees); the displayed conversation history shown to the user is never altered. Call this when the conversation is long, token pressure is high, or you judge that older turns are no longer needed in full. Idempotent and safe: repeated calls produce incremental summaries.', { keep_recent: { type: 'number', minimum: 2, maximum: 60, description: 'Recent message count to keep uncompressed at the tail. Defaults to the configured keep_recent_messages.' }, force: { type: 'boolean', description: 'Compress even if the context is not yet over the automatic threshold. Defaults to false.' } }, []),
-            t('context_history_manage', 'Manage the LLM context history for this conversation without affecting the displayed conversation history. This is the active context-management surface. The hot cache stays bounded; evicted folded segments remain in a conversation-isolated append-only cold archive and are loaded only by explicit search/read/restore calls. Actions: list returns a bounded index of current context entries; remove deletes one current entry; summarize folds a contiguous current range; restore reinserts a folded segment when its summary marker is still present; search finds matching hot or archived segments; read returns one bounded segment without injecting the whole archive; status reports budgets, hot cache, cold archive, and the protected recent zone. The recent context tail and last user message are protected from remove/summarize unless dangerous is true.', {
+            t('context_history_manage', 'Manage the LLM context history for this conversation without affecting the displayed conversation history. This is the active context-management surface. The hot cache stays bounded; evicted folded segments remain in a conversation-isolated append-only cold archive and are loaded only by explicit search/read/restore calls. Actions: list returns a bounded index of current context entries; remove declares one long-term entry for unload (see below); summarize folds a contiguous current range; restore reinserts a folded segment when its summary marker is still present; search finds matching hot or archived segments; read returns one bounded segment without injecting the whole archive; status reports budgets, hot cache, cold archive, the protected recent zone, and pending removals. The recent context tail and last user message are protected from remove/summarize unless dangerous is true. For cache-optimization, remove ONLY targets long-term history (never the protected recent tail or last user message) and does NOT unload immediately: the declared entry stays in context for the rest of the current Build Block so the provider prefix cache stays stable, then is physically removed when the Block ends — applying to subsequent Blocks only.', {
                 action: { type: 'string', enum: ['list', 'remove', 'summarize', 'restore', 'search', 'read', 'status'], description: 'list current entries; remove one; summarize a range; restore by restore_id; search hot/cold folded segments; read one bounded folded segment; status report context budgets and storage.' },
                 position: { type: 'number', minimum: 0, description: '0-based context entry index for remove, or the start of the range for summarize.' },
                 to: { type: 'number', minimum: 0, description: '0-based inclusive end of the range for summarize. Defaults to position.' },
@@ -363,6 +363,15 @@ class ToolExecutor {
                 max_chars: { type: 'number', minimum: 1000, maximum: 60000, description: 'Maximum message-content characters returned by read (default 12000).' },
                 dangerous: { type: 'boolean', description: 'Set true to override the protected recent-message zone and allow removing/summarizing entries that include the recent context tail or the last user message.' },
             }, ['action']),
+            t('branch_list', 'List all branches in this conversation and their mailbox/activity status. Only available when the conversation was created with "允许分支交流" (allow branch communication) enabled. Returns each branch id, active flag, source message index, message/history/workRun counts, and unread mailbox counts so you can decide who to message or read next.', {}, []),
+            t('branch_send', 'Send a message to another branch in this conversation. Only available when branch communication is enabled. The message is persisted to the target branch mailbox and becomes visible to that branch on its next branch_read. Use this to coordinate work across concurrently running branches. A branch cannot message itself.', { to_branch: { type: 'string', description: 'Target branch id (from branch_list).' }, message: { type: 'string', description: 'Message body to deliver.' }, kind: { type: 'string', enum: ['message', 'directive', 'result'], description: 'Message kind; defaults to message.' }, correlation_id: { type: 'string', description: 'Optional correlation id for reply tracking.' }, reply_to: { type: 'string', description: 'Optional message id this message replies to.' } }, ['to_branch', 'message']),
+            t('branch_read', 'Read inbound messages and recent activity from another branch in this conversation. Only available when branch communication is enabled. Marks inbound messages read. Returns the branch metadata, inbound messages, and recent Build Block activity (final results and recent events).', { branch: { type: 'string', description: 'Branch id to read (from branch_list).' }, max_chars: { type: 'number', minimum: 100, maximum: 16000, description: 'Maximum characters for final-result text; defaults to 8000.' } }, ['branch']),
+            t('branch_create', 'Create a new conversation branch at a historical block position (a user message index) with a new initial instruction. Only available when branch communication is enabled. The new branch becomes an additional running branch. Use this to spin off alternative work from a past point without disturbing existing branches.', { message_index: { type: 'number', minimum: 0, description: '0-based index of a user message in the conversation history (the historical block position to branch from).' }, prompt: { type: 'string', description: 'The new branch initial instruction (becomes the branch user message).' }, message_id: { type: 'string', description: 'Optional exact message id to anchor the branch target.' }, guide_id: { type: 'string', description: 'Optional guide id to anchor the branch target.' } }, ['message_index', 'prompt']),
+            t('compress_tool_result', 'Compress ONE oversized tool result into a concise, format-preserving summary using the model, instead of hard truncation. Pass the artifact_id returned inline by an oversized tool result (the full raw content stays out of context, on disk). Use this when a read/grep/bash result reported an oversized_tool_result marker and you want to recover its structure (JSON arrays, table rows, code blocks, identifiers, error strings) as a compact summary. This runs an isolated compression call whose system prefix does not touch the conversation prompt cache, so it does not disturb cache hit rate.', { artifact_id: { type: 'string', description: 'The artifact_id from the oversized_tool_result marker returned inline by an oversized tool result.' }, content: { type: 'string', description: 'Optional fallback: a SHORT raw result text to compress directly when no artifact_id exists.' }, format_hint: { type: 'string', description: 'Optional description of the structure to preserve verbatim (e.g. "keep JSON arrays and file paths", "keep table columns and error strings").' } }, []),
+            t('background_tool', 'Run a tool call in the background WITHOUT blocking the conversation turn. Pass the target tool name and its arguments; this tool returns a background_id IMMEDIATELY, and the real tool keeps running in the background. The result is persisted and can be retrieved later with read_tool_result. Use this for long-running or non-critical tools (bash, web_fetch, long read/grep) so the conversation continues without waiting. The background result stays OUT of context until you explicitly read it, preserving prompt-cache hit rate. Orchestration/flow/subagent/question tools cannot be backgrounded.', { tool: { type: 'string', description: 'The tool name to run in the background (e.g. bash, web_fetch, read, grep).' }, args: { type: 'object', description: 'The arguments object for the target tool, matching its normal schema.' } }, ['tool']),
+            t('read_tool_result', 'Read the result of a background tool. Pass the background_id returned by background_tool. When status is running, returns a running marker; when done, returns the persisted result (optionally release it from storage after reading); when error, returns the failure. Background results are released from storage only when you set release=true.', { background_id: { type: 'string', description: 'The background_id returned by background_tool.' }, release: { type: 'boolean', description: 'Set true to release the persisted result from storage after reading it.' } }, ['background_id']),
+            t('goal_manage', 'Actively manage the persistent Goal state for this conversation. You may enter Goal mode, update (edit) its objective, mark it complete, or exit Goal mode yourself. Call this when the user asks you to pursue a persistent objective, when the objective changes, when you have verified the objective is genuinely achieved, or when you judge the Goal is no longer needed and should be cleared. This is the agent-side state control that mirrors the GUI goal panel controls. enter/update require objective; complete marks the objective verified and exits Goal mode; exit clears the Goal (and returns to Build mode) without claiming completion.', { action: { type: 'string', enum: ['enter', 'update', 'complete', 'exit'], description: 'enter=enter Goal mode and set the objective; update=edit the objective (records a change); complete=mark the objective verified-achieved and exit Goal mode; exit=clear the Goal and return to Build mode without claiming completion.' }, objective: { type: 'string', description: 'The Goal objective text. Required for enter and update.' }, reason: { type: 'string', description: 'Optional one-line reason for the state change, recorded for audit.' } }, ['action']),
+            t('conversation_rename', 'Rename the CURRENT conversation to a concise, descriptive title you choose. On the FIRST Build Block of a NEW conversation the runtime asks you to call this once so the conversation list shows a meaningful name instead of an auto-generated one. Keep the title short (a few words) and cache-friendly: a concrete noun phrase describing the task, never a sentence or quoted prompt.', { title: { type: 'string', description: 'The new conversation title (a short noun phrase, e.g. "Fix TUI color leak", "Add goal_manage tool").' } }, ['title']),
             t('question', 'Ask user a multiple-choice question', { questions: { type: 'array' } }, ['questions']),
             t('skill_download', 'Download a skill', { name: { type: 'string' }, source: { type: 'string' } }, ['name', 'source']),
             t('skill', 'Search enabled skill metadata or load one exact skill body on demand. Use query when unsure, then name to load the selected skill.', { query: { type: 'string', maxLength: 200 }, name: { type: 'string', maxLength: 200 } }, []),

package/dist/tools/nativeTools.js

@@ -38,10 +38,14 @@ exports.NATIVE_TOOL_CATALOG = [
     { name: 'subagent_send', label: 'Subagent send', description: 'Persist a message to a peer mailbox.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'subagent_result', label: 'Subagent result', description: 'Read peer transcript and result.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'subagent_close', label: 'Subagent close', description: 'Close a same-conversation peer agent.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
+    { name: 'branch_list', label: 'Branch list', description: 'List all conversation branches and their mailbox/activity status. Only available when branch communication is enabled.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
+    { name: 'branch_send', label: 'Branch send', description: 'Send a message to another conversation branch. Only available when branch communication is enabled.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
+    { name: 'branch_read', label: 'Branch read', description: 'Read inbound messages and recent activity from another conversation branch. Only available when branch communication is enabled.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
+    { name: 'branch_create', label: 'Branch create', description: 'Create a new conversation branch at a historical block position. Only available when branch communication is enabled.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'linked_plan', label: 'Linked plan', description: 'Read or conservatively update the conversation-linked Markdown plan.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'build_history_query', label: 'Build history query', description: 'Read concrete public work details for one historical Build Block.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'context_compress', label: 'Context compress', description: 'Actively compress the LLM context history, leaving the displayed conversation history unchanged.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
-    { name: 'context_history_manage', label: 'Context history manage', description: 'Inspect, search, restore, or fold LLM context history without touching the displayed conversation history.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
+    { name: 'context_history_manage', label: 'Context history manage', description: 'Inspect, search, restore, fold, or unload LLM context history without touching the displayed conversation history. Unload (remove) targets long-term entries only and takes effect after the current Build Block, for subsequent Blocks only.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'question', label: 'Ask question', description: 'Ask the user for structured option feedback.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'skill_download', label: 'Skill download', description: 'Download and install a skill.', category: 'agent', defaultEnabled: true },
     { name: 'skill', label: 'Skill', description: 'Search enabled skill metadata or load one skill body on demand.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },

package/dist/tui/src/adapters/core-runtime-adapter.js

@@ -93,6 +93,41 @@ function samePath(left, right) {
   return normalize(left) === normalize(right);
 }
 
+function isPathInside(parent, child) {
+  try {
+    const relative = path.relative(path.resolve(parent), path.resolve(child));
+    return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative));
+  } catch {
+    return false;
+  }
+}
+
+function isProtectedInstallPath(candidate) {
+  if (process.platform !== "win32") return false;
+  const protectedRoots = [
+    process.env.ProgramFiles,
+    process.env["ProgramFiles(x86)"],
+    process.env.ProgramW6432
+  ].filter(Boolean);
+  return protectedRoots.some((root) => isPathInside(root, candidate));
+}
+
+function safeWorkspacePath(root, candidate) {
+  const resolvedRoot = path.resolve(root);
+  const resolvedCandidate = path.resolve(candidate || resolvedRoot);
+  const executableRoot = path.dirname(process.execPath);
+  // A packaged TUI launched from its installation directory must never turn
+  // that directory into an external workspace. The runtime root owns the
+  // default internal workspace in this case.
+  if (
+    samePath(resolvedCandidate, resolvedRoot)
+    || isPathInside(resolvedRoot, resolvedCandidate)
+    || isPathInside(executableRoot, resolvedCandidate)
+    || isProtectedInstallPath(resolvedCandidate)
+  ) return resolvedRoot;
+  return resolvedCandidate;
+}
+
 function mergeProviderConfig(currentProviders, incomingProviders) {
   return (incomingProviders || []).map((incoming) => {
     const current = (currentProviders || []).find((provider) => provider.id === incoming.id);
@@ -120,7 +155,7 @@ function createCoreRuntimeAdapter(options = {}) {
   const { FlowEngine } = require(path.join(desktopDist, "core", "flow.js"));
   const installUpdate = require(path.join(desktopDist, "core", "installUpdate.js"));
   const root = path.resolve(options.root || path.join(os.homedir(), ".Newmark"));
-  const workspacePath = path.resolve(options.workspacePath || process.cwd());
+  const workspacePath = safeWorkspacePath(root, options.workspacePath || process.cwd());
   ensureRuntimeRoot(root, configModule);
 
   const agent = new Agent(root);
@@ -128,7 +163,9 @@ function createCoreRuntimeAdapter(options = {}) {
     .find((workspace) => samePath(workspace.path, workspacePath));
   const selectedWorkspace = knownWorkspace
     ? agent.selectWorkspaceFromStorage(knownWorkspace.id)
-    : agent.addExternalWorkspace(workspacePath);
+    : samePath(workspacePath, root)
+      ? (agent.workspace.current || agent.createInternalWorkspace())
+      : agent.addExternalWorkspace(workspacePath);
   if (!selectedWorkspace) {
     throw new Error(
       `The current folder cannot be registered as a Newmark workspace: ${workspacePath}. ` +
@@ -454,4 +491,4 @@ function createCoreRuntimeAdapter(options = {}) {
   };
 }
 
-module.exports = { createCoreRuntimeAdapter, mergeProviderConfig, resolveDesktopDist, samePath, sanitizeProviders };
+module.exports = { createCoreRuntimeAdapter, mergeProviderConfig, resolveDesktopDist, samePath, safeWorkspacePath, sanitizeProviders };