dsh-context-memory 0.7.0 → 0.9.0

package/lib/candidates.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The candidate queue: statements worth offering, not worth remembering unasked.
+ *
+ * A capture rule can be generous or be safe. Explicit verbs ("记住…", "remember that…")
+ * are safe because the user asked; widening the patterns to ordinary declarative
+ * sentences is not, because the same shape produces "we use sqlite" and "we use two
+ * queues in this diagram". Writing both to the log would make recall worse than the
+ * narrower rule it replaced.
+ *
+ * So the wider rule produces a *question*. A candidate is proposed to the panel, and
+ * only a person turns it into a memory. The queue is append-only for the same reason the
+ * log is: "we offered this and you dismissed it" has to stay answerable, and a mutable
+ * queue would let a later run silently re-ask what was already declined.
+ *
+ * A dismissed candidate is remembered as dismissed rather than deleted, so the same
+ * sentence in the same session is not proposed again on every step.
+ *
+ * @module context-memory/candidates
+ */
+import type { Candidate, CandidateState, MemoryKind } from './types.js';
+/** What a caller proposes, before an id exists. */
+export interface ProposeInput {
+    text: string;
+    kind?: MemoryKind;
+    sessionId?: string;
+}
+/** Enough of `ContextMemory` to answer "is this already remembered". */
+export interface KnownMemories {
+    has(id: string): boolean;
+}
+export declare class CandidateQueue {
+    private readonly dir;
+    private readonly logPath;
+    /**
+     * The last parsed log, revalidated against the file's size and mtime on every read.
+     *
+     * Same reasoning as `MemoryStore`: the pre-step asks the queue one question per
+     * noticed statement (`propose` → `has`/`get`), and re-parsing an unchanged file for
+     * each of them is work that answers nothing new. A change on disk invalidates it, so
+     * two processes still agree.
+     */
+    private cached;
+    constructor(dir: string);
+    get path(): string;
+    private signature;
+    private append;
+    /**
+     * Fold the queue's log.
+     *
+     * The same shape as the memory fold, and the same reason: two processes reading one
+     * file must agree on which questions are still open. A decision naming a proposal that
+     * is not in the log is skipped rather than inventing a candidate.
+     *
+     * The returned array is shared with the cache: treat it as read-only.
+     */
+    all(): CandidateState[];
+    private parse;
+    pending(): CandidateState[];
+    get(id: string): CandidateState | undefined;
+    /**
+     * Offer a statement, unless it is already settled.
+     *
+     * Three suppressions, each for a different noise source: an active memory (the user
+     * already has it), a pending candidate (this step and the last one said the same
+     * thing), and a dismissed one (a question already answered — re-asking it every step
+     * is how a prompt becomes nagging).
+     */
+    propose(input: ProposeInput, known: KnownMemories): Candidate | undefined;
+    /** Record a decision. Returns false when there is no such open candidate. */
+    decide(id: string, status: 'accepted' | 'dismissed', at?: number): boolean;
+}

package/lib/candidates.js

@@ -0,0 +1,150 @@
+/**
+ * The candidate queue: statements worth offering, not worth remembering unasked.
+ *
+ * A capture rule can be generous or be safe. Explicit verbs ("记住…", "remember that…")
+ * are safe because the user asked; widening the patterns to ordinary declarative
+ * sentences is not, because the same shape produces "we use sqlite" and "we use two
+ * queues in this diagram". Writing both to the log would make recall worse than the
+ * narrower rule it replaced.
+ *
+ * So the wider rule produces a *question*. A candidate is proposed to the panel, and
+ * only a person turns it into a memory. The queue is append-only for the same reason the
+ * log is: "we offered this and you dismissed it" has to stay answerable, and a mutable
+ * queue would let a later run silently re-ask what was already declined.
+ *
+ * A dismissed candidate is remembered as dismissed rather than deleted, so the same
+ * sentence in the same session is not proposed again on every step.
+ *
+ * @module context-memory/candidates
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { memoryId, normaliseSubject } from './identity.js';
+function candidateId(text) {
+    // Same derivation the memory uses, so a candidate and the memory it becomes answer
+    // "is this the same statement" the same way. Two derivations would drift.
+    return memoryId(normaliseSubject(text), text.trim());
+}
+export class CandidateQueue {
+    dir;
+    logPath;
+    /**
+     * The last parsed log, revalidated against the file's size and mtime on every read.
+     *
+     * Same reasoning as `MemoryStore`: the pre-step asks the queue one question per
+     * noticed statement (`propose` → `has`/`get`), and re-parsing an unchanged file for
+     * each of them is work that answers nothing new. A change on disk invalidates it, so
+     * two processes still agree.
+     */
+    cached;
+    constructor(dir) {
+        this.dir = dir;
+        this.logPath = join(dir, 'candidates.jsonl');
+    }
+    get path() {
+        return this.logPath;
+    }
+    signature() {
+        try {
+            const stats = statSync(this.logPath);
+            return `${stats.size}:${stats.mtimeMs}`;
+        }
+        catch {
+            return null;
+        }
+    }
+    append(event) {
+        if (!existsSync(this.dir))
+            mkdirSync(this.dir, { recursive: true });
+        appendFileSync(this.logPath, `${JSON.stringify(event)}\n`, 'utf8');
+        this.cached = undefined;
+    }
+    /**
+     * Fold the queue's log.
+     *
+     * The same shape as the memory fold, and the same reason: two processes reading one
+     * file must agree on which questions are still open. A decision naming a proposal that
+     * is not in the log is skipped rather than inventing a candidate.
+     *
+     * The returned array is shared with the cache: treat it as read-only.
+     */
+    all() {
+        const key = this.signature();
+        if (this.cached !== undefined && this.cached.key === key)
+            return this.cached.value;
+        const value = key === null ? [] : this.parse();
+        this.cached = { key, value };
+        return value;
+    }
+    parse() {
+        const byId = new Map();
+        const lines = readFileSync(this.logPath, 'utf8').split('\n');
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index].trim();
+            if (line.length === 0)
+                continue;
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                // A torn final line is the expected shape after a crash; anything else is damage.
+                const rest = lines.slice(index + 1).every((remaining) => remaining.trim().length === 0);
+                if (rest)
+                    break;
+                throw new Error(`${this.logPath}: line ${index + 1} is not valid JSON`);
+            }
+            if (event.type === 'propose') {
+                byId.set(event.candidate.id, { ...event.candidate, status: 'pending' });
+                continue;
+            }
+            const target = byId.get(event.id);
+            if (target)
+                target.status = event.status;
+        }
+        return [...byId.values()];
+    }
+    pending() {
+        return this.all().filter((candidate) => candidate.status === 'pending');
+    }
+    get(id) {
+        return this.all().find((candidate) => candidate.id === id);
+    }
+    /**
+     * Offer a statement, unless it is already settled.
+     *
+     * Three suppressions, each for a different noise source: an active memory (the user
+     * already has it), a pending candidate (this step and the last one said the same
+     * thing), and a dismissed one (a question already answered — re-asking it every step
+     * is how a prompt becomes nagging).
+     */
+    propose(input, known) {
+        const text = input.text.trim();
+        if (text.length === 0)
+            return undefined;
+        const id = candidateId(text);
+        if (known.has(id))
+            return undefined;
+        const existing = this.get(id);
+        if (existing !== undefined)
+            return undefined;
+        const candidate = {
+            id,
+            text,
+            kind: input.kind ?? 'fact',
+            proposedAt: Date.now(),
+        };
+        if (input.sessionId !== undefined)
+            candidate.sessionId = input.sessionId;
+        this.append({ type: 'propose', at: candidate.proposedAt, candidate });
+        return candidate;
+    }
+    /** Record a decision. Returns false when there is no such open candidate. */
+    decide(id, status, at = Date.now()) {
+        const target = this.get(id);
+        if (target === undefined || target.status !== 'pending')
+            return false;
+        this.append({ type: 'decide', at, id, status });
+        return true;
+    }
+}

package/lib/capture.d.ts

@@ -16,11 +16,32 @@
  *
  * @module context-memory/capture
  */
+import type { MemoryKind } from './types.js';
 import type { RememberInput } from './memory.js';
 /** One distilled statement ready for `memory.remember()`. */
 export type DistilledMemory = RememberInput & {
     sessionId: string;
 };
+/** A statement worth *offering*, not worth remembering unasked. */
+export interface CapturedCandidate {
+    text: string;
+    kind: MemoryKind;
+    sessionId: string;
+}
+/**
+ * Statements that look like durable facts but were not asked to be kept.
+ *
+ * These are deliberately **not** memories. The rules below are heuristics — "we use
+ * sqlite" reads like a fact, and so does "we use two queues" or a sentence quoted from
+ * somewhere else — and a heuristic that writes to the log is a heuristic that fills the
+ * log with things the user never said they wanted. A candidate is a question put to the
+ * user, which is the cheapest way to be generous without eroding what recall is worth.
+ *
+ * The bar is set by `technicalSignal`: without a token that looks like a name — `pnpm`,
+ * `node_modules`, `MySQL`, `@scope/pkg` — a sentence is ordinary conversation, and
+ * "今天用两个服务" must not become a memory.
+ */
+export declare function candidates(text: string, sessionId: string, explicit?: readonly string[]): CapturedCandidate[];
 /**
  * Extract remember-worthy statements from one incoming user message.
  *

package/lib/capture.js

@@ -16,6 +16,92 @@
  *
  * @module context-memory/capture
  */
+/**
+ * Statements that look like durable facts but were not asked to be kept.
+ *
+ * These are deliberately **not** memories. The rules below are heuristics — "we use
+ * sqlite" reads like a fact, and so does "we use two queues" or a sentence quoted from
+ * somewhere else — and a heuristic that writes to the log is a heuristic that fills the
+ * log with things the user never said they wanted. A candidate is a question put to the
+ * user, which is the cheapest way to be generous without eroding what recall is worth.
+ *
+ * The bar is set by `technicalSignal`: without a token that looks like a name — `pnpm`,
+ * `node_modules`, `MySQL`, `@scope/pkg` — a sentence is ordinary conversation, and
+ * "今天用两个服务" must not become a memory.
+ */
+export function candidates(text, sessionId, explicit = []) {
+    const already = new Set(explicit.map((statement) => statement.trim().toLowerCase()));
+    const seen = new Set();
+    const out = [];
+    for (const sentence of sentenceCandidates(text)) {
+        const normalized = sentence.text.trim();
+        if (normalized.length < 6 || normalized.length > 160)
+            continue;
+        const key = normalized.toLowerCase();
+        // An explicit "记住…" in the same message already covers this sentence; proposing it
+        // again would ask the user to confirm something they just asked for.
+        if (already.has(key) || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({ text: normalized, kind: sentence.kind, sessionId });
+        // Three per message is a ceiling, not a target: a message that trips four patterns is
+        // usually a message about something else, and a panel that offers ten rows at once
+        // gets ignored exactly like one that offers none.
+        if (out.length >= 3)
+            break;
+    }
+    return out;
+}
+/**
+ * A token that looks like a technology, a package, or a path.
+ *
+ * This is what separates "we use pnpm for this repo" from "我们用两个队列". Both are
+ * declarative; only the first names something a future reader could act on. Requiring an
+ * ASCII token of at least two characters is crude and deliberately so: a vocabulary list
+ * would go stale, and semantic judgment is the model's job, not a regex's.
+ */
+const TECHNICAL_SIGNAL = /[A-Za-z][A-Za-z0-9_.\-+]*[A-Za-z0-9]|\/[A-Za-z0-9_.-]+\//;
+/** A question is not a statement, whatever else it contains. */
+const QUESTION = /(?:\?|？)\s*$|(?:吗|么|呢)\s*[。.]?\s*$/;
+/** Openers that make a sentence an instruction to the agent, not a fact about the world. */
+const DIRECTIVE = /^(?:please\b|帮(?:我|忙)|请|麻烦|看一下|看看|检查|修改|修复|添加|实现|重构|运行|跑一下|add\b|fix\b|check\b|look\b|show\b|run\b|update\b|refactor\b|implement\b)/i;
+/** Sentence shapes that assert something stable about the project or the user. */
+const SHAPES = [
+    // English: we use X / this project builds with X / I rely on X
+    { pattern: /^(?:we|i|this project|the project|our team)\s+(?:use|uses|build with|builds with|rely on|relies on|depend on|depends on|test with|tests with)\s+/i, kind: 'fact' },
+    // English: we always/never/prefer X — a standing preference or a rule.
+    { pattern: /^(?:we|i)\s+(?:always|never|prefer|avoid|stick to)\b/i, kind: 'preference' },
+    { pattern: /^(?:don'?t|do not|never)\s+(?:use|commit|add|write)\b/i, kind: 'pitfall' },
+    { pattern: /^the\s+(?:build|test suite|package manager|project)\s+(?:uses|runs|is)\b/i, kind: 'fact' },
+    // Chinese: 我们用 X / 本项目用 X 构建 / 团队统一用 X
+    { pattern: /^(?:我们|我|团队|本项目|这个项目|该项目)?\s*(?:都|一直|统一|一律)?\s*用\s*\S/i, kind: 'fact' },
+    { pattern: /^(?:我们|我|团队|本项目|这个项目|该项目)?\s*(?:都|统一)?\s*(?:用|使用)\S+\s*(?:来)?\s*(?:构建|打包|管理|存|跑|测试|开发|部署|做)/, kind: 'fact' },
+    // Chinese: X 是 (我们的) 构建工具 / 包管理器 / 数据库 …
+    { pattern: /是(?:我们的|本项目的|这个项目的)?(?:构建工具|包管理器|测试框架|数据库|持久化|运行时|框架|语言)/, kind: 'fact' },
+    // Chinese: 我们习惯 / 偏好 / 倾向
+    { pattern: /^(?:我们|我)(?:习惯|倾向|偏好|喜欢|不喜欢)/, kind: 'preference' },
+    // Chinese: 不要用 X / 别碰 X / 禁止 X
+    { pattern: /^(?:不要|别|禁止|不能|不许)(?:再|直接)?\s*(?:用|使用|碰|提交|提交到|写|引入)/, kind: 'pitfall' },
+];
+function sentenceCandidates(text) {
+    const out = [];
+    for (const raw of text.split(/(?<=[。！？!?\n])/)) {
+        const sentence = raw.trim().replace(/[。.!！]+$/, '').trim();
+        if (sentence.length === 0)
+            continue;
+        if (QUESTION.test(raw.trim()))
+            continue;
+        if (DIRECTIVE.test(sentence))
+            continue;
+        if (!TECHNICAL_SIGNAL.test(sentence))
+            continue;
+        const shape = SHAPES.find((candidate) => candidate.pattern.test(sentence));
+        if (shape === undefined)
+            continue;
+        out.push({ text: sentence, kind: shape.kind });
+    }
+    return out;
+}
 /**
  * Extract remember-worthy statements from one incoming user message.
  *

package/lib/cli.js

@@ -7,7 +7,9 @@
  * @module context-memory/cli
  */
 import { parseArgs } from 'node:util';
+import { describeContradiction, describeGuard } from './guard.js';
 import { ContextMemory } from './memory.js';
+import { resolveProjectStore, userStoreDir } from './scope.js';
 export function run(argv) {
     const { positionals, values } = parseArgs({
         args: argv,
@@ -15,28 +17,38 @@ export function run(argv) {
         options: {
             subject: { type: 'string' },
             kind: { type: 'string' },
+            scope: { type: 'string' },
             source: { type: 'string' },
+            global: { type: 'boolean' },
         },
     });
-    const memory = new ContextMemory(process.cwd());
+    // The CLI runs outside a session, so its launch directory is the only working
+    // directory it can know. `resolveProjectStore` still climbs to the project root, which
+    // is what makes `cd packages/x && dsh-context-memory list` see the same log as the root.
+    const root = resolveProjectStore();
+    const memory = new ContextMemory(root, { userDir: userStoreDir() });
     const cmd = positionals[0] ?? 'list';
     switch (cmd) {
         case 'remember': {
             const text = positionals.slice(1).join(' ');
             if (text.trim().length === 0) {
-                console.log('Usage: dsh-context-memory remember "<statement>" [--subject <what it is about>]');
+                console.log('Usage: dsh-context-memory remember "<statement>" [--subject <what it is about>] [--global]');
                 return 1;
             }
+            // `--global` records a working preference that follows the user across projects;
+            // the default is the narrow claim, because most statements are about one checkout.
+            const scope = values['global'] === true || values['scope'] === 'user' ? 'user' : 'project';
             // `--subject` is what makes a conflict expressible from the command line: two
             // different statements about one thing stay separate records instead of folding.
             const stored = memory.remember({
                 text,
+                scope,
                 ...(values['subject'] !== undefined ? { subject: String(values['subject']) } : {}),
                 ...(values['kind'] !== undefined ? { kind: String(values['kind']) } : {}),
                 ...(values['source'] !== undefined ? { source: String(values['source']) } : {}),
             });
-            const guard = stored.guard ? ` (guard: ${stored.guard.command})` : ' (no check could be compiled)';
-            console.log(`Remembered ${stored.id}: ${stored.text}${guard}`);
+            const guard = stored.guard ? ` (check: ${describeGuard(stored.guard)})` : ' (no check could be compiled)';
+            console.log(`Remembered ${stored.id} [${stored.scope}]: ${stored.text}${guard}`);
             // A memory with no executable check is recorded, and the caller is told plainly
             // that nothing will verify it — rather than reporting a success that implies more.
             return 0;
@@ -48,8 +60,16 @@ export function run(argv) {
                 return 0;
             }
             for (const item of active) {
-                const mark = item.verification?.outcome === 'passed' ? '✓' : item.verification ? '✗' : '·';
-                console.log(`${mark} ${item.id}  ${item.text}`);
+                const mark = item.verification?.outcome === 'passed'
+                    ? '✓'
+                    : item.verification?.outcome === 'violated'
+                        ? '!'
+                        : item.verification ? '✗' : '·';
+                console.log(`${mark} ${item.id} [${item.scope ?? 'project'}]  ${item.text}`);
+            }
+            const contradicted = active.filter((item) => item.verification?.outcome === 'violated');
+            if (contradicted.length > 0) {
+                console.log(`\n${contradicted.length} memor${contradicted.length === 1 ? 'y' : 'ies'} contradicted by a check — not offered as guidance.`);
             }
             return 0;
         }
@@ -78,8 +98,12 @@ export function run(argv) {
                 console.log('A reason is required: a superseded memory is kept as the record of why it stopped being true.');
                 return 1;
             }
-            const ok = memory.forget(id, reason);
-            console.log(ok ? `Superseded ${id}: ${reason}` : `No memory with id ${id}`);
+            // `--scope` disambiguates the one case the id alone cannot: the same sentence held
+            // in both logs has one id and two rows, and retiring "the" memory would be whichever
+            // log the fold listed first.
+            const scope = values['scope'] === 'user' || values['scope'] === 'project' ? values['scope'] : undefined;
+            const ok = memory.forget(id, reason, scope === undefined ? {} : { scope });
+            console.log(ok ? `Superseded ${id}: ${reason}` : `No memory with id ${id}${scope === undefined ? '' : ` in the ${scope} log`}`);
             return ok ? 0 : 1;
         }
         case 'conflicts': {
@@ -103,6 +127,13 @@ export function run(argv) {
                 if (result.outcome === 'broken' && result.output.trim().length > 0) {
                     console.log(`            the check could not run: ${result.output.trim().split('\n')[0]}`);
                 }
+                // A check that ran and came back false reports no output of its own; without the
+                // operand it tested, "violated" is a verdict the reader cannot act on. The guard
+                // rides along on the result — looking it up here would re-fold the whole log once
+                // per violated memory, and the number of those is unbounded.
+                if (result.outcome === 'violated') {
+                    console.log(`            contradicted: ${describeContradiction(result.guard, result.output)}`);
+                }
             }
             console.log(`\npassed ${summary.passed}, violated ${summary.violated}, broken ${summary.broken}, uncheckable ${summary.uncheckable}`);
             if (summary.broken > 0) {
@@ -110,19 +141,67 @@ export function run(argv) {
             }
             return ContextMemory.exitCode(summary);
         }
+        case 'candidates': {
+            const pending = memory.candidates();
+            if (pending.length === 0) {
+                console.log('No candidates waiting. (These come from ordinary declarative statements; they are never remembered without being accepted.)');
+                return 0;
+            }
+            for (const candidate of pending) {
+                console.log(`${candidate.id}  [${candidate.kind}]  ${candidate.text}`);
+            }
+            console.log(`\n${pending.length} candidate${pending.length === 1 ? '' : 's'} — accept with \`accept <id>\`, decline with \`dismiss <id>\`.`);
+            return 0;
+        }
+        case 'accept': {
+            const id = positionals[1] ?? '';
+            if (id.length === 0) {
+                console.log('Usage: dsh-context-memory accept <candidate id> [--kind <kind>] [--global]');
+                return 1;
+            }
+            const scope = values['global'] === true || values['scope'] === 'user' ? 'user' : 'project';
+            const stored = memory.accept(id, {
+                scope,
+                ...(values['kind'] !== undefined ? { kind: String(values['kind']) } : {}),
+            });
+            if (stored === undefined) {
+                console.log(`No pending candidate with id ${id}`);
+                return 1;
+            }
+            console.log(`Remembered ${stored.id}: ${stored.text}`);
+            return 0;
+        }
+        case 'dismiss': {
+            const id = positionals[1] ?? '';
+            if (id.length === 0) {
+                console.log('Usage: dsh-context-memory dismiss <candidate id>');
+                return 1;
+            }
+            const ok = memory.dismiss(id);
+            console.log(ok ? `Dismissed ${id}` : `No pending candidate with id ${id}`);
+            return ok ? 0 : 1;
+        }
         case 'help':
         default:
             console.log('Usage: dsh-context-memory <command>');
             console.log('Commands:');
             console.log('  remember "<statement>"        record a memory and compile a check if possible');
             console.log('    --subject <what it is about>  make a later disagreeing statement a conflict');
+            console.log('    --scope <project|user>        which log to write (default project)');
+            console.log('    --global                      shorthand for --scope user');
             console.log('    --kind <fact|decision|preference|pitfall>');
             console.log('    --source <user|agent|plugin>');
-            console.log('  list                          active memories, with verification status');
+            console.log('  list                          active memories, with scope and verification status');
             console.log('  recall "<query>"              rank memories by relevance');
             console.log('  forget <id> "<reason>"        retire a memory, keeping the reason');
             console.log('  conflicts                     active memories that disagree');
+            console.log('  candidates                    statements noticed but not remembered');
+            console.log('  accept <candidate id>         turn a candidate into a memory');
+            console.log('  dismiss <candidate id>        decline a candidate, keeping the answer');
             console.log('  verify                        re-run every compiled check; exit 1 only on a real violation');
+            console.log(`\nproject log: ${memory.locations.project}`);
+            if (memory.locations.user)
+                console.log(`user log:    ${memory.locations.user}`);
             return 0;
     }
 }

package/lib/client/index.d.ts

@@ -8,30 +8,24 @@
  *
  * @module client
  */
-import type { ComponentType } from 'react';
+import type { Context } from '@deepseek-ai/cordis';
+import type { LocaleRuntime } from '@deepseek-ai/dsh-client-locale/client';
+import type { SlotRegistry } from '@deepseek-ai/dsh-client-ui-renderer/client';
+import { zh } from './locales.js';
 export declare const inject: string[];
-interface SlotsService {
-    inject(name: string, register: () => void): void;
-    register(options: {
-        name: string;
-        id: string;
-        order: number;
-        label: () => string;
-        locale: string;
-    }, component: ComponentType<{
-        t: (key: string, params?: Record<string, unknown>) => string;
-    }>): unknown;
-}
-interface ClientContext {
-    slots: SlotsService;
-    locale: {
-        register(ns: string, dicts: {
-            zh: unknown;
-            en: unknown;
-        }): () => void;
-        bind(ns: string): (key: string, params?: Record<string, unknown>) => string;
-    };
-    effect(callback: () => unknown, label?: string): unknown;
+type ClientContext = Context & {
+    slots: SlotRegistry;
+    locale: LocaleRuntime;
+};
+/**
+ * Declaring the namespace is what lets the registration below name it: the host's
+ * `LocaleNamespaceMap` is merge-extensible and `locale: NS` is checked against it,
+ * so an undeclared namespace does not type-check at all.
+ */
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        contextMemory: keyof typeof zh;
+    }
 }
 export declare function apply(ctx: ClientContext): void;
 export {};

package/lib/client/locales.d.ts

@@ -50,6 +50,17 @@ export declare const zh: {
     integration: string;
     autoCaptureLabel: string;
     recallInjectLabel: string;
+    memoryAdded: string;
+    memoryTextPlaceholder: string;
+    subjectPlaceholder: string;
+    forgotten: string;
+    confirmForget: string;
+    candidates: string;
+    candidatesHint: string;
+    accept: string;
+    dismiss: string;
+    candidateAccepted: string;
+    candidateDismissed: string;
 };
 /** English dictionary, checked complete against the zh key set. */
 export declare const en: typeof zh;

package/lib/client/locales.js

@@ -50,6 +50,17 @@ export const zh = {
     'integration': '集成',
     'autoCaptureLabel': '自动捕获:用户消息里的「记住…」「以后…」自动入库',
     'recallInjectLabel': '召回注入:每次请求前把相关记忆折进上下文',
+    'memoryAdded': '已记录',
+    'memoryTextPlaceholder': '要记住的内容，一句话说清',
+    'subjectPlaceholder': '留空则自动取主语',
+    'forgotten': '已遗忘',
+    'confirmForget': '这条记忆会被删除，且不再参与召回。',
+    'candidates': '待确认',
+    'candidatesHint': '这些是你说过、但没让我记的话。确认后才会进召回，不确认就一直留在这里。',
+    'accept': '记下',
+    'dismiss': '不用',
+    'candidateAccepted': '已记下',
+    'candidateDismissed': '已忽略',
 };
 /** English dictionary, checked complete against the zh key set. */
 export const en = {
@@ -92,4 +103,15 @@ export const en = {
     'integration': 'Integration',
     'autoCaptureLabel': 'Auto capture: "remember that…" statements land in the log',
     'recallInjectLabel': 'Recall injection: fold relevant memories into each request',
+    'memoryAdded': 'Memory added',
+    'memoryTextPlaceholder': 'What to remember, in one sentence',
+    'subjectPlaceholder': 'Leave empty to infer the subject',
+    'forgotten': 'Forgotten',
+    'confirmForget': 'This memory is deleted and no longer recalled.',
+    'candidates': 'Suggested',
+    'candidatesHint': 'Things you said that were not asked to be remembered. They only enter recall once you accept them.',
+    'accept': 'Remember it',
+    'dismiss': 'No thanks',
+    'candidateAccepted': 'Remembered',
+    'candidateDismissed': 'Dismissed',
 };

package/lib/client/view.d.ts

@@ -2,12 +2,19 @@
  * Pure rendering half of the contextMemory page. Uses shared UI kit.
  * @module client/view
  */
+import type { TranslateNS } from '@deepseek-ai/dsh-client-ui-slots';
 import type { ReactNode } from 'react';
 import type { MemoryState } from '../types.js';
-export type Translate = (key: string, params?: Record<string, unknown>) => string;
+/**
+ * The translate seat the host injects for this plugin's namespace, taken from the
+ * official type so the panel and its registration agree on one key domain.
+ */
+export type Translate = TranslateNS<'contextMemory'>;
 export interface PanelProps {
     t: Translate;
 }
 export declare function checkLabel(memory: MemoryState, t: Translate): string;
 export declare function provenance(memory: MemoryState): string;
+/** A row key that is unique across scopes, where the id alone is not. */
+export declare function memoryKey(memory: MemoryState): string;
 export declare function ContextMemoryPanel({ t }: PanelProps): ReactNode;