@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/tools/metadata.js

@@ -368,6 +368,13 @@ export const TOOL_METADATA = [
         priority: 6,
         description: 'Control desktop applications with app profiles, Excel automation, mouse, keyboard, windows, dialogs, form fields, dropdowns, lists, buttons, links, radios, tabs, menus, tree items, sliders, checkboxes, and assertions'
     },
+    {
+        name: 'office_macro_execute',
+        category: 'system',
+        keywords: ['office', 'excel', 'word', 'powerpoint', 'vba', 'macro', 'powershell', 'com', 'windows', 'automation'],
+        priority: 4,
+        description: 'Execute VBA or PowerShell macros in Microsoft Office apps (Excel/Word/PowerPoint) via COM — Windows only. Dangerous: runs arbitrary code, requires confirmation. Not exposed to fleet peers.'
+    },
     // Planning
     {
         name: 'create_todo_list',
@@ -682,6 +689,13 @@ export const TOOL_METADATA = [
         priority: 6,
         description: 'Capture one local webcam frame and record a vision percept'
     },
+    {
+        name: 'camera_analyze',
+        category: 'media',
+        keywords: ['camera', 'webcam', 'see', 'vision', 'describe', 'look', 'photo', 'companion', 'eyes', 'analyze', 'what do you see'],
+        priority: 7,
+        description: 'Capture a local webcam frame and describe it with a local multimodal vision model'
+    },
     {
         name: 'audio',
         category: 'media',
@@ -940,6 +954,20 @@ export const TOOL_METADATA = [
         priority: 5,
         description: 'Store persistent memory entries'
     },
+    {
+        name: 'replace_memory',
+        category: 'utility',
+        keywords: ['memory', 'replace', 'rewrite', 'update', 'persist', 'preference'],
+        priority: 5,
+        description: 'Replace an existing persistent memory entry under the memory char budget'
+    },
+    {
+        name: 'memory_propose',
+        category: 'utility',
+        keywords: ['memory', 'candidate', 'propose', 'review', 'long-term', 'persist'],
+        priority: 5,
+        description: 'Propose a review-gated long-term memory candidate without silently writing prompt-injected memory'
+    },
     {
         name: 'recall',
         category: 'utility',

package/dist/tools/office-macro-tool.d.ts

@@ -0,0 +1,10 @@
+import type { ToolResult } from '../types/index.js';
+export interface OfficeMacroToolInput {
+    application: 'Excel' | 'Word' | 'PowerPoint';
+    macroCode: string;
+    type: 'vba' | 'powershell';
+    runHeadless?: boolean;
+}
+export declare class OfficeMacroTool {
+    execute(input: OfficeMacroToolInput): Promise<ToolResult>;
+}

package/dist/tools/office-macro-tool.js

@@ -0,0 +1,93 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+const execAsync = promisify(exec);
+export class OfficeMacroTool {
+    async execute(input) {
+        if (process.platform !== 'win32') {
+            return {
+                success: false,
+                error: 'Office Macro Tool is only supported on Windows (win32 platform).',
+            };
+        }
+        try {
+            const { application, macroCode, type, runHeadless = false } = input;
+            const appName = `"${application}.Application"`;
+            let psScript = '';
+            if (type === 'powershell') {
+                psScript = `
+$ErrorActionPreference = "Stop"
+$app = New-Object -ComObject ${appName}
+$app.Visible = $${!runHeadless}
+try {
+${macroCode.split(/\r?\n/).map((l) => '    ' + l).join('\n')}
+} finally {
+    # We do not automatically quit here to allow user interaction unless specified in the script
+}
+        `.trim();
+            }
+            else if (type === 'vba') {
+                // Wrapper to inject VBA code into the application and run it
+                // This usually requires 'Trust access to the VBA project object model' in Office settings.
+                psScript = `
+$ErrorActionPreference = "Stop"
+$app = New-Object -ComObject ${appName}
+$app.Visible = $${!runHeadless}
+try {
+    $workbook = $null
+    if ("${application}" -eq "Excel") {
+        $workbook = $app.Workbooks.Add()
+    } elseif ("${application}" -eq "Word") {
+        $workbook = $app.Documents.Add()
+    } elseif ("${application}" -eq "PowerPoint") {
+        $workbook = $app.Presentations.Add()
+    }
+    
+    if ($workbook -ne $null) {
+        $vbext_ct_StdModule = 1
+        $module = $workbook.VBProject.VBComponents.Add($vbext_ct_StdModule)
+        $module.CodeModule.AddFromString(@"
+${macroCode}
+"@)
+        
+        # We try to run the first parameterless macro found or a specific name if we can infer it.
+        # But commonly, for VBA injection, the user script should define a 'Sub Main()' and we run it.
+        $app.Run("Main")
+    }
+} catch {
+    Write-Error $_.Exception.Message
+} finally {
+    # If headless, we quit
+    if (${runHeadless ? '$true' : '$false'}) {
+        $app.Quit()
+        [System.Runtime.Interopservices.Marshal]::ReleaseComObject($app) | Out-Null
+    }
+}
+        `.trim();
+            }
+            else {
+                return { success: false, error: `Unsupported macro type: ${type}` };
+            }
+            // Save to a temporary file
+            const tempDir = os.tmpdir();
+            const psFilePath = path.join(tempDir, `office_macro_${Date.now()}.ps1`);
+            await fs.writeFile(psFilePath, psScript, 'utf8');
+            // Execute via Powershell
+            const { stdout, stderr } = await execAsync(`powershell.exe -ExecutionPolicy Bypass -File "${psFilePath}"`, {
+                timeout: 60000, // 60 seconds max
+            });
+            // Cleanup
+            await fs.unlink(psFilePath).catch(() => { });
+            if (stderr) {
+                return { success: false, error: stderr.trim() };
+            }
+            return { success: true, output: stdout.trim() || 'Macro executed successfully.' };
+        }
+        catch (e) {
+            return { success: false, error: e instanceof Error ? e.message : String(e) };
+        }
+    }
+}
+//# sourceMappingURL=office-macro-tool.js.map

package/dist/tools/register-tool-handler.d.ts

@@ -0,0 +1,25 @@
+/**
+ * register_tool — lets Code Buddy author a NEW tool for itself at runtime.
+ *
+ * This is the "the code it builds can call its own tools" capability. On a
+ * passing static safety scan it writes BOTH tool registries (via LiveToolMutator):
+ *   - FormalToolRegistry  → the authored tool is immediately CALLABLE (dispatch),
+ *   - legacy ToolRegistry → its schema becomes VISIBLE to the model next turn.
+ *
+ * Authored tools are namespaced `authored__<name>` and run SANDBOXED. Gated
+ * overall by `CODEBUDDY_SELF_IMPROVE=true` at the registration site (tools.ts).
+ *
+ * The static scan here is the same G1 used by the self-improvement engine
+ * (authored-artifact-gate). The fuller behavioural held-out gate (which proves a
+ * tool actually works on fresh inputs) is applied by the engine's tool-gate when
+ * a tool is proposed as a self-improvement against a benchmark scenario.
+ */
+import type { ITool, ToolSchema } from './registry/types.js';
+import type { ToolResult } from '../types/index.js';
+export declare class RegisterToolTool implements ITool {
+    readonly name = "register_tool";
+    readonly description: string;
+    execute(input: Record<string, unknown>): Promise<ToolResult>;
+    getSchema(): ToolSchema;
+}
+export declare function createRegisterToolTool(): RegisterToolTool;

package/dist/tools/register-tool-handler.js

@@ -0,0 +1,100 @@
+/**
+ * register_tool — lets Code Buddy author a NEW tool for itself at runtime.
+ *
+ * This is the "the code it builds can call its own tools" capability. On a
+ * passing static safety scan it writes BOTH tool registries (via LiveToolMutator):
+ *   - FormalToolRegistry  → the authored tool is immediately CALLABLE (dispatch),
+ *   - legacy ToolRegistry → its schema becomes VISIBLE to the model next turn.
+ *
+ * Authored tools are namespaced `authored__<name>` and run SANDBOXED. Gated
+ * overall by `CODEBUDDY_SELF_IMPROVE=true` at the registration site (tools.ts).
+ *
+ * The static scan here is the same G1 used by the self-improvement engine
+ * (authored-artifact-gate). The fuller behavioural held-out gate (which proves a
+ * tool actually works on fresh inputs) is applied by the engine's tool-gate when
+ * a tool is proposed as a self-improvement against a benchmark scenario.
+ */
+import { AUTHORED_LANGUAGES, toAuthoredName, } from '../agent/self-improvement/authored-tool-runtime.js';
+import { inspectAuthoredCode } from '../agent/self-improvement/authored-artifact-gate.js';
+import { LiveToolMutator } from '../agent/self-improvement/tool-skill-mutator.js';
+import { logger } from '../utils/logger.js';
+export class RegisterToolTool {
+    name = 'register_tool';
+    description = 'Author a NEW tool for yourself at runtime. Provide a name, description, JSON-schema params, ' +
+        'a language (javascript|typescript|python) and the code. The code reads its call arguments as ' +
+        'JSON from the CODEBUDDY_TOOL_INPUT env var and prints its result to stdout. On a passing safety ' +
+        'check the tool is registered as `authored__<name>` and becomes callable by you on your next turn.';
+    async execute(input) {
+        const rawName = String(input.name ?? '').trim();
+        const description = String(input.description ?? '').trim();
+        const language = String(input.language ?? 'javascript').toLowerCase();
+        const code = typeof input.code === 'string' ? input.code : '';
+        const parameters = input.params && typeof input.params === 'object'
+            ? input.params
+            : { type: 'object', properties: {} };
+        if (!rawName)
+            return { success: false, error: 'register_tool: `name` is required.' };
+        if (!description)
+            return { success: false, error: 'register_tool: `description` is required.' };
+        if (!code.trim())
+            return { success: false, error: 'register_tool: `code` is required.' };
+        if (!AUTHORED_LANGUAGES.includes(language)) {
+            return { success: false, error: `register_tool: language must be one of ${AUTHORED_LANGUAGES.join(', ')}.` };
+        }
+        // Static safety scan (engine G1): dangerous patterns, secrets, no-src/-write, omissions.
+        const scan = inspectAuthoredCode(code, 'code');
+        if (!scan.ok) {
+            return { success: false, error: `register_tool: refused — ${scan.reasons.join('; ')}.` };
+        }
+        const spec = {
+            name: toAuthoredName(rawName),
+            description,
+            parameters,
+            language,
+            code,
+        };
+        try {
+            new LiveToolMutator().register(spec);
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `register_tool: registration failed — ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        logger.info(`[self-improve] authored tool registered: ${spec.name}`);
+        return {
+            success: true,
+            output: `Registered tool \`${spec.name}\`. It is now callable by you on your next turn — ` +
+                `call it with arguments matching its params.`,
+        };
+    }
+    getSchema() {
+        return {
+            name: this.name,
+            description: this.description,
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'Tool name (namespaced to authored__<name>)' },
+                    description: { type: 'string', description: 'What the tool does and when to use it' },
+                    params: { type: 'object', description: 'JSON Schema for the tool arguments' },
+                    language: {
+                        type: 'string',
+                        enum: ['javascript', 'typescript', 'python'],
+                        description: 'Implementation language (default javascript)',
+                    },
+                    code: {
+                        type: 'string',
+                        description: 'Code that reads its args as JSON from env CODEBUDDY_TOOL_INPUT and prints its result to stdout',
+                    },
+                },
+                required: ['name', 'description', 'code'],
+            },
+        };
+    }
+}
+export function createRegisterToolTool() {
+    return new RegisterToolTool();
+}
+//# sourceMappingURL=register-tool-handler.js.map

package/dist/tools/registry/index.d.ts

@@ -40,7 +40,7 @@ export { RelationshipContextTool, createRelationshipIntelligenceTools, } from '.
 export { InternetScoutPlanTool, InternetScoutRunTool, createInternetScoutTools, } from './internet-scout-tools.js';
 export { LeadScoutEnrichmentPlanTool, LeadScoutLessonCandidatesTool, LeadScoutPlanTool, LeadScoutRunTool, createLeadScoutTools, } from './lead-scout-tools.js';
 export { BrowserOperatorTool, createBrowserOperatorTools } from './browser-operator-tools.js';
-export { RememberTool, RecallTool, ForgetTool, createMemoryTools, } from './memory-tools.js';
+export { RememberTool, ReplaceMemoryTool, MemoryProposeTool, RecallTool, ForgetTool, createMemoryTools, } from './memory-tools.js';
 export { TodoAttentionTool, RestoreContextTool, createAttentionTools, } from './attention-tools.js';
 export { LessonsAddTool, LessonsGraphTool, LessonsSearchTool, LessonsListTool, TaskVerifyTool, createLessonsTools, } from './lessons-tools.js';
 export { UserModelObserveTool, UserModelRecallTool, createUserModelTools, } from './user-model-tools.js';
@@ -91,3 +91,4 @@ import type { ITool } from './types.js';
  */
 export declare function registerBuiltinTools(registry: FormalToolRegistry): number;
 import { FormalToolRegistry } from './tool-registry.js';
+export * from "./windows-tools.js";

package/dist/tools/registry/index.js

@@ -66,7 +66,7 @@ export { LeadScoutEnrichmentPlanTool, LeadScoutLessonCandidatesTool, LeadScoutPl
 // Tool Adapters - Browser Operator (live-web session proposal)
 export { BrowserOperatorTool, createBrowserOperatorTools } from './browser-operator-tools.js';
 // Tool Adapters - Persistent Memory (remember, recall, forget)
-export { RememberTool, RecallTool, ForgetTool, createMemoryTools, } from './memory-tools.js';
+export { RememberTool, ReplaceMemoryTool, MemoryProposeTool, RecallTool, ForgetTool, createMemoryTools, } from './memory-tools.js';
 // Tool Adapters - Attention (Todo + RestoreContext)
 export { TodoAttentionTool, RestoreContextTool, createAttentionTools, } from './attention-tools.js';
 // Tool Adapters - Lessons (self-improvement loop + verification contract)
@@ -369,4 +369,5 @@ import { createGuiTools } from './gui-tools.js';
 import { createSessionTools } from './session-tools.js';
 import { createAliasTools } from './tool-aliases.js';
 import { createGitNexusTools } from './gitnexus-tools.js';
+export * from "./windows-tools.js";
 //# sourceMappingURL=index.js.map

package/dist/tools/registry/memory-tools.d.ts

@@ -3,6 +3,8 @@
  *
  * Tools for the agent to autonomously manage its persistent memory (CLAUDE.md style).
  * - remember: Store information in project or user memory
+ * - replace_memory: Replace an existing memory entry under Hermes-style bounds
+ * - memory_propose: Queue a long-term memory candidate for human review
  * - recall: Explicitly retrieve a memory by key
  * - forget: Remove a memory entry
  */
@@ -17,6 +19,24 @@ export declare class RememberTool implements ITool {
     getMetadata(): IToolMetadata;
     isAvailable(): boolean;
 }
+export declare class ReplaceMemoryTool implements ITool {
+    readonly name = "replace_memory";
+    readonly description = "Replace an existing persistent memory entry. Use when a stored fact is obsolete or too verbose and must be rewritten under the memory char budget.";
+    execute(input: Record<string, unknown>): Promise<ToolResult>;
+    getSchema(): ToolSchema;
+    validate(input: unknown): IValidationResult;
+    getMetadata(): IToolMetadata;
+    isAvailable(): boolean;
+}
+export declare class MemoryProposeTool implements ITool {
+    readonly name = "memory_propose";
+    readonly description = "Propose a long-term memory candidate for human review. Use this instead of remember when the fact is inferred, ambiguous, or should not be silently injected into future prompts.";
+    execute(input: Record<string, unknown>): Promise<ToolResult>;
+    getSchema(): ToolSchema;
+    validate(input: unknown): IValidationResult;
+    getMetadata(): IToolMetadata;
+    isAvailable(): boolean;
+}
 export declare class RecallTool implements ITool {
     readonly name = "recall";
     readonly description = "Explicitly retrieve a specific memory entry by its key. Use this if the information is not currently in your system prompt.";

package/dist/tools/registry/memory-tools.js

@@ -3,10 +3,13 @@
  *
  * Tools for the agent to autonomously manage its persistent memory (CLAUDE.md style).
  * - remember: Store information in project or user memory
+ * - replace_memory: Replace an existing memory entry under Hermes-style bounds
+ * - memory_propose: Queue a long-term memory candidate for human review
  * - recall: Explicitly retrieve a memory by key
  * - forget: Remove a memory entry
  */
 import { getMemoryManager } from '../../memory/persistent-memory.js';
+import { getMemoryCandidateQueue } from '../../memory/memory-candidate-queue.js';
 import { executeHermesLifecycleHook } from '../../hooks/hermes-lifecycle-hooks.js';
 // ============================================================================
 // remember
@@ -45,10 +48,10 @@ export class RememberTool {
                     ? hookResult.updatedInput.category
                     : category;
             }
-            await mm.remember(key, value, { scope, category });
+            const result = await mm.remember(key, value, { scope, category });
             return {
                 success: true,
-                output: `Successfully remembered "${key}" in ${scope} memory (category: ${category}).`,
+                output: `${result.message} Usage: ${result.usage.used}/${result.usage.limit} chars (${result.usage.percent}%).`,
             };
         }
         catch (err) {
@@ -80,7 +83,7 @@ export class RememberTool {
                     },
                     category: {
                         type: 'string',
-                        enum: ['project', 'preferences', 'decisions', 'patterns', 'custom'],
+                        enum: ['project', 'preferences', 'decisions', 'patterns', 'context', 'custom'],
                         description: 'The type of information being stored',
                     },
                 },
@@ -118,6 +121,223 @@ export class RememberTool {
     }
 }
 // ============================================================================
+// replace_memory
+// ============================================================================
+export class ReplaceMemoryTool {
+    name = 'replace_memory';
+    description = 'Replace an existing persistent memory entry. Use when a stored fact is obsolete or too verbose and must be rewritten under the memory char budget.';
+    async execute(input) {
+        const mm = getMemoryManager();
+        let key = input.key;
+        let value = input.value;
+        let scope = input.scope ?? 'project';
+        let category = input.category;
+        try {
+            const hookResult = await executeHermesLifecycleHook(process.cwd(), 'before_memory_write', {
+                toolName: this.name,
+                toolInput: { key, value, scope, category },
+                memoryKey: key,
+                memoryValue: value,
+                memoryScope: scope,
+                memoryCategory: category,
+            });
+            if (!hookResult.allowed) {
+                return {
+                    success: false,
+                    error: hookResult.feedback ?? 'Memory replacement blocked by BeforeMemoryWrite hook.',
+                };
+            }
+            if (hookResult.updatedInput) {
+                key = typeof hookResult.updatedInput.key === 'string' ? hookResult.updatedInput.key : key;
+                value = typeof hookResult.updatedInput.value === 'string' ? hookResult.updatedInput.value : value;
+                scope = hookResult.updatedInput.scope === 'user' || hookResult.updatedInput.scope === 'project'
+                    ? hookResult.updatedInput.scope
+                    : scope;
+                category = typeof hookResult.updatedInput.category === 'string'
+                    ? hookResult.updatedInput.category
+                    : category;
+            }
+            const result = await mm.replace(key, value, { scope, category });
+            if (result.status === 'missing') {
+                return {
+                    success: true,
+                    output: result.message,
+                };
+            }
+            return {
+                success: true,
+                output: `${result.message} Usage: ${result.usage.used}/${result.usage.limit} chars (${result.usage.percent}%).`,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Failed to replace memory: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    getSchema() {
+        return {
+            name: this.name,
+            description: this.description,
+            parameters: {
+                type: 'object',
+                properties: {
+                    key: {
+                        type: 'string',
+                        description: 'Existing memory key to replace',
+                    },
+                    value: {
+                        type: 'string',
+                        description: 'New concise memory value',
+                    },
+                    scope: {
+                        type: 'string',
+                        enum: ['project', 'user'],
+                        description: 'Memory scope to replace in (default: project)',
+                    },
+                    category: {
+                        type: 'string',
+                        enum: ['project', 'preferences', 'decisions', 'patterns', 'context', 'custom'],
+                        description: 'Optional replacement category',
+                    },
+                },
+                required: ['key', 'value'],
+            },
+        };
+    }
+    validate(input) {
+        if (typeof input !== 'object' || input === null) {
+            return { valid: false, errors: ['Input must be an object'] };
+        }
+        const data = input;
+        if (typeof data.key !== 'string' || !data.key.trim()) {
+            return { valid: false, errors: ['key must be a non-empty string'] };
+        }
+        if (typeof data.value !== 'string' || !data.value.trim()) {
+            return { valid: false, errors: ['value must be a non-empty string'] };
+        }
+        return { valid: true };
+    }
+    getMetadata() {
+        return {
+            name: this.name,
+            description: this.description,
+            category: 'utility',
+            keywords: ['memory', 'replace', 'rewrite', 'update', 'persist', 'preference'],
+            priority: 5,
+            requiresConfirmation: false,
+            modifiesFiles: true,
+            makesNetworkRequests: false,
+        };
+    }
+    isAvailable() {
+        return true;
+    }
+}
+// ============================================================================
+// memory_propose
+// ============================================================================
+export class MemoryProposeTool {
+    name = 'memory_propose';
+    description = 'Propose a long-term memory candidate for human review. Use this instead of remember when the fact is inferred, ambiguous, or should not be silently injected into future prompts.';
+    async execute(input) {
+        const key = input.key;
+        const value = input.value;
+        const scope = input.scope ?? 'project';
+        const category = input.category ?? 'context';
+        const confidence = typeof input.confidence === 'number' ? input.confidence : undefined;
+        const rationale = typeof input.rationale === 'string' ? input.rationale : undefined;
+        try {
+            const { candidate, deduped } = getMemoryCandidateQueue(process.cwd()).propose({
+                key,
+                value,
+                scope,
+                category,
+                source: 'self_observed',
+                ...(confidence !== undefined ? { confidence } : {}),
+                ...(rationale ? { rationale } : {}),
+            });
+            return {
+                success: true,
+                output: `${deduped ? 'Matched existing pending' : 'Proposed'} memory candidate ${candidate.id} (${candidate.scope}/${candidate.category}). Approve with: /memory accept ${candidate.id}`,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `memory_propose failed: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    getSchema() {
+        return {
+            name: this.name,
+            description: this.description,
+            parameters: {
+                type: 'object',
+                properties: {
+                    key: {
+                        type: 'string',
+                        description: 'Short kebab-case key for the memory candidate',
+                    },
+                    value: {
+                        type: 'string',
+                        description: 'Concise candidate memory value',
+                    },
+                    scope: {
+                        type: 'string',
+                        enum: ['project', 'user'],
+                        description: 'Candidate scope (default: project)',
+                    },
+                    category: {
+                        type: 'string',
+                        enum: ['project', 'preferences', 'decisions', 'patterns', 'context', 'custom'],
+                        description: 'Candidate category',
+                    },
+                    confidence: {
+                        type: 'number',
+                        description: 'Confidence from 0 to 1',
+                    },
+                    rationale: {
+                        type: 'string',
+                        description: 'Short evidence note for reviewer',
+                    },
+                },
+                required: ['key', 'value'],
+            },
+        };
+    }
+    validate(input) {
+        if (typeof input !== 'object' || input === null) {
+            return { valid: false, errors: ['Input must be an object'] };
+        }
+        const data = input;
+        if (typeof data.key !== 'string' || !data.key.trim()) {
+            return { valid: false, errors: ['key must be a non-empty string'] };
+        }
+        if (typeof data.value !== 'string' || !data.value.trim()) {
+            return { valid: false, errors: ['value must be a non-empty string'] };
+        }
+        return { valid: true };
+    }
+    getMetadata() {
+        return {
+            name: this.name,
+            description: this.description,
+            category: 'utility',
+            keywords: ['memory', 'candidate', 'propose', 'review', 'long-term', 'persist'],
+            priority: 5,
+            requiresConfirmation: false,
+            modifiesFiles: true,
+            makesNetworkRequests: false,
+        };
+    }
+    isAvailable() {
+        return true;
+    }
+}
+// ============================================================================
 // recall
 // ============================================================================
 export class RecallTool {
@@ -267,6 +487,8 @@ export class ForgetTool {
 export function createMemoryTools() {
     return [
         new RememberTool(),
+        new ReplaceMemoryTool(),
+        new MemoryProposeTool(),
         new RecallTool(),
         new ForgetTool(),
     ];

package/dist/tools/registry/multimodal-tools.js

@@ -221,7 +221,7 @@ export class TextToSpeechTool {
                     },
                     provider: {
                         type: 'string',
-                        enum: ['auto', 'system', 'edge-tts', 'espeak', 'say', 'kokoro', 'audioreader'],
+                        enum: ['auto', 'system', 'edge-tts', 'espeak', 'say', 'audioreader'],
                         description: 'TTS provider. auto detects a local provider; system uses Windows SAPI.',
                     },
                     voice: {
@@ -1104,7 +1104,7 @@ function optionalProvider(value) {
     if (typeof value !== 'string' || !value.trim())
         return undefined;
     const provider = value.trim();
-    if (['auto', 'system', 'edge-tts', 'espeak', 'say', 'kokoro', 'audioreader'].includes(provider)) {
+    if (['auto', 'system', 'edge-tts', 'espeak', 'say', 'audioreader'].includes(provider)) {
         return provider;
     }
     throw new Error(`Unsupported text_to_speech provider: ${provider}`);