npm - dominds - Versions diffs - 1.4.2 → 1.5.2 - Mend

dominds 1.4.2 → 1.5.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (174) hide show

package/dist/static/index.html CHANGED Viewed

@@ -52,7 +52,7 @@
         padding: 20px;
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-B-8J28g7.js"></script>
+    <script type="module" crossorigin src="/assets/index-DrTqAfFy.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CD5wtC_i.css">
   </head>
   <body>

package/dist/team.js CHANGED Viewed

@@ -14,6 +14,7 @@ exports.Team = void 0;
  */
 const promises_1 = __importDefault(require("fs/promises"));
 const yaml_1 = __importDefault(require("yaml"));
+const enabled_apps_1 = require("./apps/enabled-apps");
 const teammates_1 = require("./apps/teammates");
 const client_1 = require("./llm/client");
 const log_1 = require("./log");
@@ -530,10 +531,26 @@ exports.Team = Team;
         async function validateMemberToolsetBindings(team, md) {
             const registeredToolsets = new Set(Object.keys((0, registry_1.listToolsets)()));
             const mcpDeclared = await readMcpDeclaredToolsets();
+            let enabledAppToolsets = new Set();
+            try {
+                const snapshot = await (0, enabled_apps_1.loadEnabledAppsSnapshot)({ rtwsRootAbs: process.cwd() });
+                enabledAppToolsets = new Set(snapshot.enabledApps.flatMap((app) => (app.installJson.contributes?.toolsets ?? []).map((toolset) => toolset.id)));
+            }
+            catch (err) {
+                addIssue('apps/toolsets/load', 'Failed to load enabled app toolsets while validating .minds/team.yaml toolset bindings.', err instanceof Error ? err.message : String(err));
+            }
             const validateAt = (args) => {
                 for (const toolsetName of args.toolsets) {
-                    if (registeredToolsets.has(toolsetName))
+                    const registeredMeta = (0, registry_1.getToolsetMeta)(toolsetName);
+                    if (registeredToolsets.has(toolsetName)) {
+                        if (registeredMeta?.source === 'app') {
+                            continue;
+                        }
+                        continue;
+                    }
+                    if (enabledAppToolsets.has(toolsetName)) {
                         continue;
+                    }
                     if (mcpDeclared.kind === 'loaded' && mcpDeclared.declaredServerIds.has(toolsetName)) {
                         if (mcpDeclared.invalidServerIds.has(toolsetName)) {
                             addIssue(`${args.idPrefix}/toolsets/${sanitizeProblemIdSegment(toolsetName)}/mcp_declared_invalid`, `Invalid .minds/team.yaml: ${args.atPrefix}.toolsets contains an MCP toolset whose server config is invalid.`, [
@@ -554,9 +571,10 @@ exports.Team = Team;
                         continue;
                     }
                     addIssue(`${args.idPrefix}/toolsets/${sanitizeProblemIdSegment(toolsetName)}/missing`, `Invalid .minds/team.yaml: ${args.atPrefix}.toolsets contains an unknown toolset.`, [
-                        `Resolved ${args.atPrefix}.toolsets includes '${toolsetName}', but this toolset is neither registered nor declared in .minds/mcp.yaml.`,
-                        `Fix: change ${args.atPrefix}.toolsets to a valid toolset name, or declare MCP server '${toolsetName}' in .minds/mcp.yaml.`,
-                        `Tip: run team_mgmt_validate_mcp_cfg({}) to confirm MCP declarations are valid and loaded.`,
+                        `Resolved ${args.atPrefix}.toolsets includes '${toolsetName}', but this toolset is not currently registered in runtime registry and is not declared in .minds/mcp.yaml.`,
+                        `If '${toolsetName}' is expected from an enabled app, confirm the app is installed/enabled in this rtws and that its contributes.toolsets were loaded successfully.`,
+                        `Otherwise, fix ${args.atPrefix}.toolsets to a valid built-in/app toolset name, or declare MCP server '${toolsetName}' in .minds/mcp.yaml.`,
+                        `Tip: run team_mgmt_validate_mcp_cfg({}) for MCP checks, and inspect / refresh enabled apps if this toolset should come from an app.`,
                     ].join('\n'));
                 }
             };
@@ -871,6 +889,7 @@ exports.Team = Team;
     Team.TEAM_YAML_MODEL_PARAMS_OPENAI_KEYS = [
         'temperature',
         'max_tokens',
+        'service_tier',
         'top_p',
         'frequency_penalty',
         'presence_penalty',
@@ -942,6 +961,7 @@ exports.Team = Team;
                 verbosity: `Did you mean \`${modelParamsAt}.codex.verbosity\` (preferred for provider: codex) or \`${modelParamsAt}.openai.verbosity\`?`,
                 parallel_tool_calls: `Did you mean \`${modelParamsAt}.codex.parallel_tool_calls\` (preferred for provider: codex) or \`${modelParamsAt}.openai.parallel_tool_calls\`?`,
                 web_search: `Did you mean \`${modelParamsAt}.codex.web_search\` (preferred for provider: codex) or \`${modelParamsAt}.openai.web_search\`?`,
+                service_tier: `Did you mean \`${modelParamsAt}.codex.service_tier\` (preferred for provider: codex) or \`${modelParamsAt}.openai.service_tier\`?`,
                 temperature: `Did you mean \`${modelParamsAt}.codex.temperature\` / \`${modelParamsAt}.openai.temperature\` (or \`${modelParamsAt}.anthropic.temperature\`)?`,
                 top_p: `Did you mean \`${modelParamsAt}.codex.top_p\` / \`${modelParamsAt}.openai.top_p\` (or \`${modelParamsAt}.anthropic.top_p\`)?`,
                 max_tokens: `Did you mean \`${modelParamsAt}.max_tokens\` / \`${modelParamsAt}.general.max_tokens\` (provider-agnostic), or \`${modelParamsAt}.codex.max_tokens\` / \`${modelParamsAt}.openai.max_tokens\` / \`${modelParamsAt}.anthropic.max_tokens\`?`,
@@ -1606,6 +1626,15 @@ exports.Team = Team;
             asOptionalString(params.user, `${at2}.user`);
             asOptionalBoolean(params.parallel_tool_calls, `${at2}.parallel_tool_calls`);
             asOptionalBoolean(params.json_response, `${at2}.json_response`);
+            const serviceTier = params.service_tier;
+            if (serviceTier !== undefined &&
+                serviceTier !== 'auto' &&
+                serviceTier !== 'default' &&
+                serviceTier !== 'flex' &&
+                serviceTier !== 'scale' &&
+                serviceTier !== 'priority') {
+                throw new Error(`Invalid ${at2}.service_tier: expected auto|default|flex|scale|priority (got ${describeValueType(serviceTier)})`);
+            }
             const reasoningEffort = params.reasoning_effort;
             if (reasoningEffort !== undefined &&
                 reasoningEffort !== 'none' &&

package/dist/tools/app-reminders.js ADDED Viewed

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAppReminderOwnerRegistryName = buildAppReminderOwnerRegistryName;
+exports.ensureAppReminderOwnersRegistered = ensureAppReminderOwnersRegistered;
+exports.unregisterAppReminderOwnersForApps = unregisterAppReminderOwnersForApps;
+exports.applyAppReminderRequests = applyAppReminderRequests;
+const evt_registry_1 = require("../evt-registry");
+const driver_messages_1 = require("../shared/i18n/driver-messages");
+const runtime_language_1 = require("../shared/runtime-language");
+const tool_1 = require("../tool");
+const registry_1 = require("./registry");
+const APP_REMINDER_META_KEYS = new Set([
+    'kind',
+    'appId',
+    'ownerRef',
+    'managedByTool',
+    'source',
+    'updateExample',
+    'ownerMeta',
+]);
+const appReminderDescriptors = new Map();
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isJsonRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isAppReminderMeta(value) {
+    if (!isRecord(value))
+        return false;
+    if (value['kind'] !== 'app_reminder_owner')
+        return false;
+    if (typeof value['appId'] !== 'string' || value['appId'].trim() === '')
+        return false;
+    if (typeof value['ownerRef'] !== 'string' || value['ownerRef'].trim() === '')
+        return false;
+    if (typeof value['managedByTool'] !== 'string' || value['managedByTool'].trim() === '')
+        return false;
+    if (typeof value['source'] !== 'string' || value['source'].trim() === '')
+        return false;
+    if (typeof value['updateExample'] !== 'string' || value['updateExample'].trim() === '')
+        return false;
+    return true;
+}
+function normalizeInsertPosition(remindersLength, position) {
+    if (position === undefined)
+        return remindersLength;
+    if (!Number.isFinite(position))
+        return remindersLength;
+    const normalized = Math.floor(position);
+    if (normalized <= 0)
+        return 0;
+    if (normalized >= remindersLength)
+        return remindersLength;
+    return normalized;
+}
+function toManagedByTool(owner) {
+    const managedByTool = owner.managedByTool?.trim();
+    if (managedByTool && managedByTool.length > 0)
+        return managedByTool;
+    return owner.ref;
+}
+function toUpdateExample(owner) {
+    const updateExample = owner.updateExample?.trim();
+    if (updateExample && updateExample.length > 0)
+        return updateExample;
+    return `${toManagedByTool(owner)}({ ... })`;
+}
+function buildDescriptor(params) {
+    return {
+        appId: params.appId,
+        ownerRef: params.owner.ref,
+        registryName: buildAppReminderOwnerRegistryName(params.appId, params.owner.ref),
+        managedByTool: toManagedByTool(params.owner),
+        source: toManagedByTool(params.owner),
+        updateExample: toUpdateExample(params.owner),
+    };
+}
+function buildAppReminderMeta(descriptor, ownerMeta) {
+    const baseMeta = {
+        kind: 'app_reminder_owner',
+        appId: descriptor.appId,
+        ownerRef: descriptor.ownerRef,
+        managedByTool: descriptor.managedByTool,
+        source: descriptor.source,
+        updateExample: descriptor.updateExample,
+    };
+    if (isJsonRecord(ownerMeta)) {
+        return { ...ownerMeta, ...baseMeta };
+    }
+    if (ownerMeta !== undefined) {
+        return { ...baseMeta, ownerMeta };
+    }
+    return baseMeta;
+}
+function extractOwnerMeta(meta) {
+    if (!isJsonRecord(meta)) {
+        return undefined;
+    }
+    const payloadEntries = Object.entries(meta).filter(([key]) => !APP_REMINDER_META_KEYS.has(key));
+    if (payloadEntries.length > 0) {
+        return Object.fromEntries(payloadEntries);
+    }
+    return meta['ownerMeta'];
+}
+function toReminderState(reminder) {
+    return {
+        content: reminder.content,
+        meta: extractOwnerMeta(reminder.meta),
+        echoback: reminder.echoback,
+    };
+}
+function findOwnedReminderEntries(dlg, descriptor, owner) {
+    const entries = [];
+    for (let index = 0; index < dlg.reminders.length; index += 1) {
+        const reminder = dlg.reminders[index];
+        if (!reminder || reminder.owner !== owner || !isAppReminderMeta(reminder.meta)) {
+            continue;
+        }
+        if (reminder.meta.appId !== descriptor.appId ||
+            reminder.meta.ownerRef !== descriptor.ownerRef) {
+            continue;
+        }
+        entries.push({ index, reminder });
+    }
+    return entries;
+}
+function fallbackRenderedReminder(reminder, reminderNo) {
+    const language = (0, runtime_language_1.getWorkLanguage)();
+    return {
+        type: 'transient_guide_msg',
+        role: 'assistant',
+        content: (0, driver_messages_1.formatReminderItemGuide)(language, reminderNo, reminder.content, {
+            meta: reminder.meta,
+        }),
+    };
+}
+async function persistAndPublishReminders(dlg) {
+    await dlg.dlgStore.persistReminders(dlg, dlg.reminders);
+    const reminderNoByIndex = (0, tool_1.computeReminderNoByIndex)(dlg.reminders);
+    const reminders = dlg.reminders.map((reminder, index) => ({
+        content: reminder.content,
+        meta: isRecord(reminder.meta) ? reminder.meta : undefined,
+        reminder_no: reminderNoByIndex.get(index),
+        echoback: (0, tool_1.reminderEchoBackEnabled)(reminder),
+    }));
+    const evt = { type: 'full_reminders_update', reminders };
+    (0, evt_registry_1.postDialogEvent)(dlg, evt);
+}
+function createAppReminderOwner(params) {
+    const { descriptor, resolveHostClient } = params;
+    const owner = {
+        name: descriptor.registryName,
+        async updateReminder(dlg, reminder) {
+            if (reminder.owner !== owner || !isAppReminderMeta(reminder.meta)) {
+                return { treatment: 'keep' };
+            }
+            try {
+                const client = resolveHostClient();
+                const result = await client.updateReminder(descriptor.appId, descriptor.ownerRef, {
+                    dialogId: dlg.id.selfId,
+                    reminder: toReminderState(reminder),
+                });
+                if (result.treatment !== 'update') {
+                    return result;
+                }
+                return {
+                    treatment: 'update',
+                    updatedContent: result.updatedContent ?? reminder.content,
+                    updatedMeta: result.updatedMeta !== undefined
+                        ? buildAppReminderMeta(descriptor, result.updatedMeta)
+                        : reminder.meta,
+                };
+            }
+            catch {
+                return { treatment: 'keep' };
+            }
+        },
+        async renderReminder(dlg, reminder, index) {
+            if (reminder.owner !== owner || !isAppReminderMeta(reminder.meta)) {
+                return fallbackRenderedReminder(reminder, index + 1);
+            }
+            try {
+                const client = resolveHostClient();
+                return await client.renderReminder(descriptor.appId, descriptor.ownerRef, {
+                    dialogId: dlg.id.selfId,
+                    reminder: toReminderState(reminder),
+                    reminderNo: index + 1,
+                    workLanguage: (0, runtime_language_1.getWorkLanguage)(),
+                });
+            }
+            catch {
+                return fallbackRenderedReminder(reminder, index + 1);
+            }
+        },
+    };
+    return owner;
+}
+function buildAppReminderOwnerRegistryName(appId, ownerRef) {
+    return `app/${appId}/${ownerRef}`;
+}
+function ensureAppReminderOwnersRegistered(params) {
+    for (const app of params.enabledApps) {
+        const reminderOwners = app.installJson.contributes?.reminderOwners ?? [];
+        const seenOwnerRefs = new Set();
+        for (const owner of reminderOwners) {
+            if (seenOwnerRefs.has(owner.ref)) {
+                throw new Error(`App '${app.appId}' declares duplicate reminder owner ref '${owner.ref}'`);
+            }
+            seenOwnerRefs.add(owner.ref);
+            const descriptor = buildDescriptor({ appId: app.appId, owner });
+            appReminderDescriptors.set(descriptor.registryName, descriptor);
+            if ((0, registry_1.getReminderOwner)(descriptor.registryName)) {
+                continue;
+            }
+            (0, registry_1.registerReminderOwner)(createAppReminderOwner({ descriptor, resolveHostClient: params.resolveHostClient }));
+        }
+    }
+}
+function unregisterAppReminderOwnersForApps(params) {
+    const appIdSet = new Set(params.appIds);
+    for (const [registryName, descriptor] of appReminderDescriptors.entries()) {
+        if (!appIdSet.has(descriptor.appId)) {
+            continue;
+        }
+        (0, registry_1.unregisterReminderOwner)(registryName);
+        appReminderDescriptors.delete(registryName);
+    }
+}
+async function applyAppReminderRequests(dlg, params) {
+    const client = params.resolveHostClient();
+    let changed = false;
+    for (const request of params.reminderRequests) {
+        const registryName = buildAppReminderOwnerRegistryName(params.appId, request.ownerRef);
+        const descriptor = appReminderDescriptors.get(registryName);
+        const owner = (0, registry_1.getReminderOwner)(registryName);
+        if (!descriptor || !owner) {
+            throw new Error(`App '${params.appId}' attempted to use unregistered reminder owner '${request.ownerRef}'`);
+        }
+        const ownedEntries = findOwnedReminderEntries(dlg, descriptor, owner);
+        const result = await client.applyReminder(params.appId, request.ownerRef, request, {
+            dialogId: dlg.id.selfId,
+            ownedReminders: ownedEntries.map((entry) => toReminderState(entry.reminder)),
+        });
+        switch (result.treatment) {
+            case 'noop':
+                break;
+            case 'add': {
+                dlg.addReminder(result.reminder.content, owner, buildAppReminderMeta(descriptor, result.reminder.meta), normalizeInsertPosition(dlg.reminders.length, result.position), { echoback: result.reminder.echoback });
+                changed = true;
+                break;
+            }
+            case 'update': {
+                const target = ownedEntries[result.ownedIndex];
+                if (!target) {
+                    throw new Error(`App '${params.appId}' reminder owner '${request.ownerRef}' returned invalid ownedIndex=${result.ownedIndex}`);
+                }
+                dlg.updateReminder(target.index, result.reminder.content, buildAppReminderMeta(descriptor, result.reminder.meta), { echoback: result.reminder.echoback });
+                changed = true;
+                break;
+            }
+            case 'delete': {
+                const target = ownedEntries[result.ownedIndex];
+                if (!target) {
+                    throw new Error(`App '${params.appId}' reminder owner '${request.ownerRef}' returned invalid ownedIndex=${result.ownedIndex}`);
+                }
+                dlg.deleteReminder(target.index);
+                changed = true;
+                break;
+            }
+            default: {
+                const _exhaustive = result;
+                throw new Error(`Unsupported app reminder apply result: ${String(_exhaustive)}`);
+            }
+        }
+    }
+    if (changed) {
+        await persistAndPublishReminders(dlg);
+    }
+}

package/dist/tools/prompts/memory/en/errors.md ADDED Viewed

@@ -0,0 +1,155 @@
+# memory Error Handling
+## Template (Errors)
+### Error Chain (required)
+1. Trigger Condition
+2. Detection Signal
+3. Recovery Steps
+4. Success Criteria
+5. Escalation Path (optional)
+## Error Codes
+### MEMORY_ALREADY_EXISTS
+**Description:** Path already exists, cannot use `add_memory` to create new memory.
+**Cause:**
+- The path you're trying to add is already occupied by another memory
+**Solution:**
+- Use `replace_memory` to update existing memory
+- Or use a different path to create new memory
+**Example:**
+```
+Error:
+status: error
+error_code: MEMORY_ALREADY_EXISTS
+message: Path "project/todo" already exists, please use replace_memory to update
+```
+### MEMORY_NOT_FOUND
+**Description:** Path does not exist, cannot perform operation.
+**Cause:**
+- The memory path you're trying to access doesn't exist
+- The path was deleted or never created
+**Solution:**
+- For update/delete operations, first use `add_memory` to create
+- Check if the path is correct
+**Example:**
+```
+Error:
+status: error
+error_code: MEMORY_NOT_FOUND
+message: Path "project/todo" does not exist, please use add_memory to create first
+```
+### MEMORY_PATH_INVALID
+**Description:** Path format is invalid.
+**Cause:**
+- Path contains illegal characters
+- Path length exceeds limit
+**Solution:**
+- Ensure path only contains letters, numbers, underscores, slashes
+- Path length should not exceed 255 characters
+**Example:**
+```
+Error:
+status: error
+error_code: MEMORY_PATH_INVALID
+message: Path "project/*invalid*" contains illegal characters
+```
+### MEMORY_CONTENT_TOO_LARGE
+**Description:** Memory content is too large.
+**Cause:**
+- Single memory content exceeds 1MB limit
+**Solution:**
+- Compress content
+- Split into multiple memories
+- Use external storage (e.g., files)
+**Example:**
+```
+Error:
+status: error
+error_code: MEMORY_CONTENT_TOO_LARGE
+message: Content size 1.2MB exceeds 1MB limit
+```
+### MEMORY_STORAGE_ERROR
+**Description:** Storage error.
+**Cause:**
+- Insufficient disk space
+- Permission issues
+- File system error
+**Solution:**
+- Check disk space
+- Check file permissions
+- Retry operation
+**Example:**
+```
+Error:
+status: error
+error_code: MEMORY_STORAGE_ERROR
+message: Cannot write to storage, insufficient disk space
+```
+## Frequently Asked Questions
+### Q: Does memory auto-save?
+A: Yes, all memory operations are immediately persisted to disk. No manual save is needed.
+### Q: Is there a limit on the number of memories?
+A: There's no strict limit, but it's recommended to keep the number of memories reasonable (less than 100 recommended).
+### Q: Can other members see my memories?
+A: No, memory is a personal memory tool, only the current agent can access it. If you need to share with team members, please use team_memory.
+### Q: Will clear_memory delete all memories?
+A: Yes, `clear_memory` will delete all personal memories, this operation is irreversible. Please use with caution.
+### Q: Do memories expire?
+A: No, memories are permanently saved until explicitly deleted.
+### Q: How do I view all current memories?
+A: The agent can access all personal memories during response generation. You can directly ask the agent what memories it currently has.

package/dist/tools/prompts/memory/en/index.md ADDED Viewed

@@ -0,0 +1,47 @@
+# memory Personal Memory Tools Manual
+## Template (Index)
+### One-line Positioning
+- <What this toolset is for, in one sentence>
+### Tool List
+- <Enumerate core tools or point to Tools/Schema section>
+### 30-Second Quickstart
+1. <call ...>
+2. <observe ...>
+3. <next step ...>
+### Navigation
+- principles / tools / scenarios / errors
+### Boundaries vs Other Toolsets
+- <When to use this vs a sibling toolset>
+memory is Dominds' **personal memory toolset** for managing an agent's private memory:
+- **Privacy**: Memory is only visible to the current agent, not shared with other members
+- **Persistence**: Memory is persisted to disk and retained after conversation restarts
+- **Structured**: Supports organizing memory by path for easy categorization and retrieval
+## Quick Navigation
+| Topic                         | Description                                     |
+| ----------------------------- | ----------------------------------------------- |
+| [principles](./principles.md) | Core concepts, memory lifecycle, best practices |
+| [tools](./tools.md)           | Complete tool list and interface contracts      |
+| [scenarios](./scenarios.md)   | Common usage scenarios (copy-paste ready)       |
+| [errors](./errors.md)         | Error codes and solutions                       |
+## Status
+- Status: Implemented
+- Main implementation files:
+  - Tool implementation: `dominds/main/tools/mem.ts`
+  - Toolset metadata: `dominds/main/tools/builtins.ts`, `dominds/main/tools/registry.ts`

package/dist/tools/prompts/memory/en/principles.md ADDED Viewed

@@ -0,0 +1,79 @@
+# memory Principles and Core Concepts
+## Template (Principles)
+### Design Goals
+- <Goal 1>
+- <Goal 2>
+### Contract Principles
+- <Input/Output contract rules>
+### Safety & Boundaries
+- <Access constraints / guardrails>
+### Failure & Recovery
+- <What to do when a call fails>
+### Glossary
+- <Toolset-specific terms>
+## Memory Model
+The memory toolset uses a **path key-value storage** model:
+- **Path**: Unique identifier for the memory, similar to a file system path, e.g., `project/todo` or `user/preferences/theme`
+- **Content**: Actual content of the memory, can be arbitrary text
+## Tool Overview
+| Tool           | Function                                     |
+| -------------- | -------------------------------------------- |
+| add_memory     | Create new memory (when path does not exist) |
+| replace_memory | Update existing memory (when path exists)    |
+| drop_memory    | Delete memory                                |
+| clear_memory   | Clear all personal memory (irrecoverable)    |
+## Memory Lifecycle
+1. **Create (add)**: Use `add_memory` to create new memory
+2. **Read**: Agent can read existing memory during response generation
+3. **Update (replace)**: Use `replace_memory` to update memory content
+4. **Delete (drop)**: Use `drop_memory` to delete specific memory
+## Best Practices
+### 1. Path Naming Conventions
+- Use descriptive paths: `project/architecture`, `user/preferences/language`
+- Avoid special characters: Do not include `/`, `\`, `*`, etc. in paths
+- Use hierarchical structure: Organize memory by topic, e.g., `project/todo`, `project/done`
+### 2. Content Format
+- Keep content concise: Each memory should cover only one topic
+- Use structured format: Can use Markdown format to organize content
+- Regular cleanup: Periodically check and delete outdated memories
+### 3. Usage Scenarios
+- **Task persistence**: Save long-term task progress
+- **Context memory**: Save important information from conversation context
+- **Preference settings**: Save user preferences and configuration information
+## Relationship with Other Tools
+- **team_memory**: Team shared memory, visible to all members
+- **reminder**: Temporary reminder, session-level
+- **change_mind**: Update taskdoc (goals/constraints/progress)
+## Limitations and Notes
+1. Memory content has size limit (max 1MB per memory)
+2. Memory path cannot exceed 255 characters
+3. `clear_memory` will delete all memory, **irrecoverable**