@max-null/dsh-memory 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Max-Null
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# dsh-memory
+
+一个面向 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 的**跨会话明文记忆插件**。遵循「一切皆插件」——它不修改 DSH 源码，声明 `name`/`inject`/`apply`，由 Loader 从 `cordis.yml` 加载。
+
+## 设计原则
+
+1. **人是所有者**：模型只能写入 `suggested` 状态的记忆，绝不自我提升；只有人工确认（`setStatus`）才能让记忆生效。
+2. **可观测先于精准**：每条记忆是明文，`memory_list` 随时可见、`memory_forget` 随时删除——不存在"静默暗礁"。
+3. **明文是人机共享的审计窗口**：记忆是可读文本，模型可自检其是否过期或出错（规划中的 v2）。
+4. **确定性且缓存安全**：BM25 关键词检索是存储的纯函数、无 LLM 调用；固定指引进 system-prompt section，`auto` 记忆进 context。
+
+## 用法
+
+```bash
+npm install @max-null/dsh-memory
+```
+
+在你的 `cordis.yml` 加一条（其余 storage / system-prompt / tools 由宿主已有；记忆的存储后端由插件自己注册）：
+
+```yaml
+- id: memory
+  name: '@max-null/dsh-memory'
+```
+
+## 提供的服务与工具
+
+- **服务** `ctx.memory`：`remember` / `list` / `search` / `forget` / `setStatus`
+- **工具**：`memory_save`、`memory_list`、`memory_search`、`memory_forget`
+- **注入**：`tool:memory` 指引 section + `memory:recall` 召回 context（`auto` 记忆，带 `[memory:<id>]` 来源标记）
+
+## 两层存储（global / project）
+
+记忆按 `namespace` 分两层物理存储，各落在独立的明文 JSON：
+
+| namespace | 默认位置 | 用途 |
+|---|---|---|
+| `global` | `$DSH_HOME/storages/memory.json` | 跨项目的个人偏好 |
+| `project` | `<cwd>/.dsh/storages/memory_project.json` | 跟随仓库的项目共识，可 git 分享 |
+
+两个根都可用 config 覆盖（`globalRoot` / `projectRoot`）。`memory_list` / `memory_search` 不带 `namespace` 过滤时会同时查两层。
+
+## 使用流程（人工确认闸门）
+
+```
+模型 memory_save  →  status: suggested（只是建议，未生效）
+人工 setStatus    →  status: auto（生效，自动进入每轮的 recall context）
+                    status: suggest（参考，不自动注入）
+memory_search     →  随时按关键词召回任意状态的记忆
+memory_forget     →  随时删除
+```
+
+模型**永远不能自我提升**一条记忆——`memory_save` 只写 `suggested`，只有人（或未来的 v2 自检）通过 `setStatus` 才能让它生效。这保证了记忆不是黑盒：人随时能看、能改、能删。
+
+## 为什么明文 + BM25，而不是向量检索
+
+向量检索的记忆本体是一串不可读的数字，过期信息会成为**无法观测、无法修复的静默暗礁**；BM25 + 明文让每一次召回都可解释、每一条记忆都可见可删。语义（向量）检索留作 v2 的可选项，且以"可观测 + 可修复"为门槛，而非时间表。
+
+明文还有一层**跟随仓库分享**的好处：`project` 命名空间的记忆落在项目文件夹内（`<cwd>/.dsh/storages/memory_project.json`），随 `git` 提交、分享给所有协作者；`global` 命名空间的记忆留在本地 `$DSH_HOME`。团队的共识（"本项目统一用 Vue3 `<script setup>`"）能沉淀进仓库，而不是散落在每个人的本地。FTS5 的 SQLite 二进制、向量的数字串，都无法这样"跟着仓库走"。
+
+## 开发
+
+```bash
+npm install
+npm run typecheck   # tsc 严格类型检查
+npm test            # vitest 单测
+npm run build       # 产出 dist/
+node scripts/verify-loader.mjs   # 用 Loader 端到端验证插件可加载
+```
+
+## 依赖（peerDependencies，由宿主提供）
+
+`@deepseek-ai/cordis`、`@deepseek-ai/dsh-storage`、`@deepseek-ai/dsh-storage-domain`、`@deepseek-ai/dsh-storage-json`、`@deepseek-ai/dsh-system-prompt`、`@deepseek-ai/dsh-tools`

package/dist/bm25.d.ts

@@ -0,0 +1,9 @@
+/**
+ * BM25 keyword scoring over plaintext memory records. A pure function of the
+ * store — no model call — so recall is deterministic and a miss is explainable
+ * as "no keyword match".
+ */
+/** Split text into lowercase terms: English/number runs stay whole, each CJK ideograph its own term. */
+export declare function tokenize(text: string): string[];
+/** Score one query against each document with BM25, in document order. */
+export declare function bm25Scores(query: string, docs: readonly string[]): number[];

package/dist/bm25.js

@@ -0,0 +1,42 @@
+/**
+ * BM25 keyword scoring over plaintext memory records. A pure function of the
+ * store — no model call — so recall is deterministic and a miss is explainable
+ * as "no keyword match".
+ */
+/** Split text into lowercase terms: English/number runs stay whole, each CJK ideograph its own term. */
+export function tokenize(text) {
+    return text.toLowerCase().match(/[a-z0-9]+|[\u3400-\u9fff]/g) ?? [];
+}
+const K1 = 1.2;
+const B = 0.75;
+/** Score one query against each document with BM25, in document order. */
+export function bm25Scores(query, docs) {
+    const queryTerms = tokenize(query);
+    const tokenized = docs.map(tokenize);
+    const documentFrequency = new Map();
+    for (const doc of tokenized) {
+        for (const term of new Set(doc)) {
+            documentFrequency.set(term, (documentFrequency.get(term) ?? 0) + 1);
+        }
+    }
+    const n = docs.length;
+    const totalLength = tokenized.reduce((sum, doc) => sum + doc.length, 0);
+    const averageLength = n === 0 ? 0 : totalLength / n;
+    return tokenized.map((doc) => {
+        let score = 0;
+        for (const term of queryTerms) {
+            let termFrequency = 0;
+            for (const candidate of doc) {
+                if (candidate === term)
+                    termFrequency++;
+            }
+            if (termFrequency === 0)
+                continue;
+            const frequency = documentFrequency.get(term) ?? 0;
+            const idf = Math.log(1 + (n - frequency + 0.5) / (frequency + 0.5));
+            const denominator = termFrequency + K1 * (1 - B + B * (doc.length / (averageLength || 1)));
+            score += idf * (termFrequency * (K1 + 1)) / denominator;
+        }
+        return score;
+    });
+}

package/dist/engine.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The memory service (`ctx.memory`): durable plaintext records over two
+ * storage roots — `global` in the harness home, `project` in the current
+ * project folder (`.dsh/`), so project memory follows the repository. A record
+ * is always created `suggested` and becomes effective only through `setStatus`.
+ */
+import { Service } from '@deepseek-ai/cordis';
+declare const memoryIdBrand: unique symbol;
+/** Opaque identity of one stored memory record. */
+export type MemoryId = string & {
+    readonly [memoryIdBrand]: never;
+};
+/** Brand a string as a {@link MemoryId} (compile-time only). */
+export declare function MemoryId(id: string): MemoryId;
+export type MemoryNamespace = 'global' | 'project';
+/** `suggested` is model-written; only a human confirmation promotes it. */
+export type MemoryStatus = 'suggested' | 'auto' | 'suggest';
+export interface MemoryRecord {
+    id: MemoryId;
+    namespace: MemoryNamespace;
+    status: MemoryStatus;
+    content: string;
+    keywords: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+export interface MemoryWrite {
+    content: string;
+    namespace?: MemoryNamespace;
+    keywords?: string[];
+}
+export interface MemoryFilter {
+    namespace?: MemoryNamespace;
+    status?: MemoryStatus;
+}
+export interface MemoryHit {
+    record: MemoryRecord;
+    score: number;
+}
+/** One durable memory change, emitted after the backend acknowledges the write. */
+export type MemoryChange = {
+    operation: 'remembered';
+    record: MemoryRecord;
+} | {
+    operation: 'forgotten';
+    id: MemoryId;
+} | {
+    operation: 'status';
+    id: MemoryId;
+    status: MemoryStatus;
+};
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        memory: MemoryEngine;
+    }
+    interface Events {
+        /** A memory record was created, deleted, or promoted/demoted. */
+        'memory/changed'(change: MemoryChange): void;
+    }
+}
+/** Engine configuration: the two storage roots, defaulted to home and project. */
+export interface MemoryConfig {
+    /** Root for `global` memories; defaults to `$DSH_HOME/storages`. */
+    globalRoot?: string;
+    /** Root for `project` memories; defaults to `<cwd>/.dsh/storages`. */
+    projectRoot?: string;
+}
+/**
+ * Cross-session plaintext memory over the storage hub, split by namespace:
+ * `global` lives in the harness home, `project` in the project folder.
+ */
+export declare class MemoryEngine extends Service {
+    private readonly config;
+    static inject: string[];
+    private globalTable?;
+    private projectTable?;
+    constructor(ctx: import('@deepseek-ai/cordis').Context, config?: MemoryConfig);
+    protected [Service.init](): Promise<void>;
+    /** Create one record in `suggested` status — never self-promoting. */
+    remember(input: MemoryWrite): Promise<MemoryRecord>;
+    list(filter?: MemoryFilter): MemoryRecord[];
+    search(query: string, filter?: MemoryFilter): MemoryHit[];
+    forget(id: MemoryId): Promise<boolean>;
+    setStatus(id: MemoryId, status: MemoryStatus): Promise<MemoryRecord>;
+    private allRecords;
+    private recordsOf;
+    private tableFor;
+    private requireTable;
+}
+export {};

package/dist/engine.js

@@ -0,0 +1,158 @@
+/**
+ * The memory service (`ctx.memory`): durable plaintext records over two
+ * storage roots — `global` in the harness home, `project` in the current
+ * project folder (`.dsh/`), so project memory follows the repository. A record
+ * is always created `suggested` and becomes effective only through `setStatus`.
+ */
+import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { Service } from '@deepseek-ai/cordis';
+import { z } from 'zod';
+import { defineDomain, domainTable, DomainFacility } from '@deepseek-ai/dsh-storage-domain';
+import { JsonStorageBackend } from '@deepseek-ai/dsh-storage-json';
+import { bm25Scores } from "./bm25.js";
+/** Brand a string as a {@link MemoryId} (compile-time only). */
+export function MemoryId(id) {
+    return id;
+}
+const blockSchema = z.object({
+    namespace: z.enum(['global', 'project']),
+    status: z.enum(['suggested', 'auto', 'suggest']),
+    content: z.string(),
+    keywords: z.array(z.string()),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+});
+/** Shared table shape; the two domains differ only by name and backend route. */
+function memorySpec(name) {
+    return defineDomain({
+        name,
+        version: 1,
+        tables: { blocks: domainTable(blockSchema) },
+    });
+}
+function toRecord(id, block) {
+    return { id: MemoryId(id), ...block };
+}
+/** Harness-home root for `global` memories. */
+function globalRoot() {
+    return join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'storages');
+}
+/** Project-folder root for `project` memories — follows the repository. */
+function projectRoot() {
+    return join(process.cwd(), '.dsh', 'storages');
+}
+/**
+ * Cross-session plaintext memory over the storage hub, split by namespace:
+ * `global` lives in the harness home, `project` in the project folder.
+ */
+export class MemoryEngine extends Service {
+    config;
+    static inject = ['storage'];
+    globalTable;
+    projectTable;
+    constructor(ctx, config = {}) {
+        super(ctx, 'memory');
+        this.config = config;
+    }
+    async [Service.init]() {
+        const globalBackend = new JsonStorageBackend(this.config.globalRoot ?? globalRoot());
+        const projectBackend = new JsonStorageBackend(this.config.projectRoot ?? projectRoot());
+        this.ctx.storage.backend.register('memory-global', globalBackend);
+        this.ctx.storage.backend.register('memory-project', projectBackend);
+        const facility = new DomainFacility(this.ctx, {
+            backend: 'memory-global',
+            routes: { memory_project: 'memory-project' },
+        });
+        const globalDomain = await facility.open(memorySpec('memory'));
+        const projectDomain = await facility.open(memorySpec('memory_project'));
+        this.ctx.effect(() => () => { void facility.closeAll(); }, 'memory.domainsClose');
+        this.globalTable = globalDomain.table('blocks');
+        this.projectTable = projectDomain.table('blocks');
+    }
+    /** Create one record in `suggested` status — never self-promoting. */
+    async remember(input) {
+        const namespace = input.namespace ?? 'global';
+        const table = this.tableFor(namespace);
+        const id = randomUUID();
+        const now = Date.now();
+        const block = {
+            namespace,
+            status: 'suggested',
+            content: input.content,
+            keywords: (input.keywords ?? []).map(keyword => keyword.toLowerCase()),
+            createdAt: now,
+            updatedAt: now,
+        };
+        await table.put(id, block);
+        const record = toRecord(id, block);
+        this.ctx.emit('memory/changed', { operation: 'remembered', record });
+        return record;
+    }
+    list(filter) {
+        const records = this.allRecords(filter?.namespace);
+        return records.filter(record => (filter?.status === undefined || record.status === filter.status));
+    }
+    search(query, filter) {
+        const records = this.list(filter);
+        const docs = records.map(record => `${record.content} ${record.keywords.join(' ')}`);
+        const scores = bm25Scores(query, docs);
+        return records
+            .map((record, index) => ({ record, score: scores[index] ?? 0 }))
+            .filter(hit => hit.score > 0)
+            .sort((left, right) => right.score - left.score);
+    }
+    async forget(id) {
+        if (await this.requireTable('global').delete(id)) {
+            this.ctx.emit('memory/changed', { operation: 'forgotten', id });
+            return true;
+        }
+        if (await this.requireTable('project').delete(id)) {
+            this.ctx.emit('memory/changed', { operation: 'forgotten', id });
+            return true;
+        }
+        return false;
+    }
+    async setStatus(id, status) {
+        const global = this.requireTable('global').get(id);
+        if (global !== undefined) {
+            const updated = { ...global, status, updatedAt: Date.now() };
+            await this.requireTable('global').put(id, updated);
+            const record = toRecord(id, updated);
+            this.ctx.emit('memory/changed', { operation: 'status', id, status });
+            return record;
+        }
+        const project = this.requireTable('project').get(id);
+        if (project !== undefined) {
+            const updated = { ...project, status, updatedAt: Date.now() };
+            await this.requireTable('project').put(id, updated);
+            const record = toRecord(id, updated);
+            this.ctx.emit('memory/changed', { operation: 'status', id, status });
+            return record;
+        }
+        throw new Error(`cannot set status of unknown memory '${id}'`);
+    }
+    allRecords(namespace) {
+        if (namespace === 'project')
+            return this.recordsOf(this.requireTable('project'));
+        if (namespace === 'global')
+            return this.recordsOf(this.requireTable('global'));
+        return [
+            ...this.recordsOf(this.requireTable('global')),
+            ...this.recordsOf(this.requireTable('project')),
+        ];
+    }
+    recordsOf(table) {
+        return [...table.entries()].map(([id, block]) => toRecord(id, block));
+    }
+    tableFor(namespace) {
+        return this.requireTable(namespace);
+    }
+    requireTable(namespace) {
+        const table = namespace === 'global' ? this.globalTable : this.projectTable;
+        if (table === undefined)
+            throw new Error('memory engine is not started yet');
+        return table;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `dsh-memory`: a cross-session, deterministic, human-owned memory plugin for
+ * the DeepSeek Harness. Load it in `cordis.yml` beside the storage, storage
+ * domain, system prompt, and tools plugins; it registers `ctx.memory`, four
+ * model tools, a stable guidance section, and a recall context.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryConfig } from './engine.ts';
+export { MemoryEngine } from './engine.ts';
+export type { MemoryChange, MemoryConfig, MemoryFilter, MemoryHit, MemoryNamespace, MemoryRecord, MemoryStatus, MemoryWrite, } from './engine.ts';
+export { MemoryId } from './engine.ts';
+export { bm25Scores, tokenize } from './bm25.ts';
+export declare const name = "dsh-memory";
+export declare const inject: string[];
+export declare function apply(ctx: Context, config?: MemoryConfig): Promise<void>;

package/dist/index.js

@@ -0,0 +1,156 @@
+/**
+ * `dsh-memory`: a cross-session, deterministic, human-owned memory plugin for
+ * the DeepSeek Harness. Load it in `cordis.yml` beside the storage, storage
+ * domain, system prompt, and tools plugins; it registers `ctx.memory`, four
+ * model tools, a stable guidance section, and a recall context.
+ */
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { MemoryEngine } from "./engine.js";
+export { MemoryEngine } from "./engine.js";
+export { MemoryId } from "./engine.js";
+export { bm25Scores, tokenize } from "./bm25.js";
+export const name = 'dsh-memory';
+export const inject = ['storage', 'systemPrompt', 'tools'];
+const RECORD_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: { type: 'string', required: true },
+        namespace: { type: 'string', required: true, enum: ['global', 'project'] },
+        status: { type: 'string', required: true, enum: ['suggested', 'auto', 'suggest'] },
+        content: { type: 'string', required: true },
+        keywords: { type: 'array', required: true, items: { type: 'string' } },
+        createdAt: { type: 'number', required: true },
+        updatedAt: { type: 'number', required: true },
+    },
+};
+const HIT_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        record: { ...RECORD_SCHEMA, required: true },
+        score: { type: 'number', required: true },
+    },
+};
+function recordValue(record) {
+    return {
+        id: String(record.id),
+        namespace: record.namespace,
+        status: record.status,
+        content: record.content,
+        keywords: record.keywords,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+    };
+}
+function hitValue(hit) {
+    return { record: recordValue(hit.record), score: hit.score };
+}
+const GUIDANCE = 'Use memory tools for cross-session preferences, habits, and project conventions. '
+    + 'memory_save always records a suggestion (`suggested`) and never makes it effective itself — '
+    + 'a human confirms it. When earlier context may be relevant, call memory_search to recall it. '
+    + 'Every memory is plaintext and inspectable with memory_list; memory_forget removes one.';
+function recallText(memory) {
+    const auto = memory.list({ status: 'auto' });
+    if (auto.length === 0)
+        return '';
+    const lines = auto.map(record => `- [memory:${String(record.id)}] ${record.content}`);
+    return `Remembered preferences and conventions — apply these:\n${lines.join('\n')}`;
+}
+function renderJson(value) {
+    return [{ type: 'text', text: JSON.stringify(value) }];
+}
+function present(title, kind, rawInput) {
+    return { card: 'generic', title, kind, ...rawInput === undefined ? {} : { rawInput } };
+}
+export async function apply(ctx, config) {
+    await ctx.plugin(MemoryEngine, config);
+    const memory = ctx.get('memory');
+    if (memory === undefined)
+        throw new Error('memory engine failed to register');
+    ctx.systemPrompt.section({
+        name: 'tool:memory',
+        order: 115,
+        text: GUIDANCE,
+    });
+    ctx.systemPrompt.context({
+        name: 'memory:recall',
+        order: 50,
+        text: () => recallText(memory),
+    });
+    ctx.tools.register(defineTool({
+        name: 'memory_save',
+        description: 'Record one cross-session memory as a suggestion. It never becomes effective until a human confirms it; the model must not present a suggestion as confirmed.',
+        parameters: {
+            content: { type: 'string', required: true, description: 'Plaintext memory content.' },
+            namespace: { type: 'string', enum: ['global', 'project'], description: 'Where it applies; defaults to global.' },
+            keywords: { type: 'array', items: { type: 'string' }, description: 'Explicit searchable anchors for memory_search.' },
+        },
+        output: {
+            schema: RECORD_SCHEMA,
+            render: (_args, value) => renderJson(value),
+        },
+        execute(args, _exec) {
+            return memory.remember({
+                content: args.content,
+                ...args.namespace === undefined ? {} : { namespace: args.namespace },
+                ...args.keywords === undefined ? {} : { keywords: args.keywords },
+            }).then(recordValue);
+        },
+        presentCall: args => present('Save memory', 'other', args.content),
+    }));
+    ctx.tools.register(defineTool({
+        name: 'memory_list',
+        description: 'List every stored memory, optionally filtered by namespace or status. Every memory is plaintext and inspectable.',
+        parameters: {
+            namespace: { type: 'string', enum: ['global', 'project'], description: 'Restrict to one namespace.' },
+            status: { type: 'string', enum: ['suggested', 'auto', 'suggest'], description: 'Restrict to one status.' },
+        },
+        output: {
+            schema: { type: 'array', items: RECORD_SCHEMA },
+            render: (_args, value) => renderJson(value),
+        },
+        execute(args, _exec) {
+            return Promise.resolve(memory.list({
+                ...args.namespace === undefined ? {} : { namespace: args.namespace },
+                ...args.status === undefined ? {} : { status: args.status },
+            }).map(recordValue));
+        },
+        presentCall: () => present('List memories', 'read'),
+    }));
+    ctx.tools.register(defineTool({
+        name: 'memory_search',
+        description: 'Recall stored memories by keyword. Deterministic literal matching — a miss means no stored term matched the query.',
+        parameters: {
+            query: { type: 'string', required: true, description: 'Keyword query.' },
+            namespace: { type: 'string', enum: ['global', 'project'], description: 'Restrict to one namespace.' },
+            status: { type: 'string', enum: ['suggested', 'auto', 'suggest'], description: 'Restrict to one status.' },
+        },
+        output: {
+            schema: { type: 'array', items: HIT_SCHEMA },
+            render: (_args, value) => renderJson(value),
+        },
+        execute(args, _exec) {
+            return Promise.resolve(memory.search(args.query, {
+                ...args.namespace === undefined ? {} : { namespace: args.namespace },
+                ...args.status === undefined ? {} : { status: args.status },
+            }).map(hitValue));
+        },
+        presentCall: args => present('Search memory', 'read', args.query),
+    }));
+    ctx.tools.register(defineTool({
+        name: 'memory_forget',
+        description: 'Delete one stored memory by id. The human owner may remove any memory.',
+        parameters: {
+            id: { type: 'string', required: true, description: 'Exact memory id from memory_list or memory_search.' },
+        },
+        output: {
+            schema: { type: 'object', additionalProperties: false, properties: { deleted: { type: 'boolean', required: true } } },
+            render: (_args, value) => renderJson(value),
+        },
+        execute(args, _exec) {
+            return memory.forget(args.id).then(deleted => ({ deleted }));
+        },
+        presentCall: args => present('Forget memory', 'other', args.id),
+    }));
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@max-null/dsh-memory",
+  "version": "0.1.0",
+  "description": "Cross-session plaintext memory plugin for the DeepSeek Harness — deterministic BM25 recall, human-owned, no embeddings",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "deepseek",
+    "harness",
+    "dsh",
+    "memory",
+    "plugin",
+    "cordis"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Max-Null/dsh-memory.git"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-storage": ">=0.0.1-rc.1",
+    "@deepseek-ai/dsh-storage-domain": ">=0.0.1-rc.1",
+    "@deepseek-ai/dsh-storage-json": ">=0.0.1-rc.1",
+    "@deepseek-ai/dsh-system-prompt": ">=0.0.1-rc.1",
+    "@deepseek-ai/dsh-tools": ">=0.0.1-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.2",
+    "@deepseek-ai/dsh-storage": ">=0.0.1-rc.1",
+    "@deepseek-ai/dsh-storage-domain": ">=0.0.1-rc.1",
+    "@deepseek-ai/dsh-storage-json": ">=0.0.1-rc.1",
+    "@deepseek-ai/dsh-system-prompt": ">=0.0.1-rc.1",
+    "@deepseek-ai/dsh-tools": ">=0.0.1-rc.1",
+    "@types/node": "^26.2.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.1.0"
+  }
+}