newmark-agent 0.5.8 → 0.5.10

package/dist/core/agent.js

@@ -355,7 +355,7 @@ class Agent {
             this.config.set('skills', 'auto_download', 'disabled');
         }
         const modeStr = this.config.getStr('agent', 'default_mode');
-        this.mode = (['plan', 'goal', 'flow'].includes(modeStr) ? modeStr : 'build');
+        this.mode = (['plan', 'chat', 'goal', 'flow'].includes(modeStr) ? modeStr : 'build');
         const inputStr = this.config.getStr('general', 'default_input');
         this.inputMode = inputStr === 'next' ? 'next' : 'guide';
         const configuredModel = this.config.getStr('models', 'default_model');
@@ -399,6 +399,8 @@ class Agent {
         }
     }
     setMode(m) {
+        if (!['build', 'plan', 'chat', 'goal', 'flow'].includes(m))
+            m = 'build';
         if (m === 'goal' && !this.goal) {
             this.goal = new GoalStateImpl('Set your objective');
         }
@@ -5362,7 +5364,24 @@ class Agent {
             if (action !== 'update')
                 return JSON.stringify({ ok: false, error: `Unknown linked_plan action: ${action}` });
             const expectedRevision = Number(input.expected_revision ?? input.expectedRevision);
-            return JSON.stringify({ ok: true, linkedPlan: this.updateLinkedPlan(String(input.markdown || ''), expectedRevision) }, null, 2);
+            const current = this.getLinkedPlan();
+            let markdown = input.markdown === undefined ? current.markdown : String(input.markdown);
+            if (input.append !== undefined)
+                markdown = `${current.markdown}${String(input.append)}`;
+            if (input.old_text !== undefined || input.oldText !== undefined) {
+                const oldText = String(input.old_text ?? input.oldText ?? '');
+                if (!oldText)
+                    throw new Error('linked_plan old_text must not be empty.');
+                const matches = current.markdown.split(oldText).length - 1;
+                if (!matches)
+                    throw new Error('linked_plan old_text was not found.');
+                const replaceAll = input.replace_all === true || input.replaceAll === true;
+                if (matches > 1 && !replaceAll)
+                    throw new Error(`linked_plan old_text matched ${matches} places; pass replace_all=true or a unique fragment.`);
+                const newText = String(input.new_text ?? input.newText ?? '');
+                markdown = replaceAll ? current.markdown.split(oldText).join(newText) : current.markdown.replace(oldText, newText);
+            }
+            return JSON.stringify({ ok: true, linkedPlan: this.updateLinkedPlan(markdown, expectedRevision) }, null, 2);
         }
         catch (error) {
             return JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) });
@@ -7965,7 +7984,24 @@ class Agent {
                     }));
                 }
                 case 'memory_lab_update': {
-                    const result = await this.updateMemoryLab({
+                    const selector = String(params.component || params.slug || '').trim();
+                    const prepared = selector ? this.memoryLab.preparePatch({
+                        component: selector,
+                        name: params.name === undefined ? undefined : String(params.name),
+                        description: params.description === undefined ? undefined : String(params.description),
+                        tags: params.tags === undefined ? undefined : (Array.isArray(params.tags) ? params.tags.map(String) : String(params.tags).split(/[,，\n]+/)),
+                        tagPaths: params.tagPaths === undefined ? undefined : (Array.isArray(params.tagPaths) ? params.tagPaths.filter(Array.isArray).map(pathValue => pathValue.map(String)) : []),
+                        content: params.content === undefined ? undefined : String(params.content),
+                        contentAppend: params.contentAppend === undefined && params.content_append === undefined ? undefined : String(params.contentAppend ?? params.content_append),
+                        oldText: params.oldText === undefined && params.old_text === undefined ? undefined : String(params.oldText ?? params.old_text),
+                        newText: String(params.newText ?? params.new_text ?? ''),
+                        replaceAll: params.replaceAll === true || params.replace_all === true,
+                        kind: params.kind === undefined ? undefined : (params.kind === 'folder' ? 'folder' : 'file'),
+                        expectedUpdatedAt: String(params.expectedUpdatedAt || params.expected_updated_at || ''),
+                        reason: String(params.reason || ''),
+                        source: String(params.source || ''),
+                    }) : undefined;
+                    const result = await this.updateMemoryLab(prepared || {
                         name: String(params.name || ''),
                         description: String(params.description || ''),
                         tags: Array.isArray(params.tags) ? params.tags.map(String) : String(params.tags || '').split(/[,，\n]+/),
@@ -9127,6 +9163,8 @@ class Agent {
         parts.push(this.buildFeatureDisclosurePrompt());
         if (this.mode === 'plan')
             parts.push(`[Plan Tool Policy]\n${(0, toolPolicy_1.planModePolicyPrompt)()}`);
+        if (this.mode === 'chat')
+            parts.push(`[Chat Tool Policy]\n${(0, toolPolicy_1.chatModePolicyPrompt)()}`);
         const pm = this.config.getStr('workspace', 'prompt_mode') || 'both';
         const injectedPrompts = new Set();
         if ((pm === 'global_only' || pm === 'both') && globalPrompt) {
@@ -9247,7 +9285,7 @@ class Agent {
             `- Language policy: general.language=${language}; the UI can switch this at runtime and each turn must obey the current value. auto follows the user's dominant input language, en replies in English, zh replies in Simplified Chinese. Keep code, commands, file paths, JSON keys, model/provider names, tool names, quoted source text, and user-provided literals exactly as required by their source language.`,
             `- Workspace permissions: access_permission=${permission}; file tools are checked before execution and blocked when they exceed the configured workspace boundary.`,
             `- Remote repository safety: when the active workspace or any target path is inside a GitHub/remote-backed repository, proactively use repo_security_audit and file_audit before git_push, gh_pr_create, release packaging, public reporting, or cloud-side audit. Treat public remotes as public disclosure surfaces and keep private URLs, secrets, privacy addresses (credential URLs, private network addresses, local user paths), local runtime state, archives, Memory Lab, Work, config, and release outputs out of commits and summaries. git_push/gh_pr_create hard-block on detected high-risk findings until a second review resolves them and the action is retried with security_review_confirmed=true.`,
-            `- Mode engine: current mode=${this.modeName()}; Build works autonomously, Plan is fully read-only with no file modifications, Goal continues until completion unless paused, Flow follows saved workflow components.`,
+            `- Mode engine: current mode=${this.modeName()}; Build works autonomously, Plan is fully read-only, Chat only performs web search/fetch evidence gathering and prompt synthesis, Goal continues until completion unless paused, Flow follows saved workflow components.`,
             `- Input mode: ${input}; Guide injects immediately, Next queues user intent for the following build turn.`,
             `- Option feedback: ${this.buildQuestionPolicyPrompt(optionFeedback)}`,
             `- Model policy: current model=${this.model || '(unset)'}, intelligence=${this.intelligence}, auto-switch=${modelSwitch}.`,
@@ -9318,6 +9356,14 @@ class Agent {
                     'Only after the durable linked plan has actually been updated and the plan is complete, expose the fixed mode handoff asking whether execution should begin. Offer exactly these two choices in the user language: "是，执行此计划" / "否，请补充____" (or "Yes, execute this plan" / "No, please supplement _____"). This fixed handoff remains required when discretionary questions are disabled.',
                     'A positive choice starts a new Build-mode input. A negative choice remains in Plan mode so the user can supply the missing details.',
                 ]).join('\n');
+            case 'chat':
+                return withLanguage([
+                    'CHAT MODE.',
+                    'Use only web_search and web_fetch. You have no workspace, host, application, memory, task, browser-control, or write permissions.',
+                    'Perform an online search to gather evidence before answering. Fetch primary or authoritative pages when the search snippets are insufficient.',
+                    'After sufficient evidence is collected, summarize and answer the user as soon as possible. Stay concise and do not turn the request into a long-running Build, Plan, Goal, or Flow task.',
+                    'Distinguish sourced facts from uncertainty and include useful source links in the final answer.',
+                ]).join('\n');
             case 'goal': {
                 const g = this.goal?.history() || '';
                 const paused = this.goal?.paused ? '\n[GOAL PAUSED by user. Wait for resume.]' : '\n[Continue working until the goal is achieved.]';

package/dist/core/memoryLab.d.ts

@@ -35,6 +35,22 @@ export interface MemoryLabUpdateInput {
     reason?: string;
     source?: string;
 }
+export interface MemoryLabPatchInput {
+    component: string;
+    name?: string;
+    description?: string;
+    tags?: string[];
+    tagPaths?: string[][];
+    content?: string;
+    contentAppend?: string;
+    oldText?: string;
+    newText?: string;
+    replaceAll?: boolean;
+    kind?: MemoryLabComponentKind;
+    expectedUpdatedAt?: string;
+    reason?: string;
+    source?: string;
+}
 export interface MemoryLabPreparedUpdate extends MemoryLabUpdateInput {
     slug: string;
     description: string;
@@ -120,6 +136,7 @@ export declare class MemoryLabManager {
     read(componentSelector?: string): MemoryLabReadResult;
     visualizationSnapshot(): MemoryLabVisualizationResult;
     prepareUpdate(input: MemoryLabUpdateInput): MemoryLabPreparedUpdate;
+    preparePatch(input: MemoryLabPatchInput): MemoryLabPreparedUpdate;
     update(prepared: MemoryLabPreparedUpdate): MemoryLabWriteResult;
     query(input: {
         query: string;

package/dist/core/memoryLab.js

@@ -91,7 +91,8 @@ class MemoryLabManager {
             'Use memory_lab_read to inspect index.json before deciding what memory is relevant.',
             'Use memory_lab_query for bounded task-relevant retrieval; do not inject the complete index when a focused query is sufficient.',
             'Use memory_lab_read with component/name/slug to read a component core markdown file.',
-            'Use memory_lab_update only when the user asks to create or update durable memory, passing name, description, tags, optional tagPaths, content, and optional kind=file|folder.',
+            'Use memory_lab_update only when the user asks to create or update durable memory. Create with name, tags, and content; patch an existing component with component plus only changed fields.',
+            'For small body edits prefer contentAppend or oldText/newText over resending the complete content.',
             'For an existing component, pass expectedUpdatedAt from the latest read/query result. A stale update is rejected instead of overwriting newer memory.',
             'Use memory_lab_delete only when the user explicitly asks to forget/remove durable memory. Delete moves the prior revision to Memory Lab/archive and records a policy event.',
             'Every mutation should include a concise reason and source. ADD, UPDATE, and DELETE decisions are append-only in policy.jsonl and are recoverable from archive.',
@@ -206,6 +207,47 @@ class MemoryLabManager {
             source: String(input.source || '').trim(),
         };
     }
+    preparePatch(input) {
+        const selector = String(input.component || '').trim();
+        if (!selector)
+            throw new Error('Memory component is required for a patch.');
+        const current = this.read(selector);
+        if (!current.ok || !current.component)
+            throw new Error(current.error || `Memory component not found: ${selector}`);
+        const existing = current.component.meta;
+        const oldContent = current.component.content;
+        let content = input.content !== undefined ? String(input.content) : oldContent;
+        if (input.contentAppend !== undefined)
+            content = `${oldContent}${String(input.contentAppend)}`;
+        if (input.oldText !== undefined) {
+            const oldText = String(input.oldText);
+            if (!oldText)
+                throw new Error('oldText must not be empty.');
+            const matches = oldContent.split(oldText).length - 1;
+            if (!matches)
+                throw new Error('oldText was not found in the Memory Lab component.');
+            if (matches > 1 && input.replaceAll !== true)
+                throw new Error(`oldText matched ${matches} places; pass replaceAll=true or a unique fragment.`);
+            content = input.replaceAll === true
+                ? oldContent.split(oldText).join(String(input.newText || ''))
+                : oldContent.replace(oldText, String(input.newText || ''));
+        }
+        const name = input.name === undefined ? existing.name : String(input.name);
+        if (this.slugify(name) !== current.component.slug) {
+            throw new Error('Renaming a Memory Lab component is not supported by incremental patch; create the new component then delete the old one.');
+        }
+        return this.prepareUpdate({
+            name,
+            description: input.description === undefined ? existing.description : String(input.description),
+            tags: input.tags === undefined ? existing.tags : input.tags,
+            tagPaths: input.tagPaths === undefined ? existing.tagPaths : input.tagPaths,
+            content,
+            kind: input.kind === undefined ? existing.kind : input.kind,
+            expectedUpdatedAt: String(input.expectedUpdatedAt || existing.updatedAt),
+            reason: input.reason,
+            source: input.source,
+        });
+    }
     update(prepared) {
         this.ensure();
         const index = this.loadIndex();

package/dist/core/toolPolicy.d.ts

@@ -25,6 +25,7 @@ export declare function toolAvailability(name: string): ToolAvailability;
 export declare function evaluateToolPolicy(request: ToolPolicyRequest): ToolPolicyDecision;
 export declare function filterToolDefinitions<T>(definitions: T[], request: Omit<ToolPolicyRequest, 'name' | 'args'>): T[];
 export declare function planModePolicyPrompt(): string;
+export declare function chatModePolicyPrompt(): string;
 export interface DeletionGuardDecision {
     blocked: boolean;
     reason?: string;

package/dist/core/toolPolicy.js

@@ -7,6 +7,7 @@ exports.toolAvailability = toolAvailability;
 exports.evaluateToolPolicy = evaluateToolPolicy;
 exports.filterToolDefinitions = filterToolDefinitions;
 exports.planModePolicyPrompt = planModePolicyPrompt;
+exports.chatModePolicyPrompt = chatModePolicyPrompt;
 exports.evaluateDeletionGuard = evaluateDeletionGuard;
 const REQUIRED_TOOLS = new Set(['pwd', 'read', 'glob', 'grep']);
 const MODE_SCOPED_TOOLS = new Set([
@@ -81,6 +82,7 @@ exports.PLAN_COMPUTER_USE_ACTIONS = ['observe', 'app_list', 'app_observe'];
 exports.PLAN_BROWSER_USE_ACTIONS = ['observe', 'navigate', 'wait', 'extract'];
 const PLAN_COMPUTER_USE_ACTION_SET = new Set(exports.PLAN_COMPUTER_USE_ACTIONS);
 const PLAN_BROWSER_USE_ACTION_SET = new Set(exports.PLAN_BROWSER_USE_ACTIONS);
+const CHAT_WEB_TOOLS = new Set(['web_search', 'web_fetch']);
 /**
  * 并发安全工具集合（DSH isConcurrencySafe 语义的 Newmark 落地）。
  *
@@ -140,6 +142,13 @@ function evaluateToolPolicy(request) {
     const base = { availability, settingsVisible: availability === 'configurable' };
     if (!name)
         return { ...base, allowed: false, reason: '[permission] Tool name is required.' };
+    if (request.mode === 'chat' && !CHAT_WEB_TOOLS.has(name)) {
+        return {
+            ...base,
+            allowed: false,
+            reason: `[permission] Chat mode only allows web_search and web_fetch. It has no workspace, host, application, memory, task, or other write access. Blocked: ${name}`,
+        };
+    }
     if (request.mode === 'plan') {
         if (name === 'computer_use') {
             const action = String(request.args?.action || '').trim();
@@ -182,6 +191,13 @@ function planModePolicyPrompt() {
         'Runtime policy rejects stale or hidden mutating tool calls even if a prompt asks for them.',
     ].join(' ');
 }
+function chatModePolicyPrompt() {
+    return [
+        'Chat mode is a narrow web-evidence mode.',
+        'Only web_search and web_fetch are available; every workspace, host, application, memory, task, browser-control, and write capability is denied at runtime.',
+        'Search the web for relevant evidence, fetch primary or authoritative sources when useful, then summarize and answer promptly instead of expanding into a long-running task.',
+    ].join(' ');
+}
 /** 删除命令动词（跨 POSIX / PowerShell / cmd）。注意：不含单独 "remove"（避免匹配普通英文）。 */
 const DELETE_VERB_SOURCE = '(?:remove-item|rmdir|unlink|erase|del|rm|rd|ri)';
 const DELETE_VERB_BOUNDARY = new RegExp(`(?:^|[\\s;&|()\\n])${DELETE_VERB_SOURCE}(?:\\s|$)`, 'i');

package/dist/core/types.d.ts

@@ -1,4 +1,4 @@
-export type AgentMode = 'build' | 'plan' | 'goal' | 'flow';
+export type AgentMode = 'build' | 'plan' | 'chat' | 'goal' | 'flow';
 export type InputMode = 'guide' | 'next';
 export type AgentStatus = 'idle' | 'working' | 'error' | 'goal_paused';
 /** Public routing identity used by renderer/main/runtime envelopes. */

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);