@lmzhen/dsh-memory 0.44.0 → 0.46.0

package/lib/types/tools/index.js

@@ -0,0 +1,438 @@
+/**
+ * Model-facing memory tool and runtime-context memory snapshot.
+ * @module @deepseek-ai/dsh-tool-memory
+ */
+import { effectiveSessionPolicy } from '@lmzhen/dsh-evolution-approval';
+import z from '@deepseek-ai/schemastery';
+import { defineTool, registerEvolutionTool } from '@lmzhen/dsh-evolution-core/platform';
+import { clampedNumber, unwrapLive, MEMORY_GUIDANCE_SECTION_ORDER, payloadText } from '@lmzhen/dsh-evolution-core';
+import { resolveExecOrigins } from '@lmzhen/dsh-evolution-core/skills';
+export const name = 'tool-memory';
+/** Max characters of each echoed memory entry (single source for the Config default and the runtime slice). */
+const DEFAULT_ENTRY_PREVIEW_CHARS = 200;
+export const inject = ['tools', 'memory'];
+/**
+ * System-prompt memory guidance, aligned with Hermes `MEMORY_GUIDANCE`.
+ * Reached by the model every turn, so it is the place to steer behavior: what
+ * to save durably, what not to save, and how to phrase an entry. The tool
+ * schema description (`MEMORY_TOOL_DESCRIPTION`) carries the complementary
+ * operation-level guidance (add/replace/remove, batch, targets, when).
+ */
+export const MEMORY_GUIDANCE = 'You have durable memory across sessions. Save stable user preferences, '
+    + 'environment facts, conventions, and tool quirks with the `memory` tool. '
+    + 'The most valuable memory is one that stops the user correcting or reminding '
+    + 'you again, so user preferences and recurring corrections outrank procedural '
+    + 'task details.\n'
+    + 'Write entries as declarative facts, not instructions to yourself: '
+    + '"User prefers concise responses" (good); "Always respond concisely" (bad). '
+    + 'Imperative phrasing is re-read as a directive in later sessions and can '
+    + 'override the user\u2019s current request.\n'
+    + 'Do NOT save task progress, session outcomes, completed-work logs, PR/issue '
+    + 'numbers, commit SHAs, or anything stale within a week — use the session '
+    + 'query tool to recall past sessions instead. Reusable procedures belong in '
+    + 'a skill, not memory.';
+/**
+ * Tool-schema description for `memory`, aligned with Hermes `MEMORY_SCHEMA`.
+ * Carries the operation-level guidance: how to batch, when to save, the
+ * priority order, the target semantics, and what to skip. Reached only when
+ * the model is choosing/using the tool, so it complements the always-on
+ * `MEMORY_GUIDANCE` system prompt.
+ */
+export const MEMORY_TOOL_DESCRIPTION = 'Save durable facts to persistent memory that survive across sessions. '
+    + 'Memory is injected into future turns, so keep entries compact and high-signal.\n\n'
+    + 'HOW: make all changes in ONE call via an `operations` array (each item '
+    + '{action, facts?|content?, old_text?}). The batch applies atomically and the char '
+    + 'limit is checked on the final result — so one call can remove/replace stale '
+    + 'entries to free room AND add new ones. Use bare action/content/old_text '
+    + 'only for a single lone change.\n\n'
+    + 'WHEN: save proactively when the user states a preference, correction, or '
+    + 'personal detail, or you learn a stable fact about their environment, '
+    + 'conventions, or workflow. Priority: user preferences & corrections > '
+    + 'environment facts > procedures. The best memory stops the user repeating '
+    + 'themselves.\n\n'
+    + 'TARGETS: "user" = who the user is (name, role, preferences, style). '
+    + '"memory" = your notes (environment, conventions, tool quirks, lessons).\n\n'
+    + 'SKIP: trivial/obvious info, easily re-discovered facts, task progress, '
+    + 'completed-work logs, temporary TODO state. To recall a past session use '
+    + 'the session query tool, not memory. Reusable procedures belong in a skill, not '
+    + 'memory.';
+export const Config = z.object({
+    memoryEnabled: z.boolean().default(true),
+    // 0.3.18 (S4.6, T-13): lower bound 1 — `slice(0, negative)` returned the
+    // entry TAIL (semantics inversion) instead of an empty/full preview.
+    entryPreviewChars: z.number().min(1).default(DEFAULT_ENTRY_PREVIEW_CHARS).volatile(),
+});
+export async function apply(ctx, rawConfig = {}) {
+    // G1: suppress the platform's auto-generated settings page for this row (the
+    // family renders its own card from the registry). Probed, not assumed: a host
+    // without the capability still loads.
+    ctx.inject(['settings'], (injected) => {
+        const settings = injected.settings;
+        if (typeof settings?.configure !== 'function')
+            return;
+        // v46 S1.12b (finding 6-1): the owner argument is what the platform looks the presentation up by.
+        // Omitting it registers the suppression on the settings service's own fiber, so a row that
+        // re-mounts keeps a dead key and the auto form can return (platform precedent:
+        // settings.configure({ auto: false }, plugin.fiber) — settings/src/index.ts:266).
+        const disposer = settings.configure({ auto: false }, ctx.fiber);
+        if (typeof disposer === 'function')
+            ctx.effect(() => disposer, 'tool-memory: settings presentation');
+    });
+    // S1-B3: with the tool disabled, prior staged memory writes used to become
+    // permanently unreachable — approve fell through to "No replay runner
+    // registered" and released the claim back to `pending` with no way forward.
+    // The flag gates only the MODEL-FACING surface (tool + prompt injection);
+    // the trailing approval-runner inject below runs in BOTH modes, so a staged
+    // write from a pre-disable session is either replayed or EXPLICITLY refused
+    // — never orphaned in the pending view.
+    const memoryDisabled = rawConfig.memoryEnabled === false;
+    // V6-06 (0.3.35): assembly-time clamp — a 0/negative/NaN/±Infinity value
+    // falls back to the default instead of turning every echoed entry into a
+    // tail slice (`slice(0, negative)` inverted the preview) or an empty string
+    // (`slice(0, NaN)`). The schema `.min(1)` rejects 0/negative at load; this
+    // clamp also covers NaN/±Infinity.
+    // G3/S3.2 + G1 §8.3: the preview length is a VOLATILE row field — its reference carries
+    // the platform-resolved layers (schema default < bundle row < profile override) and is
+    // read at USE time, so a committed change applies to the next tool result with no
+    // restart and no watcher. The clamp covers NaN/±Infinity, which schemastery lets
+    // through; `.min(1)` rejects 0/negative at load (`slice(0, negative)` used to return
+    // the entry TAIL — the 0.3.18 inversion).
+    let previewClampWarned = false;
+    const previewChars = () => {
+        const value = unwrapLive(rawConfig.entryPreviewChars);
+        const clamped = clampedNumber(value, DEFAULT_ENTRY_PREVIEW_CHARS, { min: 1 });
+        if (!previewClampWarned && value !== undefined && clamped !== value) {
+            previewClampWarned = true;
+            ctx.logger.warn(`tool-memory: entryPreviewChars=${String(value)} is invalid; falling back to the default ${DEFAULT_ENTRY_PREVIEW_CHARS}`);
+        }
+        return clamped;
+    };
+    // 0.3.18 (S4.3, E-67): systemPrompt is an OPTIONAL service (soft probe, the
+    // M-7 doctrine — align with tool-skill-manage). A host without it still boots
+    // and gets the working memory tool; only guidance/snapshot are skipped.
+    // The mount-time renderContext() is also failure-tolerant: without a
+    // registered memory provider the snapshot degrades to empty (self-corrects
+    // at the first successful write through the applied-event listener).
+    // P2-13 (v15): the REAL upstream types (a zero-arg `text` closure satisfies
+    // PromptContext's `(ctx) => string`) — upstream signature drift now fails
+    // `tsc` at the mirror. (The hand-written shape was { section({name,order,
+    // text}): () => void; context({name,order,text}): () => void } | undefined.)
+    const systemPrompt = ctx.get('systemPrompt');
+    let snapshotText = '';
+    if (!memoryDisabled) {
+        try {
+            snapshotText = await ctx.memory.renderContext();
+        }
+        catch (error) {
+            ctx.logger.warn(`tool-memory: memory provider not ready at mount; snapshot starts empty until the first write: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (systemPrompt && !memoryDisabled) {
+        // G6-S2/W8: the guidance and the snapshot are LITERAL text contributions — a memory entry may
+        // contain the platform's `{{name}}` prompt syntax, and the platform throws on unknown references.
+        // interpolate:false keeps every brace verbatim (no escaping, no substitution) for BOTH the static
+        // guidance and the user-authored snapshot.
+        ctx.effect(() => systemPrompt.section({
+            name: 'evolution:memory-guidance',
+            order: MEMORY_GUIDANCE_SECTION_ORDER,
+            text: MEMORY_GUIDANCE,
+            interpolate: false,
+        }), 'tool-memory.memory-guidance');
+        ctx.effect(() => systemPrompt.context({
+            name: 'evolution:memory-snapshot',
+            order: 150,
+            text: () => snapshotText,
+            interpolate: false,
+        }), 'tool-memory.memory-snapshot');
+        // P2 fix: the snapshot refresh moved to the write sink (MemoryRegistry
+        // emits evolution/memory-applied after ANY successful write). Bypass paths —
+        // `/graph edit|delete memory:`, background review direct writes — refresh the
+        // model-visible snapshot here, not only the foreground tool's own callback.
+        const refreshSnapshot = async () => {
+            try {
+                snapshotText = await ctx.memory.renderContext();
+            }
+            catch {
+                // Snapshot refresh is best-effort; a stale snapshot self-corrects at the
+                // next successful refresh (the write itself already landed).
+            }
+        };
+        ctx.effect(() => ctx.on('evolution/memory-applied', () => { void refreshSnapshot(); }), 'tool-memory.snapshot-refresh');
+        // P2-07 (audit): cordis `inject` does not order sibling fibers — if the
+        // memory PROVIDER row applies after this row, the mount-time render throws
+        // (`memory: no provider registered`). The registry now announces the
+        // registration, so the snapshot refreshes on that event instead of a 500 ms
+        // retry that held a timer for up to 60 s.
+        ctx.effect(() => ctx.on('evolution/memory-provider-registered', () => { void refreshSnapshot(); }), 'tool-memory.snapshot-ready');
+    }
+    else if (!memoryDisabled) {
+        ctx.logger.warn('tool-memory: systemPrompt service not mounted; memory guidance and snapshot are not injected (the write tool still works)');
+    }
+    async function executeCore(normalized) {
+        // V24-20a (v24): element-level shape guard on the DIRECT entry. The
+        // approval replay runner calls executeCore with the STORED staged args
+        // and no tool schema in front of it, so `operations: [null]` used to
+        // reach applyBatch and throw a bare TypeError. (The tool-execute path
+        // rejects the same shape earlier, in its conflict pre-check.)
+        if (normalized.operations?.some((op) => {
+            const raw = op;
+            return raw === null || typeof raw !== 'object';
+        })) {
+            return { ok: false, message: 'operations 的每一项都必须是对象。', entries: [], chars: 0, limit: 0 };
+        }
+        // v30 TSM-03: field-level guards mirroring tool-skill-manage's scalar
+        // guard. The approval replay runner executes STORED args with no schema:
+        // a garbage STRING `target` (e.g. "memori") used to retarget the write
+        // to USER.md silently (fileFor maps anything ≠ 'memory' to the user
+        // profile), and non-string facts/old_text escaped as bare TypeErrors
+        // from inside the store.
+        // `unknown`-typed alias: the runtime value may violate the declared
+        // union (the replay channel executes stored args without a schema), so
+        // the comparison below must stay a REAL guard.
+        const target = normalized.target;
+        if (target !== 'memory' && target !== 'user') {
+            return { ok: false, message: `memory："target" 必须是 "memory" 或 "user"（收到 ${String(target)}）；拒绝写入。`, entries: [], chars: 0, limit: 0 };
+        }
+        for (const field of ['facts', 'old_text', 'content']) {
+            const value = normalized[field];
+            if (value !== undefined && value !== null && typeof value !== 'string') {
+                return { ok: false, message: `memory："${field}" 必须是字符串（收到 ${typeof value}）；拒绝写入。`, entries: [], chars: 0, limit: 0 };
+            }
+        }
+        // PLAN S3.6 (T2-03/A18): the OPERATION payload gets the same field gate, by INDEX and by FIELD.
+        // `content` is the documented alias of `facts` (T3-06) and was the one field the guards above
+        // did not name: a staged `operations: [{action:'add', content: 5}]` reached the store, threw, and
+        // the approval path answered the generic "Replay runner failed" while the record stayed pending
+        // forever. A payload defect can never be approved away, so the refusal says how to dispose of it.
+        for (const [index, operation] of (normalized.operations ?? []).entries()) {
+            for (const field of ['facts', 'content', 'old_text']) {
+                const value = operation[field];
+                if (value === undefined || value === null || typeof value === 'string')
+                    continue;
+                return { ok: false, message: `memory：operations[${index}].${field} 必须是字符串（收到 ${typeof value}）；拒绝写入 —— 重新批准无法修复载荷缺陷，请驳回该记录。`, entries: [], chars: 0, limit: 0 };
+            }
+        }
+        const result = normalized.operations
+            ? await ctx.memory.applyBatch(normalized.target, normalized.operations)
+            : await ctx.memory.applyBatch(normalized.target, [{ action: normalized.action ?? 'add', facts: normalized.facts, old_text: normalized.old_text }]);
+        // 0.3.18 (S4.2, E-20): the snapshot refresh happens ONLY in the
+        // memory-applied listener (single sink — MemoryRegistry emits after every
+        // successful write). A render here raced the listener's render and could
+        // leave a stale snapshot in the prompt.
+        return {
+            ok: result.ok,
+            message: result.message,
+            entries: result.entries.map(entry => entry.slice(0, previewChars())),
+            chars: result.chars,
+            limit: result.limit,
+        };
+    }
+    // PLAN-R2 P2-7 (2026-09-16): the store's per-action required-field contract,
+    // mirrored field-for-field so this pre-check and the store's own rejection
+    // cannot diverge. The effective judgment (memory-files and this file both
+    // resolve the pair through core's `payloadText`, T3-06/A34, then
+    // evolution-core's applyBatchCore enforces):
+    // add needs non-blank facts; remove/replace need non-blank old_text;
+    // replace additionally needs non-blank facts; an out-of-enum action is
+    // rejected loud (V6-25). Rejections below reuse the store's exact message
+    // text minus the on-disk entry preview (unknowable before the write).
+    const requiredFieldRejection = (op, position) => {
+        const body = payloadText(op);
+        if (op.action === 'add') {
+            return body ? null : `第 ${position} 个操作（add）：必须提供 facts。未应用任何操作。`;
+        }
+        if (op.action !== 'remove' && op.action !== 'replace') {
+            return `第 ${position} 个操作：未知动作「${String(op.action)}」（应为 add/remove/replace）。未应用任何操作。`;
+        }
+        if (!(op.old_text ?? '').trim()) {
+            return `第 ${position} 个操作（${op.action}）：必须提供 old_text。未应用任何操作。`;
+        }
+        if (op.action === 'replace' && !body) {
+            return `第 ${position} 个操作（replace）：必须提供 facts。`;
+        }
+        return null;
+    };
+    // S1-B3: gated on memoryDisabled — a disabled tool must not appear in the
+    // catalog. (The approval runner below registers in both modes.)
+    if (!memoryDisabled) {
+        registerEvolutionTool(ctx, defineTool({
+            name: 'memory',
+            description: MEMORY_TOOL_DESCRIPTION,
+            parameters: {
+                target: { type: 'string', enum: ['memory', 'user'], required: true },
+                action: { type: 'string', enum: ['add', 'replace', 'remove'] },
+                facts: { type: 'string' },
+                content: { type: 'string' },
+                old_text: { type: 'string' },
+                operations: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            action: { type: 'string', enum: ['add', 'replace', 'remove'], required: true },
+                            facts: { type: 'string' },
+                            content: { type: 'string' },
+                            old_text: { type: 'string' },
+                        },
+                    },
+                },
+            },
+            output: {
+                schema: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        ok: { type: 'boolean', required: true },
+                        message: { type: 'string', required: true },
+                        entries: { type: 'array', required: true, items: { type: 'string' } },
+                        chars: { type: 'integer', required: true },
+                        limit: { type: 'integer', required: true },
+                        pending_id: { type: 'string' },
+                    },
+                },
+                render: (_args, value) => [{ type: 'text', text: `${value.ok ? 'OK' : 'Error'}: ${value.message} (${value.chars}/${value.limit} chars)` }],
+            },
+            isConcurrencySafe: () => false,
+            // F-06: `session` is optional in the exec contract too — the
+            // defensive chaining below is only honest if the type says so.
+            async execute(args, exec) {
+                // facts and content are the same field under two names; a differing pair
+                // is ambiguous input, so fail loud instead of silently dropping one.
+                // T3-06/A34: only TWO non-blank bodies can differ. A blank member
+                // carries no payload, so `{facts: '', content: 'x'}` is one payload
+                // (core's `payloadText`), not an ambiguous pair — refusing it here while
+                // every other channel lands 'x' was the half-changed form of the same
+                // rule. Read through `payloadText` so a non-string member is skipped
+                // rather than trimmed (the replay channel passes stored args with no
+                // schema, and the field gate below owns that refusal).
+                const conflict = (a) => {
+                    const facts = payloadText({ facts: a.facts });
+                    const content = payloadText({ content: a.content });
+                    return facts !== '' && content !== '' && facts !== content;
+                };
+                // V24-20a (v24): element-level shape guard — `operations: [null]` used
+                // to reach `conflict` and throw a bare TypeError (`a.facts` on null).
+                // Same "schema is not a guarantee" posture as V8-09 (array container)
+                // and D-1 (scalar fields); the approval staged-args replay path does
+                // not pass the schema, so the guard is not redundant with it.
+                if (Array.isArray(args.operations)) {
+                    for (const op of args.operations) {
+                        const raw = op;
+                        if (raw === null || typeof raw !== 'object') {
+                            return { ok: false, message: 'operations 的每一项都必须是对象。', entries: [], chars: 0, limit: 0 };
+                        }
+                        if (conflict(op))
+                            return { ok: false, message: '每个操作只能提供 facts 或 content 之一（同一字段）：两者给了不同的值。', entries: [], chars: 0, limit: 0 };
+                    }
+                }
+                else if (conflict(args)) {
+                    return { ok: false, message: '只能提供 facts 或 content 之一（同一字段）：两者给了不同的值。', entries: [], chars: 0, limit: 0 };
+                }
+                // V7-07 (0.3.43): an EMPTY operations array is a no-op input — reject it
+                // BEFORE the approval gate (a "memory 0 ops" approval record would be
+                // staged and is meaningless to replay; the 0.3.37 V6-25 declaration
+                // assumed this check existed).
+                if (Array.isArray(args.operations) && args.operations.length === 0) {
+                    return { ok: false, message: '没有提供任何操作（operations 数组为空）。', entries: [], chars: 0, limit: 0 };
+                }
+                // F-07: a NON-ARRAY `operations` payload (garbage that slipped
+                // past the schema) used to fall into the single-operation branch, so the
+                // model received an error about the WRONG shape (e.g. "facts required")
+                // instead of the real one. Return a structured shape error before any
+                // normalization/approval; an ABSENT operations field keeps the single-op
+                // path (the documented bare action/content/old_text form).
+                if (args.operations !== undefined && !Array.isArray(args.operations)) {
+                    return { ok: false, message: '形状不合法：operations 必须是 {action, content?, old_text?} 对象的数组（单个操作时可省略 operations）。', entries: [], chars: 0, limit: 0 };
+                }
+                const target = args.target === 'user' ? 'user' : 'memory';
+                const normalized = Array.isArray(args.operations)
+                    ? { target, operations: args.operations }
+                    : { target, action: args.action ?? 'add', facts: payloadText(args), old_text: args.old_text };
+                // PLAN-R2 P2-7 (2026-09-16): existence pre-check of the per-action
+                // required fields BEFORE the approval gate, on BOTH paths — each
+                // operations[] element (store position = index + 1) and the normalized
+                // single operation (position 1). The store's required-field rejection
+                // (see requiredFieldRejection above) used to run only at EXECUTION, so
+                // an approval-enabled deployment staged such a write first and the
+                // approved replay then failed hard — V7-07 fixed the empty-operations
+                // sibling of this; this closes the per-operation gap the same way.
+                if (normalized.operations) {
+                    for (const [index, op] of normalized.operations.entries()) {
+                        const rejection = requiredFieldRejection(op, index + 1);
+                        if (rejection)
+                            return { ok: false, message: rejection, entries: [], chars: 0, limit: 0 };
+                    }
+                }
+                else {
+                    const rejection = requiredFieldRejection(normalized, 1);
+                    if (rejection)
+                        return { ok: false, message: rejection, entries: [], chars: 0, limit: 0 };
+                }
+                // F-329 parity for single operations (V4-15): only qualify the summary's
+                // target when it differs from the default 'memory', so a lone add to the
+                // default target reads "memory add" instead of the redundant "memory
+                // memory add". The batch form already gets this through normalizeSummary
+                // (evolution-approval, only for operations.length > 1) — apply the same
+                // single-word rule here for the single-op summary.
+                const targetLabel = target === 'memory' ? '' : `${target} `;
+                // Single-source origin resolution (S1-B1, on the rc.44 M2-2.3 table):
+                // core's resolveExecOrigins reads the session header origin AND the v37
+                // S2.2 review-channel session mark. This tool used to skip the mark
+                // half, so an inject-mode review's memory writes resolved as
+                // `foreground` — mislabeled in the approval queue and, under
+                // `stageForeground: false`, executing without staging at all.
+                const origin = resolveExecOrigins(exec).approval;
+                const sessionPolicy = effectiveSessionPolicy(ctx, exec.agent?.session);
+                const approval = ctx.get('evolutionApproval');
+                if (approval) {
+                    const decision = await approval.request({
+                        kind: 'memory',
+                        summary: `memory ${targetLabel}${Array.isArray(args.operations) ? `${args.operations.length} ops` : (args.action ?? 'add')}`,
+                        args: normalized,
+                        origin,
+                        // 0.3.20 (N-1): the session id rides along so the approval service can
+                        // DERIVE the platform override ('never' for unattended sessions); the
+                        // tool previously sent only the self-reported policy, which the
+                        // mounted platform approval service discards in favour of its own
+                        // derivation — leaving CI/cron writes stuck in staging.
+                        // F-06: full-depth optional chaining (see above).
+                        ...exec.agent?.session?.id ? { sessionId: exec.agent.session.id } : {},
+                        // V6-27 (0.3.40): the platform overrideOf resolves the policy from the
+                        // session's log view — the session OBJECT, not the id, is what it can probe.
+                        // F-06: full-depth optional chaining (see above).
+                        ...exec.agent?.session ? { session: exec.agent.session } : {},
+                        ...sessionPolicy !== undefined ? { sessionPolicy } : {},
+                    });
+                    if (decision.action === 'staged') {
+                        // 0.3.20 (N-1-followup): no `pending_id ?? ''` — absent stays absent
+                        // (mirrors the tool-skill-manage E-70 shape).
+                        return {
+                            ok: true,
+                            message: decision.message,
+                            entries: [],
+                            chars: 0,
+                            limit: 0,
+                            ...decision.pendingId !== undefined ? { pending_id: decision.pendingId } : {},
+                        };
+                    }
+                }
+                return await executeCore(normalized);
+            },
+        }));
+    }
+    ctx.inject(['evolutionApproval'], (approvalCtx) => {
+        const approval = approvalCtx.evolutionApproval;
+        // S1-B3: the runner exists in BOTH modes — replay when enabled, an explicit
+        // refusal when disabled — so a staged write can never become an unresolvable
+        // pending record ("No replay runner registered" bounce).
+        const dispose = memoryDisabled
+            ? approval.registerRunner('memory', () => Promise.resolve({
+                ok: false,
+                message: '拒绝：记忆工具已禁用（tool-memory memoryEnabled:false）—— 它的回放运行器无法执行这条暂存写入。请驳回该记录；若仍需要该写入，请在重新启用该工具后再暂存。',
+            }))
+            : approval.registerRunner('memory', args => executeCore(args));
+        approvalCtx.effect(() => dispose, memoryDisabled ? 'tool-memory.approval-runner-disabled' : 'tool-memory.approval-runner');
+    });
+}
+//# sourceMappingURL=index.js.map

package/locale/files/de.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Lokales Gedächtnis",
+    "description": "Merkt sich nützliche Fakten über Sitzungen hinweg und behält sie auf diesem Rechner."
+  }
+}

package/locale/files/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Local memory",
+    "description": "Remembers useful facts across sessions and keeps them on this computer."
+  }
+}

package/locale/files/es.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Memoria local",
+    "description": "Recuerda datos útiles entre sesiones y los guarda en este equipo."
+  }
+}

package/locale/files/fr.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Mémoire locale",
+    "description": "Retient les faits utiles d’une session à l’autre et les garde sur cet ordinateur."
+  }
+}

package/locale/files/ja.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "このパソコンのメモリ",
+    "description": "役に立つ知識をセッションをまたいで覚え、このパソコンに置いておく。"
+  }
+}

package/locale/files/pt.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Memória local",
+    "description": "Lembra fatos úteis entre sessões e os mantém neste computador."
+  }
+}

package/locale/files/ru.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Память на компьютере",
+    "description": "Запоминает полезные факты от сессии к сессии и хранит их на этом компьютере."
+  }
+}

package/locale/files/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "本地记忆",
+    "description": "记住有用的信息，换个会话也不会丢，都存在这台电脑上。"
+  }
+}

package/locale/tools/de.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Agenten-Gedächtnis",
+    "description": "Lässt den Agenten speichern, was er gelernt hat, und später wieder abrufen."
+  }
+}

package/locale/tools/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Agent memory",
+    "description": "Lets the agent save and recall what it learned."
+  }
+}

package/locale/tools/es.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Memoria del agente",
+    "description": "El agente guarda y recupera lo que aprende."
+  }
+}

package/locale/tools/fr.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Mémoire de l’agent",
+    "description": "Permet à l’agent d’enregistrer ce qu’il a appris et de le retrouver."
+  }
+}

package/locale/tools/ja.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "エージェントのメモリ",
+    "description": "エージェントが学んだことを保存し、あとから思い出せる。"
+  }
+}

package/locale/tools/pt.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Memória do agente",
+    "description": "Deixa o agente salvar e lembrar o que aprendeu."
+  }
+}

package/locale/tools/ru.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Память агента",
+    "description": "Агент может сохранять и вспоминать то, что узнал."
+  }
+}

package/locale/tools/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "智能体记忆",
+    "description": "让智能体把学到的东西存下来，需要时再取。"
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-memory",
   "description": "Memory provider registry for self-evolution (community build)",
-  "version": "0.44.0",
+  "version": "0.46.0",
   "publishConfig": {
     "access": "public"
   },
@@ -19,16 +19,30 @@
       "default": "./lib/index.js"
     },
     "./package.json": "./package.json",
-    "./locale/*.json": "./locale/*.json"
+    "./locale/*.json": "./locale/*.json",
+    "./files": {
+      "types": "./lib/types/files/index.d.ts",
+      "default": "./lib/files/index.js"
+    },
+    "./files/locale/*.json": "./locale/files/*.json",
+    "./tools": {
+      "types": "./lib/types/tools/index.d.ts",
+      "default": "./lib/tools/index.js"
+    },
+    "./tools/locale/*.json": "./locale/tools/*.json"
   },
   "files": [
-    "locale/*.json",
+    "lib/**/*.js",
     "lib/*.js",
-    "lib/types/**/*.d.ts"
+    "lib/types/**/*.d.ts",
+    "locale/**/*.json",
+    "locale/*.json"
   ],
   "license": "MIT",
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.5"
+    "@deepseek-ai/schemastery": "^3.18.5",
+    "@lmzhen/dsh-evolution-core": "^0.46.0",
+    "@lmzhen/dsh-evolution-approval": "^0.46.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.5"