newmark-agent 0.5.7 → 0.5.9

package/dist/llm/provider.js

@@ -43,9 +43,6 @@ const child_process_1 = require("child_process");
 const agentKernelDiagnostics_1 = require("../core/agentKernelDiagnostics");
 const chat_messages_1 = require("../providers/chat-messages");
 const providers_1 = require("../providers");
-// Keep provider requests below the release-harness/user-visible command
-// deadline. A provider that does not answer must produce one bounded error;
-// it must not restart the same request through every Windows transport.
 // Provider responses are intentionally unbounded. User cancellation, transport
 // errors, and tool-specific limits remain the only automatic stop conditions.
 const DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 0;
@@ -939,7 +936,7 @@ class LLMProvider {
      * `provider_adapters_v2` context flag. Request serialization and SSE
      * normalization are delegated to the shared provider adapters while the
      * transport orchestration (loopback node-http, fetch -> node-http fallback,
-     * 120s/30s timeouts) and the 4xx Chat -> Responses downgrade stay here.
+     * cancellation-only streaming and the 4xx Chat -> Responses downgrade) stay here.
      * The emitted request body and StreamToken stream are byte-equivalent to
      * the legacy inlined path.
      */
@@ -1082,9 +1079,9 @@ class LLMProvider {
     }
     /**
      * Loopback-aware transport injected into adapter `execute`. Streaming
-     * requests retain the fetch-to-node fallback for transport failures, while
-     * a local deadline is returned directly so one request cannot become a
-     * second Windows fallback request.
+     * requests retain the fetch-to-node fallback for transport failures. They
+     * have no response deadline; only caller cancellation or a concrete
+     * transport/provider failure may end the request.
      */
     buildProviderAdapterTransport() {
         return async (request, signal) => {
@@ -1096,7 +1093,9 @@ class LLMProvider {
                     forwardAbort();
                 else
                     signal?.addEventListener('abort', forwardAbort, { once: true });
-                const effectiveTimeout = this.effectiveRequestTimeout(120000);
+                // Streaming provider responses are intentionally unbounded. Only
+                // caller cancellation or an explicit provider failure may end them.
+                const effectiveTimeout = 0;
                 const timer = effectiveTimeout > 0
                     ? setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout)
                     : undefined;
@@ -1247,7 +1246,9 @@ class LLMProvider {
             forwardAbort();
         else
             signal?.addEventListener('abort', forwardAbort, { once: true });
-        const effectiveTimeout = this.effectiveRequestTimeout(120000);
+        // Streaming provider responses are intentionally unbounded. Do not turn
+        // silence into an empty-response failure.
+        const effectiveTimeout = 0;
         const timeout = effectiveTimeout > 0
             ? setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout)
             : undefined;
@@ -1285,10 +1286,14 @@ class LLMProvider {
             }
             const decoder = new TextDecoder();
             let buffer = '';
-            let currentToolCall = null;
+            const toolCalls = new Map();
+            const toolCallOrder = [];
+            let syntheticToolIndex = 0;
+            let lastToolIndex = 0;
             let currentReasoningContent = '';
             let contentPolicyBlocked = false;
             let emittedContent = false;
+            let explicitCompletion = false;
             const streamSignal = signal || new AbortController().signal;
             while (true) {
                 const { done, value } = await (0, providers_1.readProviderStreamChunk)(reader, streamSignal);
@@ -1302,8 +1307,10 @@ class LLMProvider {
                     if (!trimmed.startsWith('data: '))
                         continue;
                     const data = trimmed.slice(6);
-                    if (data === '[DONE]')
+                    if (data === '[DONE]') {
+                        explicitCompletion = true;
                         continue;
+                    }
                     try {
                         const json = JSON.parse(data);
                         if (json.usage)
@@ -1324,27 +1331,54 @@ class LLMProvider {
                         }
                         if (delta.tool_calls) {
                             for (const tc of delta.tool_calls) {
-                                if (tc.id) {
-                                    if (currentToolCall) {
-                                        yield { type: 'tool_call', text: '', toolCall: currentToolCall, reasoningContent: currentReasoningContent || undefined };
-                                    }
-                                    currentToolCall = { id: tc.id, name: tc.function?.name || '', arguments: tc.function?.arguments || '' };
-                                }
-                                else if (tc.function?.arguments && currentToolCall) {
-                                    currentToolCall.arguments += tc.function.arguments;
+                                const rawIndex = Number(tc.index);
+                                const index = Number.isInteger(rawIndex) && rawIndex >= 0
+                                    ? rawIndex
+                                    : (tc.id ? syntheticToolIndex++ : lastToolIndex);
+                                lastToolIndex = index;
+                                let call = toolCalls.get(index);
+                                if (!call && (tc.id || tc.function?.name)) {
+                                    call = { id: tc.id || '', name: tc.function?.name || '', argumentParts: [] };
+                                    toolCalls.set(index, call);
+                                    toolCallOrder.push(index);
                                 }
+                                if (!call)
+                                    continue;
+                                if (tc.id && !call.id)
+                                    call.id = tc.id;
+                                if (tc.function?.name && !call.name)
+                                    call.name = tc.function.name;
+                                if (tc.function?.arguments)
+                                    call.argumentParts.push(tc.function.arguments);
                             }
                         }
                     }
                     catch { /* skip malformed JSON */ }
                 }
             }
-            if (currentToolCall && currentToolCall.arguments) {
-                yield { type: 'tool_call', text: '', toolCall: currentToolCall, reasoningContent: currentReasoningContent || undefined };
+            if (toolCallOrder.length) {
+                for (const index of toolCallOrder) {
+                    const call = toolCalls.get(index);
+                    if (!call)
+                        continue;
+                    yield {
+                        type: 'tool_call',
+                        text: '',
+                        toolCall: {
+                            id: call.id,
+                            name: call.name,
+                            arguments: (0, providers_1.assembleCompatibleToolArguments)(call.argumentParts),
+                        },
+                        reasoningContent: currentReasoningContent || undefined,
+                    };
+                }
             }
             else if (!emittedContent && contentPolicyBlocked) {
                 yield { type: 'text', text: '[Error] Content policy refusal (content_filter).' };
             }
+            else if (!explicitCompletion && !emittedContent && !currentReasoningContent) {
+                yield { type: 'text', text: '[LLM Error] GitHub Models stream ended before an explicit completion.' };
+            }
         }
         finally {
             reader?.releaseLock();

package/dist/main.js

@@ -77,6 +77,7 @@ const compat_1 = require("./core/compat");
 const dshCompatibility_1 = require("./core/dshCompatibility");
 const mcpManager_1 = require("./core/mcpManager");
 const workEventCoalescer_1 = require("./core/workEventCoalescer");
+const terminalOutputBuffer_1 = require("./core/terminalOutputBuffer");
 const cli_help_1 = require("./cli-help");
 const APP_NAME = 'Newmark Agent';
 const APP_ID = 'ai.newmark.agent';
@@ -4451,10 +4452,16 @@ else {
                 }
             });
             const ptySessions = new Map();
-            const sendTerminalData = (sessionId, session, text) => {
-                session.buffer = `${session.buffer}${text}`.slice(-256 * 1024);
+            const terminalOutput = new terminalOutputBuffer_1.TerminalOutputBuffer((sessionId, text) => {
+                const session = ptySessions.get(sessionId);
+                if (session)
+                    session.buffer = terminalOutput.history(sessionId);
                 if (mainWindow && !mainWindow.isDestroyed())
                     mainWindow.webContents.send('pty:data', sessionId, text);
+            });
+            const sendTerminalData = (sessionId, session, text) => {
+                terminalOutput.push(sessionId, text);
+                session.buffer = terminalOutput.history(sessionId);
             };
             electron_1.ipcMain.handle('pty:spawn', async (_event, shellId) => {
                 const sessionId = (0, crypto_1.randomUUID)().slice(0, 8);
@@ -4476,7 +4483,9 @@ else {
                 ptySessions.set(sessionId, session);
                 proc.onData(text => sendTerminalData(sessionId, session, text));
                 proc.onExit(event => {
+                    terminalOutput.flush(sessionId);
                     ptySessions.delete(sessionId);
+                    terminalOutput.close(sessionId);
                     if (mainWindow && !mainWindow.isDestroyed()) {
                         mainWindow.webContents.send('pty:exit', sessionId, event.exitCode);
                     }
@@ -4534,7 +4543,7 @@ else {
                 const session = ptySessions.get(sessionId);
                 if (!session)
                     return { buffer: '' };
-                return { buffer: session.buffer };
+                return { buffer: terminalOutput.history(sessionId) || session.buffer };
             });
             const terminalOwnerFor = (conversationId, actorId) => (0, terminalTakeover_1.normalizeTerminalTakeoverOwner)({
                 backend: wslBackendEnabled() ? 'wsl' : (process.platform === 'win32' ? 'windows' : process.platform),

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

@@ -105,6 +105,8 @@ class ChatCompletionsAdapter {
         let contentPolicyBlocked = false;
         let emittedContent = false;
         let emittedTool = false;
+        let emittedReasoning = false;
+        let explicitCompletion = false;
         try {
             while (true) {
                 const { done, value } = await (0, provider_events_1.readProviderStreamChunk)(reader, signal);
@@ -118,8 +120,10 @@ class ChatCompletionsAdapter {
                     if (!trimmed.startsWith('data: '))
                         continue;
                     const data = trimmed.slice(6);
-                    if (data === '[DONE]')
+                    if (data === '[DONE]') {
+                        explicitCompletion = true;
                         continue;
+                    }
                     let json;
                     try {
                         json = JSON.parse(data);
@@ -135,13 +139,18 @@ class ChatCompletionsAdapter {
                     if ((0, provider_events_1.isContentPolicyBlocked)(json))
                         contentPolicyBlocked = true;
                     const choices = Array.isArray(json.choices) ? json.choices : [];
-                    const delta = choices[0]?.delta;
+                    const choice = choices[0];
+                    if (choice?.finish_reason !== undefined && choice.finish_reason !== null)
+                        explicitCompletion = true;
+                    const delta = choice?.delta;
                     if (!delta)
                         continue;
                     if (delta.reasoning_content) {
                         const reasoning = this.extractText(delta.reasoning_content);
-                        if (reasoning)
+                        if (reasoning) {
+                            emittedReasoning = true;
                             yield { type: 'reasoning.summary.delta', delta: reasoning };
+                        }
                     }
                     const textDelta = this.extractText(delta.content);
                     if (textDelta) {
@@ -190,7 +199,7 @@ class ChatCompletionsAdapter {
                         type: 'tool_call.completed',
                         id: currentToolCall.id,
                         name: currentToolCall.name,
-                        arguments: currentToolCall.argumentParts.join(''),
+                        arguments: (0, provider_events_1.assembleCompatibleToolArguments)(currentToolCall.argumentParts),
                     };
                 }
             }
@@ -198,6 +207,10 @@ class ChatCompletionsAdapter {
                 yield { type: 'response.failed', error: '[Error] Content policy refusal (content_filter).' };
                 return;
             }
+            if (!explicitCompletion && !emittedContent && !emittedTool && !emittedReasoning) {
+                yield { type: 'response.failed', error: '[LLM Error] Chat stream ended before an explicit completion.' };
+                return;
+            }
             yield { type: 'response.completed' };
         }
         finally {

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

@@ -29,6 +29,13 @@ export declare function parseProviderSse(raw: string): Array<{
     event?: string;
     data: string;
 }>;
+/**
+ * Compatible gateways may stream function arguments as JSON deltas or repeat
+ * a cumulative snapshot on every SSE frame. Keep the normal incremental form
+ * when it parses, then fall back to snapshot folding. Returning malformed
+ * concatenated snapshots would erase the model's correction at tool parsing.
+ */
+export declare function assembleCompatibleToolArguments(parts: string[]): string;
 /**
  * Detect content-policy refusals across the provider failure shapes.
  * Mirrors `LLMProvider.contentPolicyBlocked` semantics exactly so the

package/dist/providers/provider-events.js

@@ -5,6 +5,7 @@ exports.providerAbortError = providerAbortError;
 exports.providerStreamTimeoutError = providerStreamTimeoutError;
 exports.readProviderStreamChunk = readProviderStreamChunk;
 exports.parseProviderSse = parseProviderSse;
+exports.assembleCompatibleToolArguments = assembleCompatibleToolArguments;
 exports.isContentPolicyBlocked = isContentPolicyBlocked;
 exports.normalizeProviderUsage = normalizeProviderUsage;
 exports.estimateRequestTokens = estimateRequestTokens;
@@ -105,6 +106,45 @@ function parseProviderSse(raw) {
     }
     return events;
 }
+/**
+ * Compatible gateways may stream function arguments as JSON deltas or repeat
+ * a cumulative snapshot on every SSE frame. Keep the normal incremental form
+ * when it parses, then fall back to snapshot folding. Returning malformed
+ * concatenated snapshots would erase the model's correction at tool parsing.
+ */
+function assembleCompatibleToolArguments(parts) {
+    const nonEmpty = (parts || []).map(String).filter(part => part && part !== 'null');
+    if (!nonEmpty.length)
+        return '{}';
+    const isJsonObject = (value) => {
+        try {
+            const parsed = JSON.parse(value);
+            return !!parsed && typeof parsed === 'object' && !Array.isArray(parsed);
+        }
+        catch {
+            return false;
+        }
+    };
+    const incremental = nonEmpty.join('');
+    if (isJsonObject(incremental))
+        return incremental;
+    let compatible = '';
+    for (const incoming of nonEmpty) {
+        if (!compatible)
+            compatible = incoming;
+        else if (incoming === compatible)
+            continue;
+        else if (incoming.startsWith(compatible))
+            compatible = incoming;
+        else if (compatible.startsWith(incoming))
+            continue;
+        else
+            compatible += incoming;
+    }
+    if (isJsonObject(compatible))
+        return compatible;
+    return [...nonEmpty].reverse().find(isJsonObject) || compatible;
+}
 /**
  * Detect content-policy refusals across the provider failure shapes.
  * Mirrors `LLMProvider.contentPolicyBlocked` semantics exactly so the

package/dist/providers/responses.adapter.js

@@ -155,6 +155,7 @@ class ResponsesAdapter {
                             const key = `${String(payload.item_id || '')}:${String(payload.summary_index || 0)}`;
                             const delta = this.extractText(payload.delta);
                             if (delta) {
+                                emittedContent = true;
                                 reasoningSummaries.set(key, (reasoningSummaries.get(key) || '') + delta);
                                 yield { type: 'reasoning.summary.delta', delta };
                             }
@@ -185,7 +186,7 @@ class ResponsesAdapter {
                                 calls.set(key, {
                                     id: String(item.call_id || item.id || key),
                                     name: String(item.name || ''),
-                                    arguments: String(item.arguments || ''),
+                                    argumentParts: item.arguments ? [String(item.arguments)] : [],
                                     emitted: false,
                                 });
                             }
@@ -193,9 +194,10 @@ class ResponsesAdapter {
                         }
                         if (eventType === 'response.function_call_arguments.delta') {
                             const key = String(payload.item_id || payload.call_id || payload.output_index || '');
-                            const call = calls.get(key) || { id: String(payload.call_id || key), name: String(payload.name || ''), arguments: '', emitted: false };
+                            const call = calls.get(key) || { id: String(payload.call_id || key), name: String(payload.name || ''), argumentParts: [], emitted: false };
                             const delta = String(payload.delta || '');
-                            call.arguments += delta;
+                            if (delta)
+                                call.argumentParts.push(delta);
                             calls.set(key, call);
                             yield { type: 'tool_call.arguments.delta', id: call.id, delta };
                             continue;
@@ -207,19 +209,21 @@ class ResponsesAdapter {
                                 const call = calls.get(key) || {
                                     id: String(item.call_id || item.id || key),
                                     name: String(item.name || ''),
-                                    arguments: String(item.arguments || ''),
+                                    argumentParts: item.arguments ? [String(item.arguments)] : [],
                                     emitted: false,
                                 };
                                 call.id = String(item.call_id || call.id);
                                 call.name = String(item.name || call.name);
-                                call.arguments = typeof item.arguments === 'string' ? item.arguments : call.arguments;
+                                if (typeof item.arguments === 'string' && item.arguments)
+                                    call.argumentParts.push(item.arguments);
                                 if (!call.emitted) {
                                     call.emitted = true;
+                                    const argumentsJson = (0, provider_events_1.assembleCompatibleToolArguments)(call.argumentParts);
                                     yield { type: 'tool_call.started', id: call.id, name: call.name };
-                                    if (call.arguments && call.arguments !== '{}') {
-                                        yield { type: 'tool_call.arguments.delta', id: call.id, delta: call.arguments };
+                                    if (argumentsJson !== '{}') {
+                                        yield { type: 'tool_call.arguments.delta', id: call.id, delta: argumentsJson };
                                     }
-                                    yield { type: 'tool_call.completed', id: call.id, name: call.name, arguments: call.arguments };
+                                    yield { type: 'tool_call.completed', id: call.id, name: call.name, arguments: argumentsJson };
                                 }
                                 calls.set(key, call);
                             }
@@ -252,9 +256,19 @@ class ResponsesAdapter {
                 yield { type: 'response.failed', error: '[LLM Error] Responses stream ended before response.completed.' };
             }
             else if (!emittedContent && calls.size === 0) {
-                yield { type: 'response.failed', error: '[Error] Empty Responses stream.' };
+                yield { type: 'response.failed', error: '[Error] Provider returned an empty response.' };
             }
             else {
+                // Some compatible Responses providers omit output_item.done but still
+                // complete the response. Preserve that valid tool activity and fold
+                // cumulative argument snapshots before handing it to the kernel.
+                for (const call of calls.values()) {
+                    if (call.emitted)
+                        continue;
+                    const argumentsJson = (0, provider_events_1.assembleCompatibleToolArguments)(call.argumentParts);
+                    yield { type: 'tool_call.started', id: call.id, name: call.name };
+                    yield { type: 'tool_call.completed', id: call.id, name: call.name, arguments: argumentsJson };
+                }
                 yield { type: 'response.completed' };
             }
         }

package/dist/tools/index.js

@@ -44,6 +44,7 @@ const browserControl_1 = require("../core/browserControl");
 const browserUse_1 = require("../core/browserUse");
 const conversationTarget_1 = require("../core/conversationTarget");
 const memoryLab_1 = require("../core/memoryLab");
+const flow_1 = require("../core/flow");
 const compat_1 = require("../core/compat");
 const terminalTakeover_1 = require("./terminalTakeover");
 const computerUse_1 = require("./computerUse");
@@ -396,7 +397,7 @@ class ToolExecutor {
             t('subagent_send', 'Persist a mailbox message to a same-conversation 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.' }, message: { type: 'string' }, prompt: { type: 'string', description: 'Legacy alias for message.' }, kind: { type: 'string', enum: ['directive', 'question', 'result', 'handoff'] }, reply_to: { type: 'string' }, correlation_id: { type: 'string' } }, []),
             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('linked_plan', 'Read or incrementally update the current conversation linked Markdown plan. Update requires expected_revision. Prefer append or old_text/new_text for local changes; markdown remains the legacy full replacement path.', { action: { type: 'string', enum: ['get', 'update'] }, markdown: { type: 'string' }, append: { type: 'string' }, old_text: { type: 'string' }, new_text: { type: 'string' }, replace_all: { type: 'boolean' }, expected_revision: { type: 'number' } }, ['action']),
             t('build_history_query', 'Read the concrete public work details (tool calls, results, file changes, guides) of one historical Build Block. Call it proactively when the current task continues, fixes, verifies, or depends on earlier work: reuse the returned activity instead of re-investigating from scratch. Do not call it merely to answer completion status already exposed by the prompt. 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 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.', {
@@ -426,11 +427,11 @@ class ToolExecutor {
             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 } }, []),
             t('flow_list', 'List available Newmark Flow workflows from the Flow folder so the agent can choose one.', {}, []),
-            t('flow_save', 'Design or update a Newmark Flow workflow. Components must be an array of dialog/logic objects compatible with *.Flow.json.', { name: { type: 'string' }, components: { type: 'array' } }, ['name', 'components']),
+            t('flow_save', 'Create or incrementally update a Newmark Flow workflow. Use action=upsert with one component or action=delete with component_id and confirm=true for local edits. action=replace plus components remains the legacy full replacement path.', { name: { type: 'string' }, action: { type: 'string', enum: ['replace', 'upsert', 'delete'] }, components: { type: 'array' }, component: { type: 'object' }, component_id: { type: 'number' }, confirm: { type: 'boolean' } }, ['name']),
             t('flow_run', 'Trigger an existing Newmark Flow workflow by name with optional input and start component.', { name: { type: 'string' }, input: { type: 'string' }, start: { type: 'number' } }, ['name']),
             t('memory_lab_read', 'Read Memory Lab index.json, its path, and usage instructions. Optionally pass component/name/slug to read a memory component core markdown.', { component: { type: 'string' }, name: { type: 'string' }, slug: { type: 'string' } }, []),
             t('memory_lab_query', 'Retrieve a bounded task-relevant Memory Lab set with deterministic scoring and adaptive early stopping. Prefer this over loading the complete index when a focused query is sufficient.', { query: { type: 'string', minLength: 1 }, limit: { type: 'number', minimum: 1, maximum: 12 }, max_chars: { type: 'number', minimum: 1000, maximum: 48000 } }, ['query']),
-            t('memory_lab_update', 'ADD or UPDATE a Memory Lab component. Existing memory should include expectedUpdatedAt from the latest read/query so stale writes fail closed. Prior revisions are archived and the Policy decision is logged.', { name: { type: 'string' }, description: { type: 'string' }, tags: { type: 'array', items: { type: 'string' } }, tagPaths: { type: 'array', items: { type: 'array', items: { type: 'string' } } }, content: { type: 'string' }, kind: { type: 'string', enum: ['file', 'folder'] }, expectedUpdatedAt: { type: 'string' }, reason: { type: 'string' }, source: { type: 'string' } }, ['name', 'tags', 'content']),
+            t('memory_lab_update', 'Create or incrementally patch a Memory Lab component. Create with name/tags/content. For an existing component pass component plus expectedUpdatedAt and only changed fields; prefer contentAppend or oldText/newText for small body edits. Prior revisions are archived and stale writes fail closed.', { component: { type: 'string' }, name: { type: 'string' }, description: { type: 'string' }, tags: { type: 'array', items: { type: 'string' } }, tagPaths: { type: 'array', items: { type: 'array', items: { type: 'string' } } }, content: { type: 'string' }, contentAppend: { type: 'string' }, oldText: { type: 'string' }, newText: { type: 'string' }, replaceAll: { type: 'boolean' }, kind: { type: 'string', enum: ['file', 'folder'] }, expectedUpdatedAt: { type: 'string' }, reason: { type: 'string' }, source: { type: 'string' } }, []),
             t('memory_lab_delete', 'DELETE obsolete durable memory only when the user explicitly asks to forget/remove it. The prior revision is moved to Memory Lab/archive and the Policy decision is logged.', { component: { type: 'string' }, name: { type: 'string' }, slug: { type: 'string' }, expectedUpdatedAt: { type: 'string' }, reason: { type: 'string' }, source: { type: 'string' } }, []),
             t('memory_lab_reindex', 'Rebuild and organize Memory Lab index links. Routed through Agent runtime when invoked by the model.', {}, []),
             t('automation_list', 'List persisted Newmark automations so the agent can inspect scheduled work.', {}, []),
@@ -986,7 +987,7 @@ class ToolExecutor {
                 case 'skill_download': return await this.skillDownload(g('name'), g('source'), context.signal);
                 case 'skill': return '[skill] Routed to Agent runtime.';
                 case 'flow_list': return this.flowList();
-                case 'flow_save': return this.flowSave(g('name'), args.components);
+                case 'flow_save': return this.flowSave(g('name'), args);
                 case 'flow_run': return `[flow_run] Routed to Agent runtime: ${g('name')}`;
                 case 'memory_lab_read': return this.memoryLabRead(g('component') || g('name') || g('slug'));
                 case 'memory_lab_query': return '[memory_lab_query] Routed to Agent runtime for bounded Policy retrieval.';
@@ -1561,13 +1562,45 @@ class ToolExecutor {
             return `[flow_list] ${e}`;
         }
     }
-    flowSave(name, componentsRaw) {
+    flowSave(name, input) {
         const cleanName = (name || '').replace(/[<>:"/\\|?*]/g, '-').trim();
         if (!cleanName)
             return '[flow_save] Workflow name is required.';
+        const dir = path.join(this.root, 'Flow');
+        const target = path.join(dir, `${cleanName}.Flow.json`);
+        const action = String(input.action || (Array.isArray(input.components) ? 'replace' : 'upsert')).toLowerCase();
+        let componentsRaw = input.components;
+        if (action === 'upsert') {
+            if (!input.component || typeof input.component !== 'object')
+                return '[flow_save] component is required for action=upsert.';
+            const existing = flow_1.FlowEngine.load(dir, cleanName)?.components || [];
+            const component = input.component;
+            const requestedId = Number(component.id);
+            if (!Number.isFinite(requestedId))
+                return '[flow_save] component.id is required for action=upsert.';
+            componentsRaw = [...existing.filter(item => item.id !== requestedId), component].sort((a, b) => Number(a.id) - Number(b.id));
+        }
+        else if (action === 'delete') {
+            if (input.confirm !== true)
+                return '[flow_save] action=delete requires confirm=true.';
+            const componentId = Number(input.component_id);
+            if (!Number.isFinite(componentId))
+                return '[flow_save] component_id is required for action=delete.';
+            const existing = flow_1.FlowEngine.load(dir, cleanName);
+            if (!existing)
+                return `[flow_save] Workflow not found: ${cleanName}`;
+            const remaining = existing.components.filter(item => item.id !== componentId);
+            if (remaining.length === existing.components.length)
+                return `[flow_save] Component not found: ${componentId}`;
+            componentsRaw = remaining;
+        }
+        else if (action !== 'replace') {
+            return `[flow_save] Unknown action: ${action}`;
+        }
         if (!Array.isArray(componentsRaw))
-            return '[flow_save] components must be an array.';
-        const components = componentsRaw.map((raw, idx) => {
+            return '[flow_save] components must be an array for action=replace.';
+        const componentInputs = componentsRaw;
+        const components = componentInputs.map((raw, idx) => {
             const c = raw;
             const type = c.type === 'logic' ? 'logic' : 'dialog';
             if (type === 'logic') {
@@ -1588,10 +1621,9 @@ class ToolExecutor {
             };
         });
         const workflow = { name: cleanName, components };
-        const dir = path.join(this.root, 'Flow');
         fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(path.join(dir, `${cleanName}.Flow.json`), JSON.stringify(workflow, null, 2), 'utf-8');
-        return `[flow_save] OK: ${cleanName}.Flow.json`;
+        fs.writeFileSync(target, JSON.stringify(workflow, null, 2), 'utf-8');
+        return `[flow_save] OK (${action}): ${cleanName}.Flow.json`;
     }
     memoryLabRead(selector) {
         const lab = new memoryLab_1.MemoryLabManager(this.root);