= {
+ health: payload.reme.connected
+ ? payload.reme.healthy
+ ? "Healthy"
+ : "Unhealthy"
+ : "Offline",
+ healthClass: payload.reme.healthy ? "good" : "bad",
+ phase: payload.runtime.phase,
+ documents,
+ sessions: payload.runtime.autoMemory.activeSessions,
+ endpoint: payload.endpoint,
+ version: health.version || "—",
+ capture: payload.runtime.autoMemory.enabled ? "Enabled" : "Disabled",
+ interval: `${payload.runtime.autoMemory.interval} turn${
+ payload.runtime.autoMemory.interval === 1 ? "" : "s"
+ }`,
+ queued: payload.runtime.autoMemory.queuedTurns,
+ dreamEnabled: payload.runtime.autoDream.enabled ? "Enabled" : "Disabled",
+ cron: payload.runtime.autoDream.cron,
+ timezone: payload.runtime.autoDream.timezone,
+ dreamResult: payload.runtime.autoDream.running
+ ? "Running…"
+ : payload.runtime.autoDream.lastResult || "Not run yet",
+ nextDream: payload.runtime.autoDream.nextRunAt || "—",
+ };
+ let html = STATUS_HTML.replace(
+ 'class="dot"',
+ `class="dot${payload.reme.connected ? " ok" : ""}"`,
+ ).replace(
+ "Connecting…",
+ payload.reme.connected ? "Connected" : "Unavailable",
+ );
+ for (const [key, value] of Object.entries(values)) {
+ html = html.replaceAll(`{{${key}}}`, escapeHtml(String(value)));
+ }
+ const activity = payload.runtime.autoMemory.recentActivity;
+ html = html.replace(
+ "{{activity}}",
+ activity.length
+ ? activity
+ .map(
+ (entry) =>
+ `Capture #${entry.id}${
+ entry.turns
+ } turn${entry.turns === 1 ? "" : "s"}${entry.status}${escapeHtml(
+ entry.completedAt || entry.startedAt,
+ )}
`,
+ )
+ .join("")
+ : 'Completed conversational turns will appear here.
',
+ );
+ const componentCards = Object.entries(components).flatMap(
+ ([group, entries]) => {
+ const instances = Object.entries(entries);
+ if (!instances.length) {
+ return [
+ `${escapeHtml(
+ group.replaceAll("_", " "),
+ )}Healthy
`,
+ ];
+ }
+ return instances.map(([name, details]) => {
+ const healthy =
+ details.is_started === true && details.is_healthy !== false;
+ const healthLabel =
+ details.is_started !== true
+ ? "Stopped"
+ : healthy
+ ? "Healthy"
+ : "Unhealthy";
+ const summary = Object.entries(details)
+ .filter(([key]) => !["is_started", "is_healthy"].includes(key))
+ .slice(0, 2)
+ .map(
+ ([key, value]) =>
+ `${escapeHtml(key.replaceAll("_", " "))}: ${escapeHtml(
+ String(value),
+ )}`,
+ )
+ .join(" · ");
+ return `${escapeHtml(
+ group.replaceAll("_", " "),
+ )} · ${escapeHtml(name)}${healthLabel}${summary}
`;
+ });
+ },
+ );
+ html = html.replace(
+ "{{components}}",
+ componentCards.join("") ||
+ 'No component diagnostics returned.
',
+ );
+ return html;
+}
+
+function escapeHtml(value: string): string {
+ return value.replace(
+ /[&<>"']/g,
+ (character) =>
+ ({
+ "&": "&",
+ "<": "<",
+ ">": ">",
+ '"': """,
+ "'": "'",
+ })[character] || character,
+ );
+}
diff --git a/typescript/src/openclaw/tools.ts b/integrations/openclaw/src/tools.ts
similarity index 97%
rename from typescript/src/openclaw/tools.ts
rename to integrations/openclaw/src/tools.ts
index d0e4aaac..157f8987 100644
--- a/typescript/src/openclaw/tools.ts
+++ b/integrations/openclaw/src/tools.ts
@@ -1,7 +1,7 @@
import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
import { Type } from "typebox";
+import type { ReMeClientLike } from "./reme/types.js";
-import type { ReMeClientLike } from "../core/types.js";
import type { OpenClawReMeConfig } from "./config.js";
/** Register the explicit search action advertised by the plugin manifest. */
diff --git a/typescript/tests/context.test.mjs b/integrations/openclaw/tests/context.test.mjs
similarity index 87%
rename from typescript/tests/context.test.mjs
rename to integrations/openclaw/tests/context.test.mjs
index 63e002d3..1cbebe47 100644
--- a/typescript/tests/context.test.mjs
+++ b/integrations/openclaw/tests/context.test.mjs
@@ -1,7 +1,7 @@
import assert from "node:assert/strict";
import test from "node:test";
-import { formatReMeContext } from "../dist/core/context.js";
+import { formatReMeContext } from "../dist/reme/context.js";
test("marks recalled memory as untrusted and prevents delimiter breakout", () => {
const context = formatReMeContext(
diff --git a/typescript/tests/openclaw.test.mjs b/integrations/openclaw/tests/openclaw.test.mjs
similarity index 72%
rename from typescript/tests/openclaw.test.mjs
rename to integrations/openclaw/tests/openclaw.test.mjs
index e41ef8f0..fd679a80 100644
--- a/typescript/tests/openclaw.test.mjs
+++ b/integrations/openclaw/tests/openclaw.test.mjs
@@ -9,7 +9,22 @@ import plugin, {
captureLastTurn,
openClawSessionId,
resolveOpenClawConfig,
-} from "../dist/openclaw/index.js";
+} from "../dist/index.js";
+import { createReMeStatusHandler } from "../dist/status-page.js";
+
+function responseRecorder() {
+ return {
+ body: "",
+ headers: new Map(),
+ statusCode: 0,
+ setHeader(name, value) {
+ this.headers.set(name, value);
+ },
+ end(body = "") {
+ this.body = String(body);
+ },
+ };
+}
test("normalizes OpenClaw configuration and stable session ids", () => {
const config = resolveOpenClawConfig(
@@ -215,6 +230,96 @@ test("runs one coalesced OpenClaw Auto Dream task", async () => {
await runtime.disposeAll();
});
+test("keeps status routes read-only and reports unhealthy components", async () => {
+ let dreamCalls = 0;
+ const runtime = {
+ async runDream() {
+ dreamCalls += 1;
+ },
+ snapshot() {
+ return {
+ phase: "running",
+ autoMemory: {
+ enabled: true,
+ interval: 5,
+ activeSessions: 0,
+ queuedTurns: 0,
+ recentActivity: [],
+ },
+ autoDream: {
+ enabled: true,
+ cron: "0 23 * * *",
+ timezone: "Asia/Shanghai",
+ running: false,
+ },
+ };
+ },
+ };
+ const handler = createReMeStatusHandler({
+ config: resolveOpenClawConfig({}, {}),
+ runtime,
+ client: {
+ async requestJob(job) {
+ if (job === "health_check") {
+ return {
+ ok: true,
+ metadata: {
+ health: {
+ healthy: false,
+ version: "test",
+ components: {
+ embedding_store: {
+ default: { is_started: true, is_healthy: false },
+ },
+ },
+ },
+ },
+ };
+ }
+ return { ok: true, metadata: { status: {} } };
+ },
+ },
+ });
+
+ const statusResponse = responseRecorder();
+ await handler(
+ { method: "GET", url: "/plugins/reme/status/api/status" },
+ statusResponse,
+ );
+ assert.equal(statusResponse.statusCode, 503);
+ assert.deepEqual(JSON.parse(statusResponse.body).reme, {
+ connected: true,
+ healthy: false,
+ health: {
+ health: {
+ healthy: false,
+ version: "test",
+ components: {
+ embedding_store: {
+ default: { is_started: true, is_healthy: false },
+ },
+ },
+ },
+ },
+ status: { status: {} },
+ error: "",
+ });
+
+ const pageResponse = responseRecorder();
+ await handler({ method: "GET", url: "/plugins/reme/status" }, pageResponse);
+ assert.equal(pageResponse.statusCode, 200);
+ assert.match(pageResponse.body, /class="metric bad">Unhealthy/);
+ assert.match(pageResponse.body, /class="bad">Unhealthy/);
+
+ const writeResponse = responseRecorder();
+ await handler(
+ { method: "POST", url: "/plugins/reme/status/api/dream" },
+ writeResponse,
+ );
+ assert.equal(writeResponse.statusCode, 404);
+ assert.equal(dreamCalls, 0);
+});
+
test("registers OpenClaw recall, capture, tool, and shutdown lifecycle", async () => {
const originalFetch = globalThis.fetch;
const calls = [];
@@ -232,6 +337,8 @@ test("registers OpenClaw recall, capture, tool, and shutdown lifecycle", async (
try {
const hooks = new Map();
const tools = [];
+ const routes = [];
+ const descriptors = [];
let service;
plugin.register({
pluginConfig: {
@@ -243,6 +350,16 @@ test("registers OpenClaw recall, capture, tool, and shutdown lifecycle", async (
registerTool(tool) {
tools.push(tool);
},
+ registerHttpRoute(route) {
+ routes.push(route);
+ },
+ session: {
+ controls: {
+ registerControlUiDescriptor(descriptor) {
+ descriptors.push(descriptor);
+ },
+ },
+ },
on(name, handler) {
hooks.set(name, handler);
},
@@ -252,6 +369,10 @@ test("registers OpenClaw recall, capture, tool, and shutdown lifecycle", async (
});
assert.equal(tools[0].name, "reme_search");
+ assert.equal(routes[0].path, "/plugins/reme/status");
+ assert.equal(routes[0].auth, "gateway");
+ assert.equal(descriptors[0].id, "reme");
+ assert.equal(descriptors[0].path, "/plugins/reme/status/");
await service.start();
const recalled = await hooks.get("before_prompt_build")(
{ prompt: "deployment" },
diff --git a/integrations/openclaw/tsconfig.json b/integrations/openclaw/tsconfig.json
new file mode 100644
index 00000000..65468743
--- /dev/null
+++ b/integrations/openclaw/tsconfig.json
@@ -0,0 +1,18 @@
+{
+ "compilerOptions": {
+ "declaration": true,
+ "declarationMap": true,
+ "forceConsistentCasingInFileNames": true,
+ "module": "NodeNext",
+ "moduleResolution": "NodeNext",
+ "noUncheckedIndexedAccess": true,
+ "outDir": "dist",
+ "rootDir": "src",
+ "skipLibCheck": true,
+ "sourceMap": true,
+ "strict": true,
+ "target": "ES2022",
+ "types": ["node"]
+ },
+ "include": ["src/**/*.ts"]
+}
diff --git a/plugins/auto-fin/README.md b/plugins/auto-fin/README.md
index 8012ce81..ba31c25e 100644
--- a/plugins/auto-fin/README.md
+++ b/plugins/auto-fin/README.md
@@ -17,7 +17,7 @@ through `plugins=["auto-fin"]`.
### 1. Install ReMe and Auto Fin
```bash
-python -m pip install "reme-ai[core]>=0.4.1.9"
+python -m pip install "reme-ai[core]>=0.4.1.12"
reme plugins install reme-auto-fin
```
@@ -59,7 +59,9 @@ reme start plugins='["auto-fin"]' \
service.backend=http
```
-Custom application configs must provide `agent_wrapper.default` and the `search` and `read` Jobs used by Auto Fin.
+Custom application configs must provide `agent_wrapper.default`, a `file_store.default` with an enabled tag index, and
+the `search`, `read`, `list_tags`, `frontmatter_read`, and `frontmatter_update` Jobs used by Auto Fin and automatic
+tagging.
## Pipeline
@@ -75,6 +77,8 @@ research Agent uses search + read on historical memory
validate historical wikilinks in code
↓
daily/YYYY-MM-DD/auto_fin.md
+ ↓
+generate memory tags; the background file watcher refreshes indexes
```
`auto_fin_data_step` signs and paginates the same endpoint used by the CLS website. It starts at the decision time and
@@ -92,7 +96,9 @@ workspace-relative Markdown targets. Missing, absolute, escaping, backslash, and
to their readable aliases.
Same-day reruns use the existing report as context and replace it with the revised result. The final write is atomic and
-refreshes the daily index. No JSONL, intermediate Markdown, or structured Agent output is written.
+refreshes the daily index. The workflow then runs `auto_tag_step` to update the generated report's memory-tag
+frontmatter; the normal background file watcher observes that source-file change and refreshes derived indexes. No
+JSONL, intermediate Markdown, or structured Agent output is written.
## Parameters
diff --git a/plugins/auto-fin/README_ZH.md b/plugins/auto-fin/README_ZH.md
index e7811bb4..222c312a 100644
--- a/plugins/auto-fin/README_ZH.md
+++ b/plugins/auto-fin/README_ZH.md
@@ -14,7 +14,7 @@ distribution：单个 `reme.plugins` entry point 暴露 `plugin.yaml`，其中
### 1. 安装 ReMe 和 Auto Fin
```bash
-python -m pip install "reme-ai[core]>=0.4.1.9"
+python -m pip install "reme-ai[core]>=0.4.1.12"
reme plugins install reme-auto-fin
```
@@ -54,7 +54,9 @@ reme start plugins='["auto-fin"]' \
service.backend=http
```
-自定义应用配置需要提供 `agent_wrapper.default`，以及 Auto Fin 使用的 `search` 和 `read` Jobs。
+自定义应用配置需要提供 `agent_wrapper.default`、启用 tag index 的 `file_store.default`，以及
+Auto Fin 和自动标签使用的 `search`、`read`、`list_tags`、`frontmatter_read` 和
+`frontmatter_update` Jobs。
## 流程
@@ -70,6 +72,8 @@ Research Agent 使用 search + read 检索历史记忆
代码校验历史 wikilink
↓
daily/YYYY-MM-DD/auto_fin.md
+ ↓
+生成记忆标签，由后台文件 watcher 刷新索引
```
`auto_fin_data_step` 使用财联社网页同源接口的签名和分页方式，从分析时刻开始向前翻页，直到完整覆盖严格的最近 24
@@ -82,8 +86,9 @@ daily/YYYY-MM-DD/auto_fin.md
Prompt 要求 Agent 只链接实际使用过的历史 Markdown；代码边界则独立保证只保留真实存在、相对
workspace 的 Markdown 目标。不存在、绝对路径、越界、带反斜杠和自引用的目标都会降级为可读 alias。
-同日重跑会参考当天已有报告并覆盖为修订结果。最终写入使用原子替换并刷新当天索引；流程不会写入 JSONL、中间 Markdown 或 Agent
-结构化输出。
+同日重跑会参考当天已有报告并覆盖为修订结果。最终写入使用原子替换并刷新当天索引，随后通过 `auto_tag_step`
+更新报告的记忆标签 frontmatter；常规后台文件 watcher 会观察该源文件变化并刷新派生索引。流程不会写入 JSONL、
+中间 Markdown 或 Agent 结构化输出。
## 参数
diff --git a/plugins/auto-fin/pyproject.toml b/plugins/auto-fin/pyproject.toml
index f09d4ea0..87107058 100644
--- a/plugins/auto-fin/pyproject.toml
+++ b/plugins/auto-fin/pyproject.toml
@@ -1,13 +1,13 @@
[project]
name = "reme-auto-fin"
-version = "0.1.2"
+version = "0.1.3"
description = "Auto Fin example plugin for ReMe."
readme = "README.md"
license = "Apache-2.0"
license-files = ["LICENSE"]
requires-python = ">=3.11"
dependencies = [
- "reme-ai>=0.4.1.9",
+ "reme-ai>=0.4.1.12",
]
[project.entry-points."reme.plugins"]
diff --git a/plugins/auto-fin/src/reme_auto_fin/merge.py b/plugins/auto-fin/src/reme_auto_fin/merge.py
index 2b5b8d1f..124bb934 100644
--- a/plugins/auto-fin/src/reme_auto_fin/merge.py
+++ b/plugins/auto-fin/src/reme_auto_fin/merge.py
@@ -104,6 +104,7 @@ class AutoFinMergeStep(AutoFinStep):
async def execute(self):
"""Research the selected news and persist the validated report."""
assert self.context is not None
+ self.context["changes"] = []
if self.context.get("auto_fin_skipped"):
return self.context.response
run_date = date.fromisoformat(str(self._required("auto_fin_date")))
@@ -131,6 +132,7 @@ class AutoFinMergeStep(AutoFinStep):
markdown = f"# {output.title}\n\n> {output.description}\n\n{output.body}\n\n"
markdown += "> 未接入可靠行情数据；本文只提供新闻研究和回顾线索，不提供收益、目标价或买卖建议。\n"
report = self._report_path(run_date)
+ change = "modified" if report.is_file() else "added"
_write(report, markdown)
await refresh_day_index(
SimpleNamespace(workspace_path=self.workspace_path),
@@ -138,6 +140,7 @@ class AutoFinMergeStep(AutoFinStep):
str(self.config_value("daily_dir")),
)
relative = report.relative_to(self.workspace_path).as_posix()
+ self.context["changes"] = [{"change": change, "path": relative}]
self.context["markdown_path"] = relative
self.context["auto_fin_digest_path"] = relative
self.context.response.answer = output.body
diff --git a/plugins/auto-fin/src/reme_auto_fin/plugin.yaml b/plugins/auto-fin/src/reme_auto_fin/plugin.yaml
index 8edb8f81..67c29516 100644
--- a/plugins/auto-fin/src/reme_auto_fin/plugin.yaml
+++ b/plugins/auto-fin/src/reme_auto_fin/plugin.yaml
@@ -43,6 +43,7 @@ application_defaults:
- backend: auto_fin_topic_step
- backend: auto_fin_merge_step
job_tools: [search, read]
+ - backend: auto_tag_step
auto_fin_cron:
backend: cron
diff --git a/plugins/auto-fin/tests/test_auto_fin.py b/plugins/auto-fin/tests/test_auto_fin.py
index 2815dd91..a273d68d 100644
--- a/plugins/auto-fin/tests/test_auto_fin.py
+++ b/plugins/auto-fin/tests/test_auto_fin.py
@@ -219,6 +219,7 @@ async def test_merge_writes_only_final_report_and_validates_historical_links(tmp
assert "missing.md" not in report and "outside.md" not in report
assert not (tmp_path / "daily" / "2026-08-10" / "auto_fin_news.md").exists()
assert not (tmp_path / "resource").exists()
+ assert context["changes"] == [{"change": "added", "path": "daily/2026-08-10/auto_fin.md"}]
assert response.metadata["source_paths"] == ["daily/2026-08-01/auto_fin.md"]
@@ -262,8 +263,10 @@ def test_plugin_config_has_default_topics_and_no_intermediate_index_step():
"auto_fin_data_step",
"auto_fin_topic_step",
"auto_fin_merge_step",
+ "auto_tag_step",
]
assert job["steps"][2]["job_tools"] == ["search", "read"]
+ assert job["steps"][3] == {"backend": "auto_tag_step"}
assert jobs["auto_fin_cron"]["cron"] == "0 18 * * *"
assert jobs["auto_fin_cron"]["steps"] == job["steps"]
assert (
diff --git a/plugins/beam-judge/README.md b/plugins/beam-judge/README.md
new file mode 100644
index 00000000..b953f210
--- /dev/null
+++ b/plugins/beam-judge/README.md
@@ -0,0 +1,3 @@
+# ReMe BEAM Judge
+
+Trusted BEAM scoring plugin. Install it alongside `plugins/beam` for a full benchmark run. Meta-ReMe candidate bundles must not include this plugin.
diff --git a/plugins/beam-judge/pyproject.toml b/plugins/beam-judge/pyproject.toml
new file mode 100644
index 00000000..0dff94b2
--- /dev/null
+++ b/plugins/beam-judge/pyproject.toml
@@ -0,0 +1,22 @@
+[project]
+name = "reme-beam-judge"
+version = "0.1.0"
+description = "Trusted BEAM judge plugin for ReMe."
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.11"
+dependencies = ["reme-ai[as]>=0.4.1.11", "json-repair", "numpy>=2.2.6"]
+
+[project.entry-points."reme.plugins"]
+beam-judge = "judge_beam"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["judge_beam*"]
+
+[tool.setuptools.package-data]
+judge_beam = ["plugin.yaml", "*.yaml"]
+
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
diff --git a/plugins/beam/src/judge_beam/__init__.py b/plugins/beam-judge/src/judge_beam/__init__.py
similarity index 68%
rename from plugins/beam/src/judge_beam/__init__.py
rename to plugins/beam-judge/src/judge_beam/__init__.py
index 7090e1ce..cf89af27 100644
--- a/plugins/beam/src/judge_beam/__init__.py
+++ b/plugins/beam-judge/src/judge_beam/__init__.py
@@ -1,4 +1,4 @@
-"""BEAM benchmark judge backend."""
+"""BEAM benchmark judge plugin."""
from .llm_judge import BeamRubricJudgeStep
diff --git a/plugins/beam/src/judge_beam/llm_judge.py b/plugins/beam-judge/src/judge_beam/llm_judge.py
similarity index 99%
rename from plugins/beam/src/judge_beam/llm_judge.py
rename to plugins/beam-judge/src/judge_beam/llm_judge.py
index fdadabbb..40e420eb 100644
--- a/plugins/beam/src/judge_beam/llm_judge.py
+++ b/plugins/beam-judge/src/judge_beam/llm_judge.py
@@ -253,6 +253,7 @@ class BeamRubricJudgeStep(BaseStep):
)
async def execute(self):
+ """Evaluate a BEAM response against its rubric."""
assert self.context is not None
llm_response: str = self.context.get("llm_response", "")
rubric: list[str] = self.context.get("rubric", [])
diff --git a/plugins/beam/src/judge_beam/llm_judge.yaml b/plugins/beam-judge/src/judge_beam/llm_judge.yaml
similarity index 100%
rename from plugins/beam/src/judge_beam/llm_judge.yaml
rename to plugins/beam-judge/src/judge_beam/llm_judge.yaml
diff --git a/plugins/beam-judge/src/judge_beam/plugin.yaml b/plugins/beam-judge/src/judge_beam/plugin.yaml
new file mode 100644
index 00000000..43f1d9e0
--- /dev/null
+++ b/plugins/beam-judge/src/judge_beam/plugin.yaml
@@ -0,0 +1,47 @@
+backends:
+ beam_rubric_judge_step: judge_beam.llm_judge:BeamRubricJudgeStep
+
+application_defaults:
+ jobs:
+ answer_judge:
+ backend: base
+ description: "BEAM rubric-based LLM-as-Judge"
+ parameters:
+ type: object
+ properties:
+ llm_response: {type: string}
+ rubric:
+ type: array
+ items: {type: string}
+ probing_question: {type: string, default: ""}
+ question_type: {type: string, default: ""}
+ required: [llm_response, rubric]
+ steps:
+ - backend: beam_rubric_judge_step
+ agent_wrapper: judge
+ components:
+ as_llm:
+ judge:
+ backend: ${LLM_BACKEND:-openai}
+ model: ${JUDGE_MODEL_NAME:-qwen3.7-max}
+ stream: false
+ context_size: 200000
+ max_retries: 5
+ retry_delay: 5.0
+ credential:
+ api_key: ${LLM_API_KEY:-}
+ base_url: ${LLM_BASE_URL:-}
+ parameters:
+ max_tokens: 65536
+ thinking_enable: false
+ agent_wrapper:
+ judge:
+ backend: agentscope
+ as_llm: judge
+ permission_mode: bypass
+ react_config: {max_iters: 1}
+ context_config:
+ trigger_ratio: 0.8
+ reserve_ratio: 0.1
+ tool_result_limit: 50000
+ model_config: {max_retries: 1}
diff --git a/plugins/beam/README.md b/plugins/beam/README.md
index fb2f9559..341cd79a 100644
--- a/plugins/beam/README.md
+++ b/plugins/beam/README.md
@@ -2,8 +2,8 @@
[中文说明](./README_ZH.md)
-This plugin owns the BEAM memory, agentic-answer and judge Steps, their prompts,
-and their Job defaults in `plugin.yaml`. ReMe's built-in `benchmark.yaml` owns the
+This plugin owns the BEAM memory and agentic-answer Steps and their Job defaults.
+The trusted judge Step, prompts and `answer_judge` Job live in `plugins/beam-judge`. ReMe's built-in `benchmark.yaml` owns the
shared evaluation Jobs and components. Dataset handling, the runner and results
remain in [`benchmark/beam`](../../benchmark/beam/README.md).
@@ -12,17 +12,19 @@ From the repository root, install ReMe and this plugin in editable mode before r
```bash
python -m pip install -e ".[as]"
reme plugins install ./plugins/beam --editable
+reme plugins install ./plugins/beam-judge --editable
reme plugins validate beam
+reme plugins validate beam-judge
python benchmark/beam/run.py
```
Editable installation registers the `beam` entry point while keeping source changes immediately
-visible. The runner selects the built-in `benchmark` preset and explicitly enables `beam` for
+visible. The runner selects the built-in `benchmark` preset and explicitly enables `beam` and `beam-judge` for
each Application. Installing the plugin makes it discoverable but does not enable it globally.
`plugin.yaml` registers backends and contributes the plugin-owned `auto_memory`,
-`agentic_answer` and `answer_judge` Job defaults. Start the installed plugin with
-`reme start config=benchmark plugins='["beam"]'`. The shared preset does not inherit
+`agentic_answer` Job defaults. Start a full benchmark application with
+`reme start config=benchmark plugins='["beam", "beam-judge"]'`. The shared preset does not inherit
`default`: only declared Jobs run, indexing is manual, and neither scheduled dream
nor the optional `auto_dream` Job is enabled.
The existing `auto_memory`, `agentic_answer`, `answer_judge`, `bench` and `judge`
@@ -31,8 +33,8 @@ still take precedence. Installing this plugin does not start an evaluation.
The shared answer base class lives in `reme.steps.benchmark.base_agentic_answer`.
The old core-owned `reme.steps.benchmark.beam` Python import path is removed.
-Custom Python callers should import memory, search and answer Steps from `reme_beam`, and the
-judge Step from `judge_beam`. After uninstalling,
+Custom Python callers should import memory, search and answer Steps from `reme_beam`, and install
+`beam-judge` before importing the judge Step from `judge_beam`. After uninstalling,
Applications and CLI services must omit the plugin until it is installed again.
Uninstallation never removes datasets, workspaces or results.
Restart an existing service after changing plugins.
diff --git a/plugins/beam/README_ZH.md b/plugins/beam/README_ZH.md
index 4d695715..86558936 100644
--- a/plugins/beam/README_ZH.md
+++ b/plugins/beam/README_ZH.md
@@ -2,7 +2,8 @@
[English](./README.md)
-插件包含 BEAM 的记忆、回答、评分 Step、提示词，以及 `plugin.yaml` 中对应的 Job 默认配置。
+插件包含 BEAM 的记忆、回答 Step 及对应 Job 默认配置。可信评分 Step、提示词和
+`answer_judge` Job 位于独立的 `plugins/beam-judge` 插件中。
ReMe 内置的 `benchmark.yaml` 负责公共评测 Job 和 Component；数据集处理、runner 和结果仍留在
[`benchmark/beam`](../../benchmark/beam/README_ZH.md)。
@@ -11,22 +12,24 @@ ReMe 内置的 `benchmark.yaml` 负责公共评测 Job 和 Component；数据集
```bash
python -m pip install -e ".[as]"
reme plugins install ./plugins/beam --editable
+reme plugins install ./plugins/beam-judge --editable
reme plugins validate beam
+reme plugins validate beam-judge
python benchmark/beam/run.py
```
editable 安装会注册 `beam` entry point，并让源码修改立即生效。runner 选择内置 `benchmark`
-配置，并为每个 Application 显式启用 `beam`。安装只让插件可被发现，不会在所有应用中全局启用。
+配置，并为每个 Application 显式启用 `beam` 和 `beam-judge`。安装只让插件可被发现，不会在所有应用中全局启用。
`plugin.yaml` 注册 backend，并通过 `application_defaults` 提供插件拥有的 `auto_memory`、
-`agentic_answer` 和 `answer_judge` Job。安装后使用
-`reme start config=benchmark plugins='["beam"]'`。公共评测配置不继承 `default`，只运行声明的 Job：
+`agentic_answer` Job。完整评测使用
+`reme start config=benchmark plugins='["beam", "beam-judge"]'`。公共评测配置不继承 `default`，只运行声明的 Job：
索引手动更新，dream 定时任务和可选的 `auto_dream`
均保持关闭。原有 `auto_memory`、`agentic_answer`、`answer_judge`、`bench`、`judge` 名称及模型环境变量
保持不变，显式应用参数和 CLI 覆盖仍优先。安装或启用插件不会自动开始评测。
共享回答基类位于 `reme.steps.benchmark.base_agentic_answer`。
原 `reme.steps.benchmark.beam` Python 导入路径已移除。自定义 Python 调用应从 `reme_beam`
-导入记忆、搜索和回答 Step，并从 `judge_beam` 导入评判 Step。
+导入记忆、搜索和回答 Step；安装 `beam-judge` 后再从 `judge_beam` 导入评判 Step。
卸载插件后，Application 和 CLI 服务必须移除插件选择，直到再次安装。
卸载不会删除数据集、工作区或结果。修改插件后需重启已有服务。
diff --git a/plugins/beam/pyproject.toml b/plugins/beam/pyproject.toml
index 2b35f5aa..82fec7f9 100644
--- a/plugins/beam/pyproject.toml
+++ b/plugins/beam/pyproject.toml
@@ -8,8 +8,6 @@ license-files = ["LICENSE"]
requires-python = ">=3.11"
dependencies = [
"reme-ai[as]>=0.4.1.11",
- "json-repair",
- "numpy>=2.2.6",
]
[project.entry-points."reme.plugins"]
@@ -17,11 +15,10 @@ beam = "reme_beam"
[tool.setuptools.packages.find]
where = ["src"]
-include = ["reme_beam*", "judge_beam*"]
+include = ["reme_beam*"]
[tool.setuptools.package-data]
reme_beam = ["plugin.yaml", "*.yaml"]
-judge_beam = ["*.yaml"]
[build-system]
requires = ["setuptools>=77", "wheel"]
diff --git a/plugins/beam/src/reme_beam/plugin.yaml b/plugins/beam/src/reme_beam/plugin.yaml
index 389653fc..cd2a1402 100644
--- a/plugins/beam/src/reme_beam/plugin.yaml
+++ b/plugins/beam/src/reme_beam/plugin.yaml
@@ -1,7 +1,6 @@
backends:
beam_auto_memory_step: reme_beam.auto_memory:BeamAutoMemoryStep
beam_agentic_answer_step: reme_beam.agentic_answer:BeamAgenticAnswerStep
- beam_rubric_judge_step: judge_beam.llm_judge:BeamRubricJudgeStep
beam_search_v2_step: reme_beam.search_v2:SearchV2Step
application_defaults:
@@ -51,37 +50,6 @@ application_defaults:
- backend: beam_agentic_answer_step
agent_wrapper: bench
- answer_judge:
- backend: base
- description: "BEAM rubric-based LLM-as-Judge: evaluate response against rubric criteria"
- watch_dirs: []
- watch_suffixes: []
- parameters:
- type: object
- properties:
- llm_response:
- type: string
- description: "The model's response to evaluate"
- rubric:
- type: array
- description: "List of rubric criteria to check"
- items:
- type: string
- probing_question:
- type: string
- description: "The original probing question"
- default: ""
- question_type:
- type: string
- description: "BEAM question type (e.g. event_ordering)"
- default: ""
- required:
- - llm_response
- - rubric
- steps:
- - backend: beam_rubric_judge_step
- agent_wrapper: judge
-
auto_memory:
backend: base
description: "Auto-memory: record conversation facts into a daily note"
@@ -116,5 +84,3 @@ application_defaults:
as_llm:
default:
max_retries: 5
- judge:
- retry_delay: 5.0
diff --git a/plugins/daily_paper/README.md b/plugins/daily_paper/README.md
index d7915c11..2d00849d 100644
--- a/plugins/daily_paper/README.md
+++ b/plugins/daily_paper/README.md
@@ -13,7 +13,7 @@ their Job configuration under `application_defaults`. Enable the installed plugi
### 1. Install ReMe and Daily Paper
```bash
-python -m pip install "reme-ai[core]>=0.4.1.9"
+python -m pip install "reme-ai[core]>=0.4.1.12"
reme plugins install reme-daily-paper
```
@@ -51,6 +51,10 @@ To run the Job once without starting a long-lived service:
reme start plugins='["daily-paper"]' job=daily_paper topics="Agent memory"
```
+Custom application configs must provide `agent_wrapper.default`, a `file_store.default` with an enabled tag index, and
+the `search`, `read`, `list_tags`, `frontmatter_read`, and `frontmatter_update` Jobs used by Daily Paper and automatic
+tagging.
+
## Pipeline
```text
@@ -64,7 +68,9 @@ download and parse arXiv PDFs, then write three Chinese analyses
↓
use search + read to connect prior memory and generate a brief
↓
-refresh the daily index and optionally send the brief to DingTalk
+generate memory tags; the background file watcher refreshes indexes
+ ↓
+optionally send the brief to DingTalk
```
`daily_paper_collect_step` concurrently reads the weekly and monthly rankings for the run date plus the strictly
@@ -81,8 +87,10 @@ PDFs and files without a text layer fail explicitly.
`daily_paper_digest_step` treats those three analyses as the factual source and receives only the read-only
`search` and `read` tools for linking earlier memory. Code validates historical wikilinks, appends links to all
-three source notes, and rebuilds the daily index. The optional `dingtalk_markdown_send_step` sends the final brief when
-conversation IDs are configured and otherwise skips without side effects.
+three source notes, and rebuilds the daily index. The workflow then runs `auto_tag_step` to update the memory-tag
+frontmatter of all three analyses and the final brief. The normal background file watcher observes those source-file
+changes and refreshes derived indexes before the optional `dingtalk_markdown_send_step` sends the brief. DingTalk
+delivery skips without side effects when conversation IDs are not configured.
## Parameters
diff --git a/plugins/daily_paper/README_ZH.md b/plugins/daily_paper/README_ZH.md
index 08d11bbd..6fd8c5ab 100644
--- a/plugins/daily_paper/README_ZH.md
+++ b/plugins/daily_paper/README_ZH.md
@@ -11,7 +11,7 @@ Step backend，并在 `application_defaults` 下提供 Job 配置；通过 `plug
### 1. 安装 ReMe 和每日论文插件
```bash
-python -m pip install "reme-ai[core]>=0.4.1.9"
+python -m pip install "reme-ai[core]>=0.4.1.12"
reme plugins install reme-daily-paper
```
@@ -47,6 +47,10 @@ curl -s http://127.0.0.1:2333/daily_paper \
reme start plugins='["daily-paper"]' job=daily_paper topics="Agent memory"
```
+自定义应用配置需要提供 `agent_wrapper.default`、启用 tag index 的 `file_store.default`，以及
+Daily Paper 和自动标签使用的 `search`、`read`、`list_tags`、`frontmatter_read` 和
+`frontmatter_update` Jobs。
+
## 流程
```text
@@ -60,7 +64,9 @@ RRF 排序后由 Agent 精选三篇
↓
使用 search + read 关联历史记忆并生成简报
↓
-写入当日索引，并按需发送到钉钉
+生成记忆标签，由后台文件 watcher 刷新索引
+ ↓
+按需发送到钉钉
```
`daily_paper_collect_step` 并发读取运行日期所在周和所在月的榜单，以及严格前一日的 Daily Papers。候选按 arXiv ID
@@ -73,8 +79,9 @@ RRF 排序后由 Agent 精选三篇
文本。三篇中文解读按精选顺序写入当天目录；扫描版或没有文本层的 PDF 会明确失败。
`daily_paper_digest_step` 以本次生成的三篇解读为事实来源，只开放只读的 `search` 和 `read` 来关联较早记忆。
-代码会校验历史 wikilink、追加三篇源笔记链接，并重建当日索引。可选的 `dingtalk_markdown_send_step` 在配置群会话后
-发送最终简报；未配置时无副作用跳过。
+代码会校验历史 wikilink、追加三篇源笔记链接，并重建当日索引。随后 `auto_tag_step` 会更新三篇解读及最终简报的
+记忆标签 frontmatter，常规后台文件 watcher 会观察这些源文件变化并刷新派生索引，再由可选的
+`dingtalk_markdown_send_step` 发送最终简报；未配置群会话时无副作用跳过。
## 参数
diff --git a/plugins/daily_paper/pyproject.toml b/plugins/daily_paper/pyproject.toml
index cbdd51a2..eb131365 100644
--- a/plugins/daily_paper/pyproject.toml
+++ b/plugins/daily_paper/pyproject.toml
@@ -1,6 +1,6 @@
[project]
name = "reme-daily-paper"
-version = "0.1.2"
+version = "0.1.3"
description = "Daily Paper research and reading-note plugin for ReMe."
readme = "README.md"
license = "Apache-2.0"
@@ -8,7 +8,7 @@ license-files = ["LICENSE"]
requires-python = ">=3.11"
dependencies = [
"pypdf>=5.0.0",
- "reme-ai>=0.4.1.9",
+ "reme-ai>=0.4.1.12",
]
[project.entry-points."reme.plugins"]
diff --git a/plugins/daily_paper/src/reme_daily_paper/analyze.py b/plugins/daily_paper/src/reme_daily_paper/analyze.py
index 6f562e3e..a56ccddd 100644
--- a/plugins/daily_paper/src/reme_daily_paper/analyze.py
+++ b/plugins/daily_paper/src/reme_daily_paper/analyze.py
@@ -155,8 +155,18 @@ class DailyPaperAnalyzeStep(DailyPaperStep):
"pdf_text_truncated": truncated,
},
)
+ changes = list(self.context.get("changes") or [])
if existing_note is not None and existing_note != note_path:
+ existing_rel = existing_note.relative_to(self.workspace_path).as_posix()
existing_note.unlink()
+ changes.append({"change": "deleted", "path": existing_rel})
+ changes.append(
+ {
+ "change": "modified" if existing_note == note_path else "added",
+ "path": note_rel,
+ },
+ )
+ self.context["changes"] = changes
self.logger.info(
f"[{self.name}] paper done arxiv_id={paper.arxiv_id} note_path={note_rel}",
)
@@ -172,6 +182,7 @@ class DailyPaperAnalyzeStep(DailyPaperStep):
async def execute(self):
assert self.context is not None
+ self.context["changes"] = []
if self._skip():
self.logger.info(f"[{self.name}] skip existing digest")
return self.context.response
diff --git a/plugins/daily_paper/src/reme_daily_paper/digest.py b/plugins/daily_paper/src/reme_daily_paper/digest.py
index 121ee8f6..09484b37 100644
--- a/plugins/daily_paper/src/reme_daily_paper/digest.py
+++ b/plugins/daily_paper/src/reme_daily_paper/digest.py
@@ -108,6 +108,7 @@ class DailyPaperDigestStep(DailyPaperStep):
title = normalize_chinese_title(output.title, f"每日论文简报-{day}")
existing_rel = str(self._state("existing_digest_path") or "").strip()
existing_path = self.workspace_path / existing_rel if existing_rel else None
+ existing_was_file = existing_path is not None and existing_path.is_file()
title, digest_path = resolve_unique_note_path(
self.workspace_path / daily_dir / day,
title,
@@ -135,8 +136,13 @@ class DailyPaperDigestStep(DailyPaperStep):
"generated_at": utc_now_iso(),
},
)
- if existing_path is not None and existing_path != digest_path:
+ changes = list(self.context.get("changes") or [])
+ if existing_was_file and existing_path != digest_path:
existing_path.unlink()
+ changes.append({"change": "deleted", "path": existing_rel})
+ digest_change = "modified" if existing_was_file and existing_path == digest_path else "added"
+ changes.append({"change": digest_change, "path": digest_rel})
+ self.context["changes"] = changes
self._set_state("digest_path", digest_rel)
self.logger.info(f"[{self.name}] digest written path={digest_rel}")
self.logger.info(
diff --git a/plugins/daily_paper/src/reme_daily_paper/digest.yaml b/plugins/daily_paper/src/reme_daily_paper/digest.yaml
index 9bd8f1a9..dd6c3b84 100644
--- a/plugins/daily_paper/src/reme_daily_paper/digest.yaml
+++ b/plugins/daily_paper/src/reme_daily_paper/digest.yaml
@@ -4,10 +4,12 @@ digest_user: |
内容只能依据输入文档，不得补充文档中没有提供的事实。
保留技术准确性，同时解释三篇论文为什么值得关注，以及它们之间有什么联系。
- 在写作前，先调用 `search` 检索已有记忆：围绕三篇论文的核心问题、方法、关键词和同义表达组织查询。
- 主题跨度较大时可以多次检索，搜索结果不必局限于 `{daily_dir}/`。只有 `{daily_dir}/` 下日期早于今天、
+ 下面提供的三篇详细论文解读是本次写作的主要输入，首要任务是基于它们生成每日论文速读。
+ 历史搜索只用于帮助构建 Wikilink，最多调用两次 `search`：围绕三篇论文共同的核心问题、方法、关键词和
+ 同义表达组织一次综合查询，搜索结果不必局限于 `{daily_dir}/`。只有 `{daily_dir}/` 下日期早于今天、
且与本期内容确实相似或互补的 Markdown 文章才可作为正文中的历史链接候选；必要时调用 `read` 核验全文，
- 不要仅凭标题判断。
+ 不要仅凭标题判断。如果没有搜索到合适的历史文章，说明已有记忆中暂无相似文章，不添加 Wikilink 即可，
+ 仍须基于三篇论文解读完成每日论文速读；不得将搜索无结果误判为论文输入缺失，也不得要求用户重新提供文档。
将确认相关的旧文章以 Wikilink 自然织入正文，并用句子说明关联（延续、对比、补充或方法相似）；
链接必须采用带 `.md` 的完整 workspace-relative 路径，例如
`[[{daily_dir}/2026-07-01/旧文章.md|此前的相关解读]]`。不要输出裸链接、独立关系字段，也不要虚构搜索未命中的路径。
diff --git a/plugins/daily_paper/src/reme_daily_paper/plugin.yaml b/plugins/daily_paper/src/reme_daily_paper/plugin.yaml
index d8e62256..84e07350 100644
--- a/plugins/daily_paper/src/reme_daily_paper/plugin.yaml
+++ b/plugins/daily_paper/src/reme_daily_paper/plugin.yaml
@@ -54,6 +54,7 @@ application_defaults:
- backend: daily_paper_analyze_step
- backend: daily_paper_digest_step
job_tools: [search, read]
+ - backend: auto_tag_step
- backend: dingtalk_markdown_send_step
input_mapping:
daily_paper_digest_path: markdown_path
diff --git a/plugins/daily_paper/tests/test_daily_paper.py b/plugins/daily_paper/tests/test_daily_paper.py
index dcf6ecc6..8c0196c7 100644
--- a/plugins/daily_paper/tests/test_daily_paper.py
+++ b/plugins/daily_paper/tests/test_daily_paper.py
@@ -63,7 +63,19 @@ def test_plugin_manifest_declares_complete_runtime_surface():
"daily_paper_analyze_step",
"daily_paper_digest_step",
}
- assert set(_plugin_config()["jobs"]) == {"daily_paper", "daily_paper_cron"}
+ jobs = _plugin_config()["jobs"]
+ assert set(jobs) == {"daily_paper", "daily_paper_cron"}
+ assert [step["backend"] for step in jobs["daily_paper"]["steps"]] == [
+ "daily_paper_collect_step",
+ "daily_paper_rank_step",
+ "daily_paper_select_step",
+ "daily_paper_analyze_step",
+ "daily_paper_digest_step",
+ "auto_tag_step",
+ "dingtalk_markdown_send_step",
+ ]
+ assert jobs["daily_paper"]["steps"][5] == {"backend": "auto_tag_step"}
+ assert jobs["daily_paper_cron"]["steps"] == jobs["daily_paper"]["steps"]
class _QueuedAgentWrapper(BaseAgentWrapper):
@@ -644,6 +656,9 @@ def test_digest_prompt_uses_configured_daily_directory(tmp_path: Path):
assert "`memory/`" in prompt
assert "搜索结果不必局限于 `memory/`" in prompt
+ assert "最多调用两次 `search`" in prompt
+ assert "首要任务是基于它们生成每日论文速读" in prompt
+ assert "不得将搜索无结果误判为论文输入缺失" in prompt
assert "[[memory/2026-07-01/旧文章.md" in prompt
assert "[[daily/2026-07-01/" not in prompt
@@ -898,6 +913,12 @@ async def test_pipeline_filters_strict_yesterday_and_writes_outputs(
"Clear evidence",
]
assert digest.metadata["arxiv_ids"] == ["2607.10001", "2607.10004", "2607.10005"]
+ assert context["changes"] == [
+ {"change": "added", "path": "daily/2026-07-21/记忆代理研究.md"},
+ {"change": "added", "path": "daily/2026-07-21/上下文压缩研究.md"},
+ {"change": "added", "path": "daily/2026-07-21/持续学习研究.md"},
+ {"change": "added", "path": "daily/2026-07-21/今日智能体论文简报.md"},
+ ]
assert cc_wrapper.calls[0]["kwargs"] == {"output_schema": PaperPickList}
assert "用户感兴趣的主题" not in cc_wrapper.calls[0]["inputs"]
assert "用户未提供明确的 topic 倾向" in cc_wrapper.calls[0]["inputs"]
@@ -933,7 +954,9 @@ async def test_pipeline_filters_strict_yesterday_and_writes_outputs(
assert "调用 Read" not in digest_prompt
assert "daily/2026-07-21" not in digest_prompt
assert "长期记忆" not in digest_prompt
- assert "先调用 `search` 检索已有记忆" in digest_prompt
+ assert "历史搜索只用于帮助构建 Wikilink，最多调用两次 `search`" in digest_prompt
+ assert "首要任务是基于它们生成每日论文速读" in digest_prompt
+ assert "不得将搜索无结果误判为论文输入缺失" in digest_prompt
assert "搜索结果不必局限于 `daily/`" in digest_prompt
assert "end_date" not in digest_prompt
assert "limit=" not in digest_prompt
@@ -984,6 +1007,10 @@ async def test_digest_force_migrates_old_fixed_filename_to_chinese_title(tmp_pat
assert new_path.is_file()
assert not old_path.exists()
assert context["daily_paper_digest_path"] == "daily/2026-07-21/全新论文简报.md"
+ assert context["changes"] == [
+ {"change": "deleted", "path": "daily/2026-07-21/daily-paper-brief.md"},
+ {"change": "added", "path": "daily/2026-07-21/全新论文简报.md"},
+ ]
@pytest.mark.asyncio
diff --git a/plugins/lme-judge/README.md b/plugins/lme-judge/README.md
new file mode 100644
index 00000000..51503a7e
--- /dev/null
+++ b/plugins/lme-judge/README.md
@@ -0,0 +1,3 @@
+# ReMe LongMemEval Judge
+
+Trusted LongMemEval scoring plugin. Install it alongside `plugins/lme` for a full benchmark run. Meta-ReMe candidate bundles must not include this plugin.
diff --git a/plugins/lme-judge/pyproject.toml b/plugins/lme-judge/pyproject.toml
new file mode 100644
index 00000000..33d73408
--- /dev/null
+++ b/plugins/lme-judge/pyproject.toml
@@ -0,0 +1,22 @@
+[project]
+name = "reme-lme-judge"
+version = "0.1.0"
+description = "Trusted LongMemEval judge plugin for ReMe."
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.11"
+dependencies = ["reme-ai[as]>=0.4.1.11"]
+
+[project.entry-points."reme.plugins"]
+lme-judge = "judge_lme"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["judge_lme*"]
+
+[tool.setuptools.package-data]
+judge_lme = ["plugin.yaml", "*.yaml"]
+
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
diff --git a/plugins/lme/src/judge_lme/__init__.py b/plugins/lme-judge/src/judge_lme/__init__.py
similarity index 64%
rename from plugins/lme/src/judge_lme/__init__.py
rename to plugins/lme-judge/src/judge_lme/__init__.py
index 127e5621..56eb459c 100644
--- a/plugins/lme/src/judge_lme/__init__.py
+++ b/plugins/lme-judge/src/judge_lme/__init__.py
@@ -1,4 +1,4 @@
-"""LongMemEval benchmark judge backend."""
+"""LongMemEval benchmark judge plugin."""
from .llm_judge import LmeAnswerJudgeStep
diff --git a/plugins/lme/src/judge_lme/llm_judge.py b/plugins/lme-judge/src/judge_lme/llm_judge.py
similarity index 97%
rename from plugins/lme/src/judge_lme/llm_judge.py
rename to plugins/lme-judge/src/judge_lme/llm_judge.py
index 10dbb06e..00fcd9c3 100644
--- a/plugins/lme/src/judge_lme/llm_judge.py
+++ b/plugins/lme-judge/src/judge_lme/llm_judge.py
@@ -27,6 +27,7 @@ class LmeAnswerJudgeStep(BaseStep):
return raw_answer.strip().lower()
async def execute(self):
+ """Evaluate an agent answer against the LongMemEval reference answer."""
assert self.context is not None
query: str = self.context.get("query", "")
agent_answer: str = self.context.get("agent_answer", "")
diff --git a/plugins/lme/src/judge_lme/llm_judge.yaml b/plugins/lme-judge/src/judge_lme/llm_judge.yaml
similarity index 100%
rename from plugins/lme/src/judge_lme/llm_judge.yaml
rename to plugins/lme-judge/src/judge_lme/llm_judge.yaml
diff --git a/plugins/lme-judge/src/judge_lme/plugin.yaml b/plugins/lme-judge/src/judge_lme/plugin.yaml
new file mode 100644
index 00000000..58fcb464
--- /dev/null
+++ b/plugins/lme-judge/src/judge_lme/plugin.yaml
@@ -0,0 +1,44 @@
+backends:
+ lme_answer_judge_step: judge_lme.llm_judge:LmeAnswerJudgeStep
+
+application_defaults:
+ jobs:
+ answer_judge:
+ backend: base
+ description: "LLM-as-Judge: evaluate agent answer against golden answer"
+ parameters:
+ type: object
+ properties:
+ query: {type: string}
+ agent_answer: {type: string}
+ golden_answer: {type: string}
+ question_type: {type: string, default: ""}
+ required: [query, agent_answer, golden_answer]
+ steps:
+ - backend: lme_answer_judge_step
+ agent_wrapper: judge
+ components:
+ as_llm:
+ judge:
+ backend: ${LLM_BACKEND:-openai}
+ model: ${JUDGE_MODEL_NAME:-qwen3.7-max}
+ stream: false
+ context_size: 200000
+ max_retries: 5
+ credential:
+ api_key: ${LLM_API_KEY:-}
+ base_url: ${LLM_BASE_URL:-}
+ parameters:
+ max_tokens: 65536
+ thinking_enable: false
+ agent_wrapper:
+ judge:
+ backend: agentscope
+ as_llm: judge
+ permission_mode: bypass
+ react_config: {max_iters: 1}
+ context_config:
+ trigger_ratio: 0.8
+ reserve_ratio: 0.1
+ tool_result_limit: 50000
+ model_config: {max_retries: 1}
diff --git a/plugins/lme/README.md b/plugins/lme/README.md
index 284ac7a4..a2310caf 100644
--- a/plugins/lme/README.md
+++ b/plugins/lme/README.md
@@ -2,8 +2,8 @@
[中文说明](./README_ZH.md)
-This plugin owns the LongMemEval memory, agentic-answer and judge Steps, their prompts,
-and their Job defaults in `plugin.yaml`. ReMe's built-in `benchmark.yaml` owns the
+This plugin owns the LongMemEval memory and agentic-answer Steps and their Job defaults.
+The trusted judge Step, prompts and `answer_judge` Job live in `plugins/lme-judge`. ReMe's built-in `benchmark.yaml` owns the
shared evaluation Jobs and components. Dataset handling, the runner and results remain
in [`benchmark/longmemeval`](../../benchmark/longmemeval/README.md).
@@ -12,17 +12,19 @@ From the repository root, install ReMe and this plugin in editable mode before r
```bash
python -m pip install -e ".[as]"
reme plugins install ./plugins/lme --editable
+reme plugins install ./plugins/lme-judge --editable
reme plugins validate lme
+reme plugins validate lme-judge
python benchmark/longmemeval/run.py
```
Editable installation registers the `lme` entry point while keeping source changes immediately
-visible. The runner selects the built-in `benchmark` preset and explicitly enables `lme` for
+visible. The runner selects the built-in `benchmark` preset and explicitly enables `lme` and `lme-judge` for
each Application. Installing the plugin makes it discoverable but does not enable it globally.
`plugin.yaml` registers backends and contributes the plugin-owned `auto_memory`,
-`agentic_answer` and `answer_judge` Job defaults. Start the installed plugin with
-`reme start config=benchmark plugins='["lme"]'`. The shared preset does not inherit
+`agentic_answer` Job defaults. Start a full benchmark application with
+`reme start config=benchmark plugins='["lme", "lme-judge"]'`. The shared preset does not inherit
`default`: only declared Jobs run, indexing is manual, and neither scheduled dream
nor the optional `auto_dream` Job is enabled.
The existing `auto_memory`, `agentic_answer`, `answer_judge`, `bench` and `judge`
@@ -31,8 +33,8 @@ still take precedence. Installing this plugin does not start an evaluation.
The shared answer base class lives in `reme.steps.benchmark.base_agentic_answer`.
The old core-owned `reme.steps.benchmark.lme` Python import path is removed.
-Custom Python callers should import memory, search and answer Steps from `reme_lme`, and the
-judge Step from `judge_lme`. After uninstalling,
+Custom Python callers should import memory, search and answer Steps from `reme_lme`, and install
+`lme-judge` before importing the judge Step from `judge_lme`. After uninstalling,
Applications and CLI services must omit the plugin until it is installed again.
Uninstallation never removes datasets, workspaces or results.
Restart an existing service after changing plugins.
diff --git a/plugins/lme/README_ZH.md b/plugins/lme/README_ZH.md
index 176b2e80..9d0bbbb0 100644
--- a/plugins/lme/README_ZH.md
+++ b/plugins/lme/README_ZH.md
@@ -2,7 +2,8 @@
[English](./README.md)
-插件包含 LongMemEval 的记忆、回答、评分 Step、提示词，以及 `plugin.yaml` 中对应的 Job 默认配置。
+插件包含 LongMemEval 的记忆、回答 Step 及对应 Job 默认配置。可信评分 Step、提示词和
+`answer_judge` Job 位于独立的 `plugins/lme-judge` 插件中。
ReMe 内置的 `benchmark.yaml` 负责公共评测 Job 和 Component；数据集处理、runner 和结果仍留在
[`benchmark/longmemeval`](../../benchmark/longmemeval/README_ZH.md)。
@@ -11,22 +12,24 @@ ReMe 内置的 `benchmark.yaml` 负责公共评测 Job 和 Component；数据集
```bash
python -m pip install -e ".[as]"
reme plugins install ./plugins/lme --editable
+reme plugins install ./plugins/lme-judge --editable
reme plugins validate lme
+reme plugins validate lme-judge
python benchmark/longmemeval/run.py
```
editable 安装会注册 `lme` entry point，并让源码修改立即生效。runner 选择内置 `benchmark`
-配置，并为每个 Application 显式启用 `lme`。安装只让插件可被发现，不会在所有应用中全局启用。
+配置，并为每个 Application 显式启用 `lme` 和 `lme-judge`。安装只让插件可被发现，不会在所有应用中全局启用。
`plugin.yaml` 注册 backend，并通过 `application_defaults` 提供插件拥有的 `auto_memory`、
-`agentic_answer` 和 `answer_judge` Job。安装后使用
-`reme start config=benchmark plugins='["lme"]'`。公共评测配置不继承 `default`，只运行声明的 Job：
+`agentic_answer` Job。完整评测使用
+`reme start config=benchmark plugins='["lme", "lme-judge"]'`。公共评测配置不继承 `default`，只运行声明的 Job：
索引手动更新，dream 定时任务和可选的 `auto_dream`
均保持关闭。原有 `auto_memory`、`agentic_answer`、`answer_judge`、`bench`、`judge` 名称及模型环境变量
保持不变，显式应用参数和 CLI 覆盖仍优先。安装或启用插件不会自动开始评测。
共享回答基类位于 `reme.steps.benchmark.base_agentic_answer`。
原 `reme.steps.benchmark.lme` Python 导入路径已移除。自定义 Python 调用应从 `reme_lme`
-导入记忆、搜索和回答 Step，并从 `judge_lme` 导入评判 Step。
+导入记忆、搜索和回答 Step；安装 `lme-judge` 后再从 `judge_lme` 导入评判 Step。
卸载插件后，Application 和 CLI 服务必须移除插件选择，直到再次安装。
卸载不会删除数据集、工作区或结果。修改插件后需重启已有服务。
diff --git a/plugins/lme/pyproject.toml b/plugins/lme/pyproject.toml
index fa91dd74..1171f4a8 100644
--- a/plugins/lme/pyproject.toml
+++ b/plugins/lme/pyproject.toml
@@ -15,11 +15,10 @@ lme = "reme_lme"
[tool.setuptools.packages.find]
where = ["src"]
-include = ["reme_lme*", "judge_lme*"]
+include = ["reme_lme*"]
[tool.setuptools.package-data]
reme_lme = ["plugin.yaml", "*.yaml"]
-judge_lme = ["*.yaml"]
[build-system]
requires = ["setuptools>=77", "wheel"]
diff --git a/plugins/lme/src/reme_lme/plugin.yaml b/plugins/lme/src/reme_lme/plugin.yaml
index e8f9513c..a0621101 100644
--- a/plugins/lme/src/reme_lme/plugin.yaml
+++ b/plugins/lme/src/reme_lme/plugin.yaml
@@ -1,7 +1,6 @@
backends:
lme_auto_memory_step: reme_lme.auto_memory:LmeAutoMemoryStep
lme_agentic_answer_step: reme_lme.agentic_answer:LmeAgenticAnswerStep
- lme_answer_judge_step: judge_lme.llm_judge:LmeAnswerJudgeStep
lme_search_v2_step: reme_lme.search_v2:SearchV2Step
application_defaults:
@@ -51,35 +50,6 @@ application_defaults:
- backend: lme_agentic_answer_step
agent_wrapper: bench
- answer_judge:
- backend: base
- description: "LLM-as-Judge: evaluate agent answer against golden answer"
- watch_dirs: []
- watch_suffixes: []
- parameters:
- type: object
- properties:
- query:
- type: string
- description: "The question being asked"
- agent_answer:
- type: string
- description: "The model's answer to evaluate"
- golden_answer:
- type: string
- description: "The correct/golden answer"
- question_type:
- type: string
- description: "The question type for prompt selection"
- default: ""
- required:
- - query
- - agent_answer
- - golden_answer
- steps:
- - backend: lme_answer_judge_step
- agent_wrapper: judge
-
auto_memory:
backend: base
description: "Auto-memory: record conversation facts into a daily note"
diff --git a/reme/__init__.py b/reme/__init__.py
index 6ece0f6e..e8c66c1a 100644
--- a/reme/__init__.py
+++ b/reme/__init__.py
@@ -1,6 +1,6 @@
"""ReMe CLI package."""
-__version__ = "0.4.1.11"
+__version__ = "0.4.1.12"
from . import config
from . import constants
diff --git a/reme/components/file_store/base_file_store.py b/reme/components/file_store/base_file_store.py
index 91bcaa73..414be787 100644
--- a/reme/components/file_store/base_file_store.py
+++ b/reme/components/file_store/base_file_store.py
@@ -6,6 +6,7 @@ from contextlib import asynccontextmanager
from functools import wraps
from ..base_component import BaseComponent
+from ..tag_index import BaseTagIndex
from ...enumeration import ComponentEnum, LinkScopeEnum
from ...schema import FileChunk, FileLink, FileNode
@@ -23,9 +24,26 @@ class BaseFileStore(BaseComponent):
def __init__(self, **kwargs):
super().__init__(**kwargs)
+ self.tag_index: BaseTagIndex | None = None
self._maintenance_lock = asyncio.Lock()
self._maintenance_lock_owner = None
+ @property
+ def tag_index_enabled(self) -> bool:
+ """Whether this file-store backend has a tag index configured."""
+ return self.tag_index is not None
+
+ def require_tag_index(self) -> BaseTagIndex:
+ """Return the configured tag index or fail with one consistent error."""
+ if self.tag_index is None:
+ raise RuntimeError("tag index is not configured")
+ return self.tag_index
+
+ @property
+ def embedding_dimensions(self) -> int:
+ """Vector dimensions used for memory estimates; zero when unavailable."""
+ return 0
+
@asynccontextmanager
async def _maintenance_guard(self):
"""Serialize maintenance and mutations, allowing nested backend overrides."""
diff --git a/reme/components/file_store/faiss_local_file_store.py b/reme/components/file_store/faiss_local_file_store.py
index 74c58310..5dc0a11e 100644
--- a/reme/components/file_store/faiss_local_file_store.py
+++ b/reme/components/file_store/faiss_local_file_store.py
@@ -654,12 +654,7 @@ class FaissLocalFileStore(LocalFileStore):
async def vector_search(self, query: str, limit: int, search_filter: dict) -> list[FileChunk]:
index_empty = self._faiss_index is None or self._faiss_index.ntotal == 0
embedding_unavailable = self.embedding_store is None or self._embedding_rebuild_pending
- if (
- embedding_unavailable
- or not query
- or limit <= 0
- or (index_empty and getattr(self.embedding_store, "is_healthy", True))
- ):
+ if embedding_unavailable or not query or limit <= 0 or (index_empty and self.embedding_store.is_healthy):
return []
query_embedding = await self._get_query_embedding(query)
diff --git a/reme/components/file_store/local_file_store.py b/reme/components/file_store/local_file_store.py
index 9cda87e9..9d9d2e47 100644
--- a/reme/components/file_store/local_file_store.py
+++ b/reme/components/file_store/local_file_store.py
@@ -68,7 +68,12 @@ class LocalFileStore(BaseFileStore):
self.embedding_store = self.bind(embedding_store, BaseEmbeddingStore, default_factory=LocalEmbeddingStore)
self.keyword_index = self.bind(keyword_index, BaseKeywordIndex, default_factory=BM25Index)
self.file_graph = self.bind(file_graph, BaseFileGraph, default_factory=LocalFileGraph)
- self.tag_index = self.bind(tag_index, BaseTagIndex, default_factory=LocalTagIndex)
+ self.tag_index = self.bind(
+ tag_index,
+ BaseTagIndex,
+ default_factory=LocalTagIndex if tag_index == "default" else None,
+ optional=False,
+ )
self.encoding = encoding
self.store_version = store_version
@@ -108,6 +113,12 @@ class LocalFileStore(BaseFileStore):
def chunks_path(self) -> Path:
return self.component_metadata_path / f"file_chunks_{self.name}_{self._store_version_suffix()}.jsonl.zst"
+ @property
+ def embedding_dimensions(self) -> int:
+ if self.embedding_store is None:
+ return 0
+ return max(0, int(getattr(self.embedding_store, "dimensions", 0)))
+
# -- lifecycle ------------------------------------------------------------
async def _start(self) -> None:
@@ -163,7 +174,7 @@ class LocalFileStore(BaseFileStore):
self.embedding_store is None
or self._embedding_rebuild_pending
or was_healthy
- or not getattr(self.embedding_store, "is_healthy", True)
+ or not self.embedding_store.is_healthy
):
return
self.logger.info(f"{self.name}: embedding provider recovered; scheduling missing-vector backfill")
@@ -223,7 +234,7 @@ class LocalFileStore(BaseFileStore):
return None
embedding_generation = self._embedding_space_generation
- was_healthy = bool(getattr(embedding_store, "is_healthy", True))
+ was_healthy = embedding_store.is_healthy
try:
query_embedding = await embedding_store.get_embedding(query)
except Exception as e:
@@ -275,7 +286,7 @@ class LocalFileStore(BaseFileStore):
tag_sync_started_at = time.monotonic()
tag_synced = await self._rebuild_tag_index("startup synchronization")
self.logger.info(
- f"{self.name}: tag index sync complete: enabled={self.tag_index is not None}, "
+ f"{self.name}: tag index sync complete: enabled={self.tag_index_enabled}, "
f"healthy={tag_synced}, "
f"elapsed={time.monotonic() - tag_sync_started_at:.3f}s",
)
@@ -529,7 +540,7 @@ class LocalFileStore(BaseFileStore):
return
total = len(missing)
- batch_size = max(1, int(getattr(self.embedding_store, "max_batch_size", 10)))
+ batch_size = max(1, int(self.embedding_store.max_batch_size))
self.logger.info(f"{self.name}: embedding backfill started: total={total}, batch_size={batch_size}")
try:
if not skip_health_check:
@@ -663,13 +674,14 @@ class LocalFileStore(BaseFileStore):
async def _rebuild_tag_index(self, reason: str) -> bool:
"""Best-effort rebuild that never lets an optional tag index block the file store."""
- if self.tag_index is None:
+ if not self.tag_index_enabled:
self._tag_index_rebuild_required = False
self._tag_indexed_file_count = 0
return True
+ tag_index = self.require_tag_index()
try:
nodes = await self.file_graph.get_nodes()
- await self.tag_index.rebuild(nodes)
+ await tag_index.rebuild(nodes)
except Exception:
self._tag_index_rebuild_required = True
self.logger.exception(
@@ -678,20 +690,20 @@ class LocalFileStore(BaseFileStore):
await self._quarantine_tag_index(reason)
return False
self._tag_index_rebuild_required = False
- self.tag_index.set_healthy(True)
- self._tag_indexed_file_count = self.tag_index.n_files
+ tag_index.set_healthy(True)
+ self._tag_indexed_file_count = tag_index.n_files
return True
async def _quarantine_tag_index(self, reason: str) -> None:
"""Fail closed after a reconciliation error without propagating cleanup failures."""
- assert self.tag_index is not None
- self.tag_index.set_healthy(False)
+ tag_index = self.require_tag_index()
+ tag_index.set_healthy(False)
try:
- await self.tag_index.clear()
+ await tag_index.clear()
except Exception:
self.logger.exception(f"{self.name}: failed to clear unhealthy tag index during {reason}")
finally:
- self.tag_index.set_healthy(False)
+ tag_index.set_healthy(False)
async def _reindex_tag(self) -> dict:
"""Synchronously rebuild the optional tag index from the authoritative file graph."""
@@ -701,33 +713,35 @@ class LocalFileStore(BaseFileStore):
async def _upsert_tag_nodes(self, nodes: list[FileNode]) -> None:
"""Update tags without allowing optional-index failures to block other indexes."""
- if self.tag_index is None:
+ if not self.tag_index_enabled:
return
+ tag_index = self.require_tag_index()
if self._tag_index_rebuild_required:
await self._rebuild_tag_index("retry before incremental update")
return
try:
- await self.tag_index.upsert_nodes(nodes)
- self.tag_index.set_healthy(True)
+ await tag_index.upsert_nodes(nodes)
+ tag_index.set_healthy(True)
except Exception:
self._tag_index_rebuild_required = True
- self.tag_index.set_healthy(False)
+ tag_index.set_healthy(False)
self.logger.exception(f"{self.name}: incremental tag index update failed; rebuilding from graph")
await self._rebuild_tag_index("incremental update recovery")
async def _delete_tag_paths(self, paths: list[str]) -> None:
"""Delete tag paths without allowing optional-index failures to block other indexes."""
- if self.tag_index is None:
+ if not self.tag_index_enabled:
return
+ tag_index = self.require_tag_index()
if self._tag_index_rebuild_required:
await self._rebuild_tag_index("retry before incremental delete")
return
try:
- await self.tag_index.delete(paths)
- self.tag_index.set_healthy(True)
+ await tag_index.delete(paths)
+ tag_index.set_healthy(True)
except Exception:
self._tag_index_rebuild_required = True
- self.tag_index.set_healthy(False)
+ tag_index.set_healthy(False)
self.logger.exception(f"{self.name}: incremental tag index delete failed; rebuilding from graph")
await self._rebuild_tag_index("incremental delete recovery")
@@ -858,7 +872,7 @@ class LocalFileStore(BaseFileStore):
return
embedding_store = self.embedding_store
embedding_generation = self._embedding_space_generation
- was_healthy = bool(getattr(embedding_store, "is_healthy", True))
+ was_healthy = embedding_store.is_healthy
try:
await embedding_store.get_node_embeddings(chunks)
except Exception as e:
@@ -930,15 +944,16 @@ class LocalFileStore(BaseFileStore):
if self.keyword_index:
await self.keyword_index.clear()
await self.file_graph.clear()
- if self.tag_index is not None:
+ if self.tag_index_enabled:
+ tag_index = self.require_tag_index()
try:
- await self.tag_index.clear()
+ await tag_index.clear()
self._tag_index_rebuild_required = False
self._tag_indexed_file_count = 0
- self.tag_index.set_healthy(True)
+ tag_index.set_healthy(True)
except Exception:
self._tag_index_rebuild_required = True
- self.tag_index.set_healthy(False)
+ tag_index.set_healthy(False)
self.logger.exception(f"{self.name}: tag index clear failed; rebuilding from empty graph")
await self._rebuild_tag_index("clear recovery")
self._mutation_generation += 1
@@ -994,17 +1009,32 @@ class LocalFileStore(BaseFileStore):
]
async def keyword_search(self, query: str, limit: int, search_filter: dict) -> list[FileChunk]:
- if not self.keyword_index:
+ if not self.keyword_index or limit <= 0:
return []
query = query.strip()
if not query:
return []
- retrieve_limit = limit
if search_filter:
- retrieve_limit = max(limit, getattr(self.keyword_index, "n_docs", limit))
- doc_id_score_dict = await self.keyword_index.retrieve(query, limit=retrieve_limit)
+ eligible_ids = {
+ chunk.id for chunk in self.file_chunks.values() if self._matches_search_filter(chunk, search_filter)
+ }
+ if not eligible_ids:
+ return []
+ try:
+ eligible_ids.intersection_update(self.keyword_index.document_ids)
+ if not eligible_ids:
+ return []
+ doc_id_score_dict = await self.keyword_index.retrieve_filtered(query, limit, eligible_ids)
+ except NotImplementedError:
+ # Compatibility path for third-party indexes implementing only retrieve().
+ doc_id_score_dict = await self.keyword_index.retrieve(
+ query,
+ limit=max(limit, getattr(self.keyword_index, "n_docs", limit)),
+ )
+ else:
+ doc_id_score_dict = await self.keyword_index.retrieve(query, limit=limit)
results = []
for doc_id, score in doc_id_score_dict.items():
chunk = self.file_chunks.get(doc_id)
@@ -1060,10 +1090,12 @@ class LocalFileStore(BaseFileStore):
return True
exact_paths = set()
+ has_exact_path_filter = False
for key in ("path", "paths"):
if key in search_filter:
+ has_exact_path_filter = True
exact_paths.update(cls._as_filter_values(search_filter[key]))
- if exact_paths and chunk.path not in exact_paths:
+ if has_exact_path_filter and chunk.path not in exact_paths:
return False
prefixes = []
diff --git a/reme/components/file_store/zvec_local_file_store.py b/reme/components/file_store/zvec_local_file_store.py
index d50f7017..2e0b5100 100644
--- a/reme/components/file_store/zvec_local_file_store.py
+++ b/reme/components/file_store/zvec_local_file_store.py
@@ -447,7 +447,7 @@ class ZvecLocalFileStore(LocalFileStore):
if self.embedding_store is None or self._embedding_rebuild_pending or not query or limit <= 0:
return []
index_empty = self._collection is None or not self._indexed_ids
- if index_empty and getattr(self.embedding_store, "is_healthy", True):
+ if index_empty and self.embedding_store.is_healthy:
return []
query_embedding = await self._get_query_embedding(query)
diff --git a/reme/components/keyword_index/base_keyword_index.py b/reme/components/keyword_index/base_keyword_index.py
index feac9e50..186c65b3 100644
--- a/reme/components/keyword_index/base_keyword_index.py
+++ b/reme/components/keyword_index/base_keyword_index.py
@@ -1,7 +1,7 @@
"""Abstract base class for keyword indexes (BM25 and other lexical backends)."""
from abc import abstractmethod
-from collections.abc import Set
+from collections.abc import Collection, Set
from ..base_component import BaseComponent
from ..tokenizer import BaseTokenizer
@@ -54,6 +54,30 @@ class BaseKeywordIndex(BaseComponent):
async def retrieve(self, query: str, limit: int = 3) -> dict[str, float]:
"""Return top-`limit` doc_id → score for the given query."""
+ async def score_documents(self, query: str, document_ids: Collection[str]) -> dict[str, float]:
+ """Score selected documents using the index's normal corpus statistics.
+
+ This compatibility implementation uses the existing public retrieval
+ contract. Backends can override it to avoid ranking the whole corpus.
+ """
+ allowed = set(document_ids)
+ if not allowed:
+ return {}
+ results = await self.retrieve(query, limit=len(self.document_ids))
+ return {doc_id: score for doc_id, score in results.items() if doc_id in allowed}
+
+ async def retrieve_filtered(
+ self,
+ query: str,
+ limit: int,
+ document_ids: Collection[str],
+ ) -> dict[str, float]:
+ """Return top results restricted to document IDs, preserving old APIs."""
+ if limit <= 0:
+ return {}
+ scores = await self.score_documents(query, document_ids)
+ return dict(list(scores.items())[:limit])
+
@abstractmethod
async def clear(self) -> None:
"""Wipe in-memory state and remove any persisted artifacts."""
diff --git a/reme/components/keyword_index/bm25_index.py b/reme/components/keyword_index/bm25_index.py
index 0169726f..4bd4c14d 100644
--- a/reme/components/keyword_index/bm25_index.py
+++ b/reme/components/keyword_index/bm25_index.py
@@ -22,7 +22,7 @@ import math
import pickle
import re
from collections import Counter
-from collections.abc import KeysView
+from collections.abc import Collection, KeysView
from pathlib import Path
from uuid import uuid4
@@ -280,32 +280,65 @@ class BM25Index(BaseKeywordIndex):
self._remove_doc(doc_id)
self._idf_cache = {}
- def _score_query(self, query_ids: list[int], n_docs: int) -> np.ndarray:
- """Compute BM25 scores across all docs; deleted docs zeroed out."""
+ def _score_query(self, query_ids: list[int], candidate_idxs: np.ndarray | None = None) -> np.ndarray:
+ """Compute BM25 scores globally or for selected live document indexes."""
+ n_docs = self.n_docs
+ if n_docs == 0:
+ size = self._doc_lens.size if candidate_idxs is None else candidate_idxs.size
+ return np.zeros(size, dtype=np.float32)
+
avg_len = self.total_len / n_docs
k1, b = self.k1, self.b
denom_base = k1 * (1.0 - b)
denom_norm = k1 * b / avg_len if avg_len > 0 else 0.0
- scores = np.zeros(self._doc_lens.size, dtype=np.float32)
+ size = self._doc_lens.size if candidate_idxs is None else candidate_idxs.size
+ scores = np.zeros(size, dtype=np.float32)
for tid in query_ids:
- doc_idxs = self._posting_doc_idxs.get(tid)
- if doc_idxs is None or doc_idxs.size == 0:
+ posting_idxs = self._posting_doc_idxs.get(tid)
+ if posting_idxs is None or posting_idxs.size == 0:
continue
idf = self._get_idf(tid, n_docs)
if idf == 0.0:
continue
- tfs = self._posting_tfs[tid].astype(np.float32)
- d_lens = self._doc_lens[doc_idxs].astype(np.float32)
+
+ if candidate_idxs is None:
+ posting_positions = slice(None)
+ score_positions = posting_idxs
+ else:
+ _common, posting_positions, score_positions = np.intersect1d(
+ posting_idxs,
+ candidate_idxs,
+ assume_unique=True,
+ return_indices=True,
+ )
+ if score_positions.size == 0:
+ continue
+
+ doc_idxs = posting_idxs[posting_positions]
+ tfs = self._posting_tfs[tid][posting_positions].astype(np.float32)
+ doc_lens = self._doc_lens[doc_idxs].astype(np.float32)
# Each doc_idx appears at most once per posting list (Counter dedups
# within a doc, and updates allocate fresh idxs), so fancy-index
# accumulation is safe here.
- scores[doc_idxs] += idf * tfs * (k1 + 1.0) / (tfs + denom_base + denom_norm * d_lens)
+ scores[score_positions] += idf * tfs * (k1 + 1.0) / (tfs + denom_base + denom_norm * doc_lens)
- if self._deleted.any():
+ if candidate_idxs is None and self._deleted.any():
scores[self._deleted] = 0.0
return scores
+ def _score_query_documents(
+ self,
+ query_ids: list[int],
+ document_ids: Collection[str],
+ ) -> tuple[np.ndarray, np.ndarray]:
+ """Score live selected documents while retaining global BM25 statistics."""
+ candidate_idxs = np.array(
+ sorted({self._doc_id_to_idx[doc_id] for doc_id in document_ids if doc_id in self._doc_id_to_idx}),
+ dtype=np.int32,
+ )
+ return candidate_idxs, self._score_query(query_ids, candidate_idxs)
+
async def retrieve(self, query: str, limit: int = 3) -> dict[str, float]:
"""BM25 retrieval; returns {doc_id: score} sorted by score descending."""
n_docs = self.n_docs
@@ -315,10 +348,35 @@ class BM25Index(BaseKeywordIndex):
if not query_ids:
return {}
- scores = self._score_query(query_ids, n_docs)
+ scores = self._score_query(query_ids)
top_idxs = self._top_k(scores, limit)
return {self._doc_ids[int(i)]: float(scores[int(i)]) for i in top_idxs}
+ async def score_documents(self, query: str, document_ids: Collection[str]) -> dict[str, float]:
+ """Return every positive-scoring selected document in descending order."""
+ query_ids = self._encode_query(query)
+ if not query_ids:
+ return {}
+ candidate_idxs, scores = self._score_query_documents(query_ids, document_ids)
+ ranked = self._top_k(scores, scores.size)
+ return {self._doc_ids[int(candidate_idxs[i])]: float(scores[i]) for i in ranked}
+
+ async def retrieve_filtered(
+ self,
+ query: str,
+ limit: int,
+ document_ids: Collection[str],
+ ) -> dict[str, float]:
+ """Return exact BM25 top-k within selected documents."""
+ if limit <= 0:
+ return {}
+ query_ids = self._encode_query(query)
+ if not query_ids:
+ return {}
+ candidate_idxs, scores = self._score_query_documents(query_ids, document_ids)
+ ranked = self._top_k(scores, limit)
+ return {self._doc_ids[int(candidate_idxs[i])]: float(scores[i]) for i in ranked}
+
# -- Persistence ----------------------------------------------------------
def _snapshot(self) -> dict:
diff --git a/reme/components/tag_index/base_tag_index.py b/reme/components/tag_index/base_tag_index.py
index 01a9a9d8..6f1acce6 100644
--- a/reme/components/tag_index/base_tag_index.py
+++ b/reme/components/tag_index/base_tag_index.py
@@ -1,21 +1,74 @@
"""Abstract interface for file-level tag indexes derived from graph nodes."""
from abc import abstractmethod
+from typing import ClassVar, Literal, TypedDict
from ..base_component import BaseComponent
+from ...constants import DEFAULT_MAX_MEMORY_TAG_LENGTH, DEFAULT_MAX_MEMORY_TAGS, DEFAULT_MEMORY_TAG_KEY
from ...enumeration import ComponentEnum
from ...schema import FileNode
+TagOrderBy = Literal["tag", "file_count"]
+TagOrder = Literal["asc", "desc"]
+TagListItem = tuple[str, int]
+
+
+class TagListResult(TypedDict):
+ """One page of active tags and their indexed-file counts."""
+
+ total_tags: int
+ total_pages: int
+ page: int
+ range: tuple[int, int]
+ items: list[TagListItem]
+
class BaseTagIndex(BaseComponent):
"""A rebuildable index of normalized ``FileNode`` frontmatter tags."""
component_type = ComponentEnum.TAG_INDEX
+ reserved_tag_keys: ClassVar[frozenset[str]] = frozenset()
- def __init__(self, **kwargs):
+ def __init__(
+ self,
+ tag_key: object = DEFAULT_MEMORY_TAG_KEY,
+ max_tags_per_file: int = DEFAULT_MAX_MEMORY_TAGS,
+ max_tag_length: int = DEFAULT_MAX_MEMORY_TAG_LENGTH,
+ **kwargs,
+ ):
super().__init__(**kwargs)
+ self._tag_key = self._validate_tag_key(tag_key)
+ self.max_tags_per_file = self._positive_int("max_tags_per_file", max_tags_per_file)
+ self.max_tag_length = self._positive_int("max_tag_length", max_tag_length)
self.is_healthy = True
+ @staticmethod
+ def _positive_int(name: str, value: object) -> int:
+ if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
+ raise ValueError(f"{name} must be a positive integer")
+ return value
+
+ @property
+ def tag_key(self) -> str:
+ """Frontmatter field from which this index derives tags."""
+ return self._tag_key
+
+ @tag_key.setter
+ def tag_key(self, value: object) -> None:
+ tag_key = self._validate_tag_key(value)
+ if tag_key != self._tag_key:
+ self._tag_key = tag_key
+ self.set_healthy(False)
+
+ def _validate_tag_key(self, value: object) -> str:
+ """Validate and normalize the configured frontmatter tag field."""
+ if not isinstance(value, str) or not value.strip():
+ raise ValueError("tag_key must be a non-empty string")
+ tag_key = value.strip()
+ if tag_key in self.reserved_tag_keys:
+ raise ValueError(f"tag_key must not be a reserved frontmatter key: {tag_key!r}")
+ return tag_key
+
def set_healthy(self, healthy: bool) -> None:
"""Mark whether lookups can safely use the current derived state."""
self.is_healthy = healthy
@@ -29,6 +82,10 @@ class BaseTagIndex(BaseComponent):
def normalize_tags(self, value: object) -> list[str]:
"""Return canonical tags according to this index's configured limits."""
+ @abstractmethod
+ def normalize_query_tags(self, value: object) -> list[str]:
+ """Return canonical lookup tags without per-file count limits."""
+
@abstractmethod
async def rebuild(self, nodes: list[FileNode]) -> None:
"""Replace the complete index with relationships derived from ``nodes``."""
@@ -49,6 +106,17 @@ class BaseTagIndex(BaseComponent):
async def tags_for_path(self, path: str) -> list[str]:
"""Return normalized tags for one workspace-relative path."""
+ @abstractmethod
+ async def list_tags(
+ self,
+ *,
+ page: int = 1,
+ order_by: TagOrderBy = "tag",
+ order: TagOrder | None = None,
+ page_size: int = 100,
+ ) -> TagListResult:
+ """Return a page of active tags with counts and a 1-based result range."""
+
@abstractmethod
async def clear(self) -> None:
"""Clear memory and persisted state."""
diff --git a/reme/components/tag_index/local_tag_index.py b/reme/components/tag_index/local_tag_index.py
index c3e97780..7392d668 100644
--- a/reme/components/tag_index/local_tag_index.py
+++ b/reme/components/tag_index/local_tag_index.py
@@ -3,19 +3,25 @@
import asyncio
from pathlib import PurePosixPath
-from .base_tag_index import BaseTagIndex
+from .base_tag_index import BaseTagIndex, TagListItem, TagListResult, TagOrder, TagOrderBy
from ..component_registry import R
-from ...schema import FileNode
+from ...schema import FileFrontMatter, FileNode
@R.register("local")
class LocalTagIndex(BaseTagIndex):
"""Maintain bidirectional path/tag relationships without separate source I/O."""
- def __init__(self, max_tags_per_file: int = 8, max_tag_length: int = 64, **kwargs):
+ reserved_tag_keys = frozenset(FileFrontMatter.model_fields) | {
+ "kind",
+ "session_id",
+ "source_conversation",
+ "source_resource",
+ "status",
+ }
+
+ def __init__(self, **kwargs):
super().__init__(**kwargs)
- self.max_tags_per_file = self._positive_int("max_tags_per_file", max_tags_per_file)
- self.max_tag_length = self._positive_int("max_tag_length", max_tag_length)
self.path_to_tags: dict[str, tuple[str, ...]] = {}
self.tag_to_paths: dict[str, set[str]] = {}
self._maintenance_lock = asyncio.Lock()
@@ -24,12 +30,6 @@ class LocalTagIndex(BaseTagIndex):
def n_files(self) -> int:
return len(self.path_to_tags)
- @staticmethod
- def _positive_int(name: str, value: object) -> int:
- if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
- raise ValueError(f"{name} must be a positive integer")
- return value
-
def _normalize_tags(self, value: object, *, limit: int | None) -> list[str]:
"""Normalize a strict tag list, optionally limiting the result count."""
if not isinstance(value, list):
@@ -39,8 +39,8 @@ class LocalTagIndex(BaseTagIndex):
for item in value:
if isinstance(item, bool) or not isinstance(item, (str, int)):
continue
- raw = str(item).strip()
- if not raw or len(raw) > self.max_tag_length or any(char.isspace() for char in raw):
+ raw = "_".join(str(item).split())
+ if not raw or len(raw) > self.max_tag_length:
continue
if not any(char.isalnum() for char in raw):
continue
@@ -57,6 +57,10 @@ class LocalTagIndex(BaseTagIndex):
"""Normalize frontmatter tags according to the per-file count limit."""
return self._normalize_tags(value, limit=self.max_tags_per_file)
+ def normalize_query_tags(self, value: object) -> list[str]:
+ """Normalize lookup tags without truncating the query expression."""
+ return self._normalize_tags(value, limit=None)
+
@staticmethod
def _validate_path(path: str) -> str:
if not isinstance(path, str) or not path or "\\" in path:
@@ -70,7 +74,8 @@ class LocalTagIndex(BaseTagIndex):
prepared: list[tuple[str, tuple[str, ...]]] = []
for node in nodes:
path = self._validate_path(node.path)
- tags = self.normalize_tags(node.front_matter.model_dump().get("tags"))
+ frontmatter = node.front_matter.model_extra or {}
+ tags = self.normalize_tags(frontmatter.get(self.tag_key))
prepared.append((path, tuple(tags)))
return prepared
@@ -127,7 +132,7 @@ class LocalTagIndex(BaseTagIndex):
# ``max_tags_per_file`` constrains indexed documents, not lookup
# expressions. Truncating here would silently weaken AND queries and
# omit valid matches from OR queries.
- normalized = self._normalize_tags(tags, limit=None)
+ normalized = self.normalize_query_tags(tags)
if not normalized:
return []
async with self._maintenance_lock:
@@ -142,6 +147,57 @@ class LocalTagIndex(BaseTagIndex):
async with self._maintenance_lock:
return list(self.path_to_tags.get(path, ()))
+ async def list_tags(
+ self,
+ *,
+ page: int = 1,
+ order_by: TagOrderBy = "tag",
+ order: TagOrder | None = None,
+ page_size: int = 100,
+ ) -> TagListResult:
+ """Return a deterministic page of active tags, counts, and its 1-based range."""
+ page = self._positive_int("page", page)
+ page_size = self._positive_int("page_size", page_size)
+ if page_size > 1000:
+ raise ValueError("page_size must be less than or equal to 1000")
+
+ if not isinstance(order_by, str):
+ raise ValueError("order_by must be one of ['file_count', 'tag']")
+ order_by = order_by.lower()
+ if order_by not in {"tag", "file_count"}:
+ raise ValueError("order_by must be one of ['file_count', 'tag']")
+ if order is None:
+ order = "asc" if order_by == "tag" else "desc"
+ if not isinstance(order, str):
+ raise ValueError("order must be one of ['asc', 'desc']")
+ order = order.lower()
+ if order not in {"asc", "desc"}:
+ raise ValueError("order must be one of ['asc', 'desc']")
+
+ async with self._maintenance_lock:
+ if not self.is_healthy:
+ raise RuntimeError("tag index is unavailable")
+ items: list[TagListItem] = [(tag, len(paths)) for tag, paths in self.tag_to_paths.items()]
+
+ if order_by == "tag":
+ items.sort(key=lambda item: item[0], reverse=order == "desc")
+ else:
+ direction = 1 if order == "asc" else -1
+ items.sort(key=lambda item: (direction * item[1], item[0]))
+
+ total_tags = len(items)
+ total_pages = (total_tags + page_size - 1) // page_size
+ start = (page - 1) * page_size
+ page_items = items[start : start + page_size]
+ item_range = (start + 1, start + len(page_items)) if page_items else (0, 0)
+ return {
+ "total_tags": total_tags,
+ "total_pages": total_pages,
+ "page": page,
+ "range": item_range,
+ "items": page_items,
+ }
+
async def clear(self) -> None:
async with self._maintenance_lock:
self.path_to_tags = {}
diff --git a/reme/config/benchmark.yaml b/reme/config/benchmark.yaml
index d9d51c3e..99cb05ef 100644
--- a/reme/config/benchmark.yaml
+++ b/reme/config/benchmark.yaml
@@ -391,18 +391,6 @@ components:
parameters:
max_tokens: 65536
thinking_enable: false
- judge:
- backend: ${LLM_BACKEND:-openai}
- model: ${JUDGE_MODEL_NAME:-qwen3.7-max}
- stream: false
- context_size: 200000
- max_retries: 5
- credential:
- api_key: ${LLM_API_KEY:-}
- base_url: ${LLM_BASE_URL:-}
- parameters:
- max_tokens: 65536
- thinking_enable: false
bench:
backend: ${LLM_BACKEND:-openai}
model: ${BENCH_MODEL_NAME:-qwen3.7-max}
@@ -443,18 +431,6 @@ components:
tool_result_limit: 50000
model_config:
max_retries: 1
- judge:
- backend: agentscope
- as_llm: judge
- permission_mode: bypass
- react_config:
- max_iters: 1
- context_config:
- trigger_ratio: 0.8
- reserve_ratio: 0.1
- tool_result_limit: 50000
- model_config:
- max_retries: 1
bench:
backend: agentscope
as_llm: bench
diff --git a/reme/config/default.yaml b/reme/config/default.yaml
index 4b26a2f2..0624a709 100644
--- a/reme/config/default.yaml
+++ b/reme/config/default.yaml
@@ -72,6 +72,7 @@ jobs:
- backend: dream_integrate_step
- backend: dream_finish_step
file_catalog: dream
+ - backend: auto_tag_step
optimize_index_cron:
backend: cron
@@ -161,6 +162,7 @@ jobs:
- backend: dream_integrate_step
- backend: dream_finish_step
file_catalog: dream
+ - backend: auto_tag_step
auto_memory:
backend: base
@@ -188,7 +190,7 @@ jobs:
- messages
steps:
- backend: auto_memory_step
- enable_tags: false
+ - backend: auto_tag_step
auto_memory_cc:
backend: base
@@ -206,6 +208,7 @@ jobs:
- session_id
steps:
- backend: auto_memory_cc_step
+ - backend: auto_tag_step
auto_resource:
backend: base
@@ -388,6 +391,37 @@ jobs:
steps:
- backend: graph_snapshot_step
+ list_tags:
+ backend: base
+ description: >-
+ List active tags with file counts. Returns {total_tags, total_pages, page, range, items}; range is the inclusive
+ 1-based item range and each item is [tag, file_count]. A page past the end returns empty items and range [0, 0].
+ parameters:
+ type: object
+ properties:
+ page:
+ type: integer
+ minimum: 1
+ default: 1
+ description: "1-based page; values past the end return an empty page"
+ order_by:
+ type: string
+ enum: [tag, file_count]
+ default: tag
+ description: "sort by tag or file count"
+ order:
+ type: string
+ enum: [asc, desc]
+ description: "defaults to asc for tag, desc for file_count"
+ page_size:
+ type: integer
+ minimum: 1
+ maximum: 1000
+ default: 100
+ description: "items per page"
+ steps:
+ - backend: list_tags_step
+
reindex:
backend: base
description: "rebuild BM25, embedding, and/or tag indexes without rescanning workspace files"
@@ -418,6 +452,12 @@ jobs:
type: number
description: "min fused score"
default: 0.0
+ tags:
+ type: array
+ items:
+ type: string
+ description: "optional tags filter; a file matches when it contains at least one valid tag"
+ default: []
start_date:
type: string
description: "optional inclusive start date filter (YYYY-MM-DD); results earlier than this date are excluded"
@@ -515,7 +555,7 @@ jobs:
frontmatter_update:
backend: base
- description: "Merge key-values into a file's frontmatter."
+ description: "Merge key-value pairs into a Markdown file's frontmatter while preserving its body and unrelated fields."
parameters:
type: object
properties:
@@ -896,11 +936,12 @@ components:
backend: bm25
tokenizer: default
-# tag_index:
-# default:
-# backend: local
-# max_tags_per_file: 8
-# max_tag_length: 64
+ tag_index:
+ default:
+ backend: local
+ tag_key: memory_tags
+ max_tags_per_file: 3
+ max_tag_length: 64
file_store:
default:
@@ -911,4 +952,4 @@ components:
embedding_store: ""
keyword_index: default
file_graph: default
-# tag_index: default
+ tag_index: default
diff --git a/reme/constants.py b/reme/constants.py
index c9566a7a..d58a3986 100644
--- a/reme/constants.py
+++ b/reme/constants.py
@@ -18,3 +18,8 @@ DEFAULT_MAX_IMAGE_BYTES = 5 * 1024 * 1024
# Background content-processing jobs skip files above this size. File watchers
# and catalogs still track them so deletes and later size reductions are seen.
DEFAULT_MAX_FILE_BYTES = 20 * 1024 * 1024
+
+# Memory-tag generation and indexing defaults.
+DEFAULT_MEMORY_TAG_KEY = "memory_tags"
+DEFAULT_MAX_MEMORY_TAGS = 3
+DEFAULT_MAX_MEMORY_TAG_LENGTH = 64
diff --git a/reme/steps/base_step.py b/reme/steps/base_step.py
index da9bce91..b2042237 100644
--- a/reme/steps/base_step.py
+++ b/reme/steps/base_step.py
@@ -71,12 +71,18 @@ class Ref:
obj.__dict__.pop(self._cache_attr, None)
def _resolve(self, obj: "BaseStep"):
- for source in (obj.kwargs, obj.context or {}):
+ sources = (obj.kwargs, obj.context or {})
+ for source in sources:
value = source.get(self.key)
if isinstance(value, self.base_cls):
return value
- name = obj.kwargs.get(self.key, "default")
+ name = "default"
+ for source in sources:
+ value = source.get(self.key)
+ if isinstance(value, str):
+ name = value
+ break
if obj.app_context is None:
if self.optional:
return None
diff --git a/reme/steps/evolve/__init__.py b/reme/steps/evolve/__init__.py
index c32b3b9b..fe9e6dbe 100644
--- a/reme/steps/evolve/__init__.py
+++ b/reme/steps/evolve/__init__.py
@@ -3,6 +3,7 @@
from ._evolve import now, passthrough_response
from .auto_image_resource import AutoImageResourceStep
from .auto_memory import AutoMemoryStep
+from .auto_tag import AutoTagStep
from .auto_memory_cc import AutoMemoryCCStep
from .auto_resource import AutoResourceStep
from .auto_text_resource import AutoTextResourceStep
@@ -22,6 +23,7 @@ __all__ = [
"AutoImageResourceStep",
"passthrough_response",
"AutoMemoryStep",
+ "AutoTagStep",
"AutoMemoryCCStep",
"AutoResourceStep",
"AutoTextResourceStep",
diff --git a/reme/steps/evolve/auto_memory.py b/reme/steps/evolve/auto_memory.py
index 9961371f..8cf29a1f 100644
--- a/reme/steps/evolve/auto_memory.py
+++ b/reme/steps/evolve/auto_memory.py
@@ -17,9 +17,6 @@ from ...components import R
_SESSION_ID_KEY = "session_id"
_SOURCE_CONVERSATION_KEY = "source_conversation"
-_TAGS_KEY = "tags"
-_MAX_TAGS = 8
-_MAX_TAG_LENGTH = 64
_MESSAGE_TIME_ALIASES = ("time_created", "timestamp", "createdAt", "timeCreated", "created_time")
@@ -62,39 +59,6 @@ def _normalize_msg_timestamp(item: dict) -> dict:
return item
-def _normalize_tags(value) -> list[str]:
- """Return up to eight unique, retrieval-friendly frontmatter tags.
-
- Tags are stored uniformly as strings. Technical tokens such as ``GPT-5``,
- ``C++``, ``C#``, and ``.NET`` are valid; whitespace-delimited phrases and
- punctuation-only values are not.
- """
- if not isinstance(value, list):
- return []
-
- tags: list[str] = []
- seen: set[str] = set()
- for item in value:
- if isinstance(item, bool) or not isinstance(item, (str, int)):
- continue
- tag = str(item).strip()
- if not tag or len(tag) > _MAX_TAG_LENGTH:
- continue
- if any(char.isspace() for char in tag):
- continue
- if not any(char.isalnum() for char in tag):
- continue
-
- dedupe_key = tag.casefold()
- if dedupe_key in seen:
- continue
- seen.add(dedupe_key)
- tags.append(tag)
- if len(tags) >= _MAX_TAGS:
- break
- return tags
-
-
@R.register("auto_memory_step")
class AutoMemoryStep(BaseStep):
"""Record conversation facts into a daily note via an Agent."""
@@ -119,10 +83,6 @@ class AutoMemoryStep(BaseStep):
def _daily_note_path(self, day: str, name: str) -> str:
return f"{self.config_value('daily_dir')}/{day}/{name}.md"
- def _tags_enabled(self) -> bool:
- """Whether this step should generate and normalize frontmatter tags."""
- return bool(self.kwargs.get("enable_tags", False))
-
def _frontmatter(self, path: str) -> dict:
post = frontmatter.loads((self.file_store.workspace_path / path).read_text(encoding="utf-8"))
return dict(post.metadata or {})
@@ -158,14 +118,12 @@ class AutoMemoryStep(BaseStep):
notes = list_response.metadata.get("notes") or []
return self._find_session_note(notes, session_id)
- async def _ensure_memory_frontmatter(self, path: str, session_id: str) -> None:
- current = self._frontmatter(path)
+ async def _ensure_session_frontmatter(self, path: str, session_id: str) -> None:
metadata = {
_SESSION_ID_KEY: session_id,
_SOURCE_CONVERSATION_KEY: self._session_link(session_id),
}
- if self._tags_enabled():
- metadata[_TAGS_KEY] = _normalize_tags(current.get(_TAGS_KEY))
+ current = self._frontmatter(path)
if all(current.get(key) == value for key, value in metadata.items()):
return
response = await self.run_job(
@@ -318,6 +276,7 @@ class AutoMemoryStep(BaseStep):
# pylint: disable=too-many-return-statements
async def execute(self):
assert self.context is not None
+ self.context["changes"] = []
raw_messages = self.context.get("messages") or []
session_id: str = self.context.get("session_id", "")
memory_hint: str = self.context.get("memory_hint", "")
@@ -381,7 +340,6 @@ class AutoMemoryStep(BaseStep):
template_key = "user_message_create" if created else "user_message_update"
user_message = self.prompt_format(
template_key,
- enable_tags=self._tags_enabled(),
today=day,
note=memory_hint or "(none)",
note_path=note_path,
@@ -399,7 +357,7 @@ class AutoMemoryStep(BaseStep):
reply_kwargs["injected_job_kwargs"] = {"_allowed_paths": [note_path]}
result = await self.agent_wrapper.reply(
user_message,
- system_prompt=self.prompt_format("system_prompt", enable_tags=self._tags_enabled()),
+ system_prompt=self.prompt_format("system_prompt"),
job_tools=self.create_tools if created else self.update_tools,
**reply_kwargs,
)
@@ -425,27 +383,28 @@ class AutoMemoryStep(BaseStep):
self.logger.info(f"[{self.name}] done without note session_id={session_id!r} modified=False")
return
note_path = str(note["path"])
- try:
- if not created or self._tags_enabled():
- await self._ensure_memory_frontmatter(note_path, session_id)
- if not created:
+ else:
+ try:
+ await self._ensure_session_frontmatter(note_path, session_id)
note_path = await self._rename_from_frontmatter_name(note_path, day)
- except RuntimeError as exc:
- self.context.response.success = False
- self.context.response.answer = str(exc)
- self.context.response.metadata.update(
- {
- "date": day,
- "path": note_path,
- "created": created,
- "modified": self._note_modified(before_note_path, before_note_bytes, note_path),
- "n_messages": len(messages),
- },
- )
- self.logger.info(f"[{self.name}] post-write failed path={note_path} answer={str(exc)!r}")
- return
+ except RuntimeError as exc:
+ self.context.response.success = False
+ self.context.response.answer = str(exc)
+ self.context.response.metadata.update(
+ {
+ "date": day,
+ "path": note_path,
+ "created": created,
+ "modified": self._note_modified(before_note_path, before_note_bytes, note_path),
+ "n_messages": len(messages),
+ },
+ )
+ self.logger.info(f"[{self.name}] post-update failed path={note_path} answer={str(exc)!r}")
+ return
modified = self._note_modified(before_note_path, before_note_bytes, note_path)
+ if modified:
+ self.context["changes"] = [{"change": "added" if created else "modified", "path": note_path}]
daily_dir = self.config_value("daily_dir")
self.logger.info(f"[{self.name}] refresh index start date={day} daily_dir={daily_dir}")
index_payload = await refresh_day_index(self.file_store, day, daily_dir)
diff --git a/reme/steps/evolve/auto_memory.yaml b/reme/steps/evolve/auto_memory.yaml
index 76df7878..0767a502 100644
--- a/reme/steps/evolve/auto_memory.yaml
+++ b/reme/steps/evolve/auto_memory.yaml
@@ -20,7 +20,6 @@ system_prompt: |
- `name` = a concise, stable topic/event filename stem, such as `cold-remedies` or `project-kickoff-decision`. Do not include today's date or the daily directory date; the outer daily path already records the date. For existing notes, update it when a better filename is clearly warranted.
- `description` = a thorough summary; vague descriptions like "notes" / "misc" are unacceptable.
- [enable_tags] - `tags` = 0–8 unique retrieval keywords for the complete note. Always include the field, using `[]` when no useful tags exist. Each tag must be one string with no whitespace, may contain technical punctuation (for example `GPT-5`, `C++`, `C#`, or `.NET`), must contain at least one letter or digit, and must be at most 64 characters. Store numeric tags as strings, for example `"100"`.
- **Never set `status`** — it is a field reserved for downstream processing.
system_prompt_zh: |
你是自动记忆系统。你的职责是将最近对话中的核心信息记录到日记记忆中。思考人类会从这段对话中自然地记住什么——不是所有内容，而是真正重要的信息。
@@ -44,7 +43,6 @@ system_prompt_zh: |
- `name` = 简洁、稳定的主题/事件文件名 stem，例如 `cold-remedies` 或 `project-kickoff-decision`。不要包含今天日期或日记目录日期；外层日记路径已经记录日期。对已有笔记，如果明显有更好的文件名，就更新它。
- `description` = 详细总结；模糊的描述如 "notes" / "misc" 不可接受。
- [enable_tags] - `tags` = 针对完整笔记的 0–8 个不重复检索关键词。该字段必须始终存在；没有合适关键词时使用 `[]`。每个 tag 必须是一个不含空白字符的字符串，可以包含技术名称中的标点（例如 `GPT-5`、`C++`、`C#` 或 `.NET`），必须至少包含一个字母或数字，且不得超过 64 个字符。数字 tag 也保存为字符串，例如 `"100"`。
- **永远不要设置 `status`**——它是下游处理保留的字段。
user_message_create: |
@@ -70,13 +68,11 @@ user_message_create: |
Create the note in one shot:
`daily_write name= description= session_id={session_id} date={today} content=`
- [enable_tags] Also pass `metadata={{"tags": [, ...]}}` in the same `daily_write` call.
- Generate `name` as a concise, stable topic/event filename stem for this memory. Prefer a reusable topic or event summary, optionally in kebab-case.
- Do not include today's date or the daily directory date in `name`; the note already lives under today's daily path.
- `name` must be a valid single filename component: no slash, backslash, leading/trailing whitespace, or characters like `< > : " | ? *`.
- `description` must be a thorough summary of the body — specific enough that the description alone conveys all key information.
- [enable_tags] - Generate 0–8 `tags` from the complete note. Always pass `metadata={{"tags": [...]}}`, including an empty list when there are no useful tags. Follow the system prompt's tag format exactly.
## Step 3 — Summary
@@ -108,13 +104,11 @@ user_message_create_zh: |
一次性创建笔记：
`daily_write name= description= session_id={session_id} date={today} content=<正文>`
- [enable_tags] 在同一次 `daily_write` 调用中另外传入 `metadata={{"tags": [, ...]}}`。
- 由你生成 `name`，作为这条记忆简洁、稳定的主题/事件文件名 stem。优先使用可复用的主题或事件总结，可以采用 kebab-case。
- `name` 不要包含今天日期或日记目录日期；笔记已经位于当天日记路径下。
- `name` 必须是合法的单个文件名组件：不能包含 slash、反斜杠、首尾空白，或 `< > : " | ? *` 等字符。
- `description` 必须是正文的详尽总结——具体到仅凭 description 就能传达全部核心信息。
- [enable_tags] - 根据完整笔记生成 0–8 个 `tags`。必须始终传入 `metadata={{"tags": [...]}}`，没有合适关键词时也要传入空数组。严格遵守 system prompt 的 tag 格式。
## 步骤 3 — 总结
@@ -161,22 +155,18 @@ user_message_update: |
Execution:
1. Use `edit path={note_path} old= new=` for each section that needs updating. You may call `edit` multiple times.
2. After body changes, refresh frontmatter with `frontmatter_update path={note_path} metadata={{"name": "", "description": ""}}`.
- [enable_tags] Also regenerate 0–8 tags from the complete merged note and include `"tags": [, ...]` in the same metadata object. Always include `tags`, using `[]` when none are useful.
- Keep the existing `name` only when it is already the best concise topic/event filename stem. The system will rename the file after your final response.
- Do not add today's date or the daily directory date to `name`.
3. If `edit` fails repeatedly (e.g., cannot find the original text due to formatting mismatch), fall back to `write path={note_path} name= description= content=` for a complete rewrite.
- [enable_tags] In this fallback, also pass `metadata={{"tags": [, ...]}}`.
## Step 3b — Full Write (Empty File Fallback)
The file exists but its body is empty. Write the full content in one shot:
`write path={note_path} name= description= content=`
- [enable_tags] Also pass `metadata={{"tags": [, ...]}}` in this call.
- Use a concise, stable topic/event `name`; filename changes are applied after your final response.
- Do not include today's date or the daily directory date in `name`.
- `description` must be a thorough summary of the body — specific enough that the description alone conveys all key information.
- [enable_tags] - Generate 0–8 tags from the complete body and always include `metadata={{"tags": [...]}}`, using `[]` when none are useful.
## Step 4 — Summary
@@ -224,22 +214,18 @@ user_message_update_zh: |
执行：
1. 对需要更新的每个部分使用 `edit path={note_path} old=<原文片段> new=<替换片段>`。可以多次调用 `edit`。
2. 正文变更后，刷新 frontmatter：`frontmatter_update path={note_path} metadata={{"name": "<更新后的文件名 stem>", "description": "<更新后的总结>"}}`。
- [enable_tags] 同时根据合并后的完整笔记重新生成 0–8 个 tags，并在同一个 metadata 对象中包含 `"tags": [, ...]`。必须始终包含 `tags`，没有合适关键词时使用 `[]`。
- 只有当前 `name` 已经是最合适的简洁主题/事件文件名 stem 时才保留。系统会在你最终回复后负责重命名文件。
- 不要在 `name` 中加入今天日期或日记目录日期。
3. 如果 `edit` 多次失败（如因格式不匹配找不到原文），退回 `write path={note_path} name= description= content=<完整正文>` 全量重写。
- [enable_tags] 在该 fallback 中还要传入 `metadata={{"tags": [, ...]}}`。
## 步骤 3b — 全量写入（空文件 fallback）
文件存在但正文为空。一次性写入完整内容：
`write path={note_path} name= description= content=<正文>`
- [enable_tags] 在该调用中另外传入 `metadata={{"tags": [, ...]}}`。
- 使用简洁、稳定的主题/事件 `name`；文件名变化会在你最终回复后应用。
- `name` 不要包含今天日期或日记目录日期。
- `description` 必须是正文的详尽总结——具体到仅凭 description 就能传达全部核心信息。
- [enable_tags] - 根据完整正文生成 0–8 个 tags，并始终包含 `metadata={{"tags": [...]}}`；没有合适关键词时使用 `[]`。
## 步骤 4 — 总结
diff --git a/reme/steps/evolve/auto_tag.py b/reme/steps/evolve/auto_tag.py
new file mode 100644
index 00000000..05ea0604
--- /dev/null
+++ b/reme/steps/evolve/auto_tag.py
@@ -0,0 +1,192 @@
+"""Generate entity-oriented memory tags for added or modified Markdown files."""
+
+from dataclasses import dataclass
+from typing import Literal
+
+import frontmatter
+
+from ._evolve import agent_reply_result_text
+from ..base_step import BaseStep
+from ..file_io._path import display_path, resolve_path
+from ..index import normalize_posix_path
+from ...components import R
+from ...constants import DEFAULT_MAX_MEMORY_TAG_LENGTH, DEFAULT_MAX_MEMORY_TAGS
+
+_SUPPORTED_CHANGES = {"added", "modified"}
+
+
+@dataclass(frozen=True)
+class _TagTarget:
+ change: Literal["added", "modified"]
+ path: str
+
+
+def normalize_memory_tags(
+ value: object,
+ *,
+ max_tags_per_file: int = DEFAULT_MAX_MEMORY_TAGS,
+ max_tag_length: int = DEFAULT_MAX_MEMORY_TAG_LENGTH,
+) -> list[str]:
+ """Normalize source tags while preserving canonical display casing."""
+ if not isinstance(value, list):
+ return []
+
+ tags: list[str] = []
+ seen: set[str] = set()
+ for item in value:
+ if not isinstance(item, str):
+ continue
+ tag = "_".join(item.split())
+ if not tag or len(tag) > max_tag_length or not any(char.isalnum() for char in tag):
+ continue
+ canonical = tag.casefold()
+ if canonical in seen:
+ continue
+ seen.add(canonical)
+ tags.append(tag)
+ if len(tags) >= max_tags_per_file:
+ break
+ return tags
+
+
+@R.register("auto_tag_step")
+class AutoTagStep(BaseStep):
+ """Update memory tags for Markdown files described by the common ``changes`` contract."""
+
+ def __init__(self, **kwargs):
+ super().__init__(**kwargs)
+ self.tools = ["read", "list_tags", "frontmatter_read", "frontmatter_update"]
+
+ def _targets(self) -> tuple[list[_TagTarget], list[dict[str, str]]]:
+ """Validate, normalize, and de-duplicate added/modified Markdown changes."""
+ assert self.context is not None
+ raw_changes = self.context.get("changes") or []
+ if not isinstance(raw_changes, list):
+ raise ValueError("AutoTagStep requires changes: list[dict]")
+
+ workspace = self.workspace_path.resolve()
+ targets: dict[str, _TagTarget] = {}
+ ignored: list[dict[str, str]] = []
+ for item in raw_changes:
+ if not isinstance(item, dict):
+ ignored.append({"path": "", "reason": "change must be an object"})
+ continue
+
+ change = str(item.get("change") or "").strip().lower()
+ raw_path = str(item.get("path") or "").strip()
+ if change not in _SUPPORTED_CHANGES:
+ ignored.append(
+ {
+ "path": raw_path,
+ "reason": f"unsupported change: {change or 'missing'}",
+ },
+ )
+ continue
+
+ target, error = resolve_path(workspace, raw_path)
+ if error or target is None:
+ ignored.append({"path": raw_path, "reason": error or "invalid path"})
+ continue
+ if not target.is_file():
+ ignored.append({"path": raw_path, "reason": "not a file"})
+ continue
+ if target.suffix.lower() != ".md":
+ ignored.append({"path": raw_path, "reason": "not a Markdown file"})
+ continue
+
+ path = normalize_posix_path(display_path(workspace, target))
+ previous = targets.get(path)
+ was_added = previous is not None and previous.change == "added"
+ normalized_change: Literal["added", "modified"] = "added" if change == "added" or was_added else "modified"
+ targets[path] = _TagTarget(change=normalized_change, path=path)
+ return list(targets.values()), ignored
+
+ async def _process_target(self, target: _TagTarget) -> str:
+ file_store = self.file_store
+ tag_index = file_store.require_tag_index()
+ tag_key = tag_index.tag_key
+ tool_context = {
+ "file_store": file_store.name,
+ "_allowed_paths": [target.path],
+ "_allowed_frontmatter_keys": [tag_key],
+ }
+ result = await self.agent_wrapper.reply(
+ self.prompt_format("user_message", path=target.path, change=target.change, tag_key=tag_key),
+ system_prompt=self.prompt_format(
+ "system_prompt",
+ tag_key=tag_key,
+ max_tags_per_file=tag_index.max_tags_per_file,
+ ),
+ job_tools=self.tools,
+ injected_job_kwargs=tool_context,
+ )
+
+ path = self.workspace_path / target.path
+ metadata = dict(frontmatter.loads(path.read_text(encoding="utf-8")).metadata or {})
+ normalized = normalize_memory_tags(
+ metadata.get(tag_key),
+ max_tags_per_file=tag_index.max_tags_per_file,
+ max_tag_length=tag_index.max_tag_length,
+ )
+ if metadata.get(tag_key) != normalized:
+ response = await self.run_job(
+ "frontmatter_update",
+ path=target.path,
+ metadata={tag_key: normalized},
+ **tool_context,
+ )
+ if not response.success:
+ raise RuntimeError(str(response.answer))
+ return agent_reply_result_text(result)
+
+ async def execute(self):
+ assert self.context is not None
+ initial_success = self.context.response.success
+ initial_answer = self.context.response.answer
+ try:
+ targets, ignored = self._targets()
+ except ValueError as exc:
+ self.context.response.success = False
+ self.context.response.answer = str(exc)
+ return self.context.response
+
+ results: list[dict] = []
+ for target in targets:
+ try:
+ summary = await self._process_target(target)
+ results.append(
+ {
+ "change": target.change,
+ "path": target.path,
+ "success": True,
+ "summary": summary,
+ },
+ )
+ except Exception as exc: # pylint: disable=broad-exception-caught
+ results.append(
+ {
+ "change": target.change,
+ "path": target.path,
+ "success": False,
+ "error": str(exc),
+ },
+ )
+ self.logger.warning(f"[{self.name}] failed path={target.path}: {exc}")
+
+ failed = sum(not item["success"] for item in results)
+ succeeded = len(results) - failed
+ self.context.response.success = initial_success
+ if not initial_answer and failed:
+ self.context.response.answer = f"Tagged {succeeded} file(s); {failed} failed"
+ elif not initial_answer and succeeded:
+ self.context.response.answer = f"Tagged {succeeded} file(s)"
+ else:
+ self.context.response.answer = initial_answer
+ self.context.response.metadata["auto_tag"] = {
+ "processed": len(results),
+ "succeeded": succeeded,
+ "failed": failed,
+ "ignored": ignored,
+ "results": results,
+ }
+ return self.context.response
diff --git a/reme/steps/evolve/auto_tag.yaml b/reme/steps/evolve/auto_tag.yaml
new file mode 100644
index 00000000..0b3f5e45
--- /dev/null
+++ b/reme/steps/evolve/auto_tag.yaml
@@ -0,0 +1,45 @@
+system_prompt: |
+ You maintain entity-oriented memory tags for one Markdown memory file at a time.
+
+ The `{tag_key}` field answers: "Who or what real-world entity is this memory about?"
+
+ Required workflow:
+ 1. Use `read` and `frontmatter_read` to inspect the complete target document and its current frontmatter.
+ 2. Use `list_tags` to inspect tags already used in the workspace. Check additional pages when useful.
+ 3. Prefer one primary entity that best answers the question. Use multiple tags only when the memory is genuinely
+ about multiple independent central entities, and never use more than {max_tags_per_file}. Prefer an existing tag
+ whenever it represents the same entity. Tags must not contain spaces; replace spaces with underscores, for example
+ `sam_altman`. Examples include a person (`sam_altman`), an organization (`OpenAI`), or an asset/entity (`gold`).
+ 4. Use `frontmatter_update` to write the complete `{tag_key}` list, including `[]` when no entity is central.
+
+ Choose entities, not broad topics, activities, attributes, dates, or generic keywords. Keep the canonical real-world
+ name and use one concise string per entity. Store multiple entities as separate YAML list items, for example
+ `[OpenAI, gold]`; never combine them into one comma-delimited string. Do not create aliases or near-duplicate
+ spellings for an existing tag. Update only `{tag_key}`; never change the document body or another frontmatter field.
+system_prompt_zh: |
+ 你负责为每一份 Markdown 记忆维护以实体为中心的记忆标签。
+
+ `{tag_key}` 字段回答的问题是：“这份记忆是关于谁或什么现实实体的？”
+
+ 必须遵循以下流程：
+ 1. 使用 `read` 和 `frontmatter_read` 阅读目标文档的完整内容及当前 frontmatter。
+ 2. 使用 `list_tags` 查看工作区已经使用的标签；必要时继续查看后续分页。
+ 3. 默认只选择一个最能回答上述问题的主实体。只有当记忆确实同时围绕多个相互独立的核心实体时，才选择
+ 多个标签，并且绝不能超过 {max_tags_per_file} 个。同一实体已有标签时必须优先复用。标签中不能包含空格；
+ 如有空格，必须替换为下划线，例如将 `Sam Altman` 写成 `sam_altman`。实体可以是人物（如 `sam_altman`）、
+ 组织或公司（如 `宁德时代`），也可以是资产等实体（如 `黄金`）。
+ 4. 使用 `frontmatter_update` 写入完整的 `{tag_key}` 列表；没有核心实体时也要写入 `[]`。
+
+ 只选择实体，不要使用宽泛主题、行为、属性、日期或普通关键词。每个实体使用一个简洁、规范的现实名称。
+ 多个实体必须保存为独立的 YAML 列表项，例如 `[宁德时代, 黄金]`；不要把它们拼成一个逗号分隔的字符串。
+ 不要为已有实体创造别名或近似拼写。只能更新 `{tag_key}`，绝不能修改正文或其他 frontmatter 字段。
+user_message: |
+ Change: {change}
+ Target path: {path}
+
+ Follow the required workflow and update this document's `{tag_key}` field.
+user_message_zh: |
+ 变更类型：{change}
+ 目标路径：{path}
+
+ 按照规定流程更新这份文档的 `{tag_key}` 字段。
diff --git a/reme/steps/evolve/dream/integrate.py b/reme/steps/evolve/dream/integrate.py
index 763467f9..12569e7e 100644
--- a/reme/steps/evolve/dream/integrate.py
+++ b/reme/steps/evolve/dream/integrate.py
@@ -57,6 +57,7 @@ class DreamIntegrateStep(BaseStep):
async def execute(self):
assert self.context is not None
+ self.context["changes"] = []
state = state_from_context(self)
if not state.units:
self.logger.info(f"[{self.name}] skip no units")
@@ -81,8 +82,16 @@ class DreamIntegrateStep(BaseStep):
for bucket in DreamBucketEnum:
(workspace / digest_dir / bucket.value).mkdir(parents=True, exist_ok=True)
self.logger.info(f"[{self.name}] digest dirs ready buckets={len(list(DreamBucketEnum))}")
+ # Compare the whole run so retries and later units updating a newly
+ # created file still emit one "added" change for the final file.
+ before = _snapshot_digest(workspace, digest_dir)
for i, unit in enumerate(state.units, start=1):
await self._integrate_one(state, unit, i, workspace, digest_dir)
+ after = _snapshot_digest(workspace, digest_dir)
+ self.context["changes"] = [
+ {"change": "modified" if path in before else "added", "path": path}
+ for path in _changed_digest_paths(before, after)
+ ]
state.failed_paths = sorted(set(state.failed_paths))
answer = (
f"Integrated {len(state.integrate_results)} unit(s); skipped {len(state.skipped_units)} unit(s); "
diff --git a/reme/steps/evolve/dream/utils.py b/reme/steps/evolve/dream/utils.py
index 7701d005..2f41d27d 100644
--- a/reme/steps/evolve/dream/utils.py
+++ b/reme/steps/evolve/dream/utils.py
@@ -31,8 +31,7 @@ def store_state(step: BaseStep, state: DreamState) -> None:
def workspace_dir(step: BaseStep) -> Path:
"""Get workspace directory."""
- vr = getattr(step.file_store, "workspace_path", None)
- return Path(vr).resolve() if vr else Path.cwd().resolve()
+ return step.file_store.workspace_path.resolve()
def daily_dir(step: BaseStep) -> str:
diff --git a/reme/steps/file_io/frontmatter_update.py b/reme/steps/file_io/frontmatter_update.py
index cc4b8f2d..e8801c13 100644
--- a/reme/steps/file_io/frontmatter_update.py
+++ b/reme/steps/file_io/frontmatter_update.py
@@ -30,6 +30,10 @@ class FrontmatterUpdateStep(BaseStep):
injected by the server into the RuntimeContext;
without it, restricting read/edit/write alone would still leave
frontmatter of arbitrary workspace Markdown files mutable.
+
+ ``_allowed_frontmatter_keys`` optionally limits updates to an injected
+ list of top-level keys. Omitting it (or setting it to ``None``) preserves
+ the unrestricted historical behavior.
"""
async def execute(self):
@@ -39,6 +43,18 @@ class FrontmatterUpdateStep(BaseStep):
metadata = self.context.get("metadata") or {}
assert isinstance(metadata, dict), "metadata must be a dict"
+ allowed_keys = self.context.get("_allowed_frontmatter_keys")
+ key_error: str | None = None
+ if allowed_keys is not None:
+ if not isinstance(allowed_keys, list) or any(not isinstance(key, str) for key in allowed_keys):
+ key_error = "_allowed_frontmatter_keys must be a list of strings"
+ else:
+ allowed = set(allowed_keys)
+ denied = [key for key in metadata if not isinstance(key, str) or key not in allowed]
+ if denied:
+ names = ", ".join(sorted(repr(key) for key in denied))
+ key_error = f"frontmatter key(s) not allowed: {names}"
+
workspace_dir = Path(self.file_store.workspace_path or ".").resolve()
target, err = resolve_path(workspace_dir, path)
if err or target is None:
@@ -57,6 +73,8 @@ class FrontmatterUpdateStep(BaseStep):
payload = {"path": path, "error": "not markdown"}
elif not metadata:
payload = {"path": path, "error": "no fields to update"}
+ elif key_error:
+ payload = {"path": path, "error": key_error}
else:
post = frontmatter.loads(target.read_text(encoding="utf-8"))
post.metadata.update(metadata)
diff --git a/reme/steps/index/__init__.py b/reme/steps/index/__init__.py
index b5dbb59e..2780b251 100644
--- a/reme/steps/index/__init__.py
+++ b/reme/steps/index/__init__.py
@@ -7,6 +7,7 @@ from .clear_store import ClearStoreStep
from .draft import AddDraftStep, ReadAllDraftStep
from .graph_snapshot import GraphSnapshotStep
from .log_changes import LogChangesStep
+from .list_tags import ListTagsStep
from .node_search import NodeSearchStep
from .init_changes import InitChangesStep
from .optimize_index import OptimizeIndexStep
@@ -35,6 +36,7 @@ __all__ = [
"GraphSnapshotStep",
"InitChangesStep",
"LogChangesStep",
+ "ListTagsStep",
"NodeSearchStep",
"normalize_posix_path",
"ReadAllDraftStep",
diff --git a/reme/steps/index/list_tags.py b/reme/steps/index/list_tags.py
new file mode 100644
index 00000000..aaa172d9
--- /dev/null
+++ b/reme/steps/index/list_tags.py
@@ -0,0 +1,22 @@
+"""Paginated listing of active file tags."""
+
+from ..base_step import BaseStep
+from ...components import R
+
+
+@R.register("list_tags_step")
+class ListTagsStep(BaseStep):
+ """Return one compact page of active tags and their indexed file counts."""
+
+ async def execute(self):
+ assert self.context is not None
+ tag_index = self.file_store.require_tag_index()
+
+ result = await tag_index.list_tags(
+ page=self.context.get("page", 1),
+ order_by=self.context.get("order_by", "tag"),
+ order=self.context.get("order"),
+ page_size=self.context.get("page_size", 100),
+ )
+ self.context.response.answer = result
+ return self.context.response
diff --git a/reme/steps/index/search.py b/reme/steps/index/search.py
index 9fee48a5..a7bc42a9 100644
--- a/reme/steps/index/search.py
+++ b/reme/steps/index/search.py
@@ -27,6 +27,13 @@ def _default_limit() -> int:
return _DEFAULT_LIMIT
+def _filter_values(value: object) -> set:
+ """Normalize a scalar or collection-valued search filter."""
+ if isinstance(value, (list, tuple, set, frozenset)):
+ return set(value)
+ return {value}
+
+
@R.register("search_step")
class SearchStep(BaseStep):
"""Hybrid search: run vector + keyword in parallel, fuse via RRF, filter, truncate."""
@@ -134,6 +141,66 @@ class SearchStep(BaseStep):
"ttl_seconds": ttl,
}
+ async def _resolve_tag_filter(
+ self,
+ raw_tags: object,
+ search_filter: dict,
+ ) -> tuple[dict, dict | None, str | None]:
+ """Merge tag-derived paths into the ordinary file-store filter."""
+ if not raw_tags:
+ return search_filter, None, None
+
+ if not self.file_store.tag_index_enabled:
+ self.logger.warning(
+ f"[{self.name}] tags requested but tag_index_unavailable",
+ )
+ return (
+ search_filter,
+ {"requested": True, "applied": False, "reason": "tag_index_unavailable"},
+ None,
+ )
+ tag_index = self.file_store.require_tag_index()
+ if not tag_index.is_healthy:
+ self.logger.warning(f"[{self.name}] tags requested but tag_index_unavailable")
+ return (
+ search_filter,
+ {"requested": True, "applied": False, "reason": "tag_index_unavailable"},
+ None,
+ )
+
+ normalized_tags = tag_index.normalize_query_tags(raw_tags)
+ if not normalized_tags:
+ return search_filter, None, "Error: tags contained no valid values"
+
+ allowed_paths = set(await tag_index.paths_for_tags(normalized_tags, match_all=False))
+ matched_path_count = len(allowed_paths)
+ if not tag_index.is_healthy:
+ self.logger.warning(
+ f"[{self.name}] tag index became unhealthy during lookup",
+ )
+ return (
+ search_filter,
+ {"requested": True, "applied": False, "reason": "tag_index_unavailable"},
+ None,
+ )
+
+ exact_paths = set()
+ has_exact_path_filter = False
+ for key in ("path", "paths"):
+ if key in search_filter:
+ has_exact_path_filter = True
+ exact_paths.update(_filter_values(search_filter.pop(key)))
+ if has_exact_path_filter:
+ allowed_paths.intersection_update(exact_paths)
+ search_filter["paths"] = sorted(allowed_paths)
+ metadata = {
+ "requested": True,
+ "applied": True,
+ "tags": normalized_tags,
+ "matched_paths": matched_path_count,
+ }
+ return search_filter, metadata, None
+
async def execute(self):
assert self.context is not None
query: str = (self.context.get("query", "") or "").strip()
@@ -170,6 +237,7 @@ class SearchStep(BaseStep):
candidates = min(_MAX_CANDIDATES, max(1, int(limit * candidate_multiplier)))
search_filter: dict = dict(self.context.get("search_filter", {}) or {})
+ raw_tags = self.context.get("tags", []) or []
# Promote top-level date parameters into search_filter for file_store.
for date_key in ("start_date", "end_date"):
@@ -208,6 +276,14 @@ class SearchStep(BaseStep):
if strict_date_filter:
search_filter["strict_date_filter"] = True
+ search_filter, tag_filter_metadata, tag_error = await self._resolve_tag_filter(raw_tags, search_filter)
+ if tag_error is not None:
+ self.context.response.success = False
+ self.context.response.answer = tag_error
+ if tag_filter_metadata is not None:
+ self.context.response.metadata["tag_filter"] = tag_filter_metadata
+ return self.context.response
+
text_weight = 1.0 - vector_weight
use_vector = vector_weight > 0.0
use_keyword = text_weight > 0.0
@@ -272,6 +348,8 @@ class SearchStep(BaseStep):
"returned": len(fused),
"hybrid": hybrid,
}
+ if tag_filter_metadata is not None:
+ self.context.response.metadata["tag_filter"] = tag_filter_metadata
if dedup is not None:
self.context.response.metadata["dedup"] = dedup
return self.context.response
diff --git a/reme/steps/index/update_changes.py b/reme/steps/index/update_changes.py
index 72c7f6c9..6ce461f0 100644
--- a/reme/steps/index/update_changes.py
+++ b/reme/steps/index/update_changes.py
@@ -351,13 +351,7 @@ class UpdateIndexStep(ChangeApplyStep):
return self._estimate_index_memory(size_bytes, len(item[1]))
def _estimate_index_memory(self, size_bytes: int, chunk_count: int) -> int:
- embedding_bytes = 0
- embedding_store = getattr(self.file_store, "embedding_store", None)
- if embedding_store is not None:
- try:
- embedding_bytes = max(0, int(embedding_store.dimensions)) * self.float16_bytes
- except (AttributeError, TypeError, ValueError):
- embedding_bytes = 0
+ embedding_bytes = self.file_store.embedding_dimensions * self.float16_bytes
expanded_content = int(size_bytes * self.batch_memory_expansion_factor)
per_chunk = self.chunk_memory_overhead_bytes + embedding_bytes
return expanded_content + self.file_memory_overhead_bytes + max(0, chunk_count) * per_chunk
diff --git a/reme/utils/logger_utils.py b/reme/utils/logger_utils.py
index 0cfe9ff7..ff87b58d 100644
--- a/reme/utils/logger_utils.py
+++ b/reme/utils/logger_utils.py
@@ -25,8 +25,14 @@ class _ForwardToLoggerHandler(logging.Handler):
def emit(self, record: logging.LogRecord) -> None:
target = logging.getLogger(self.target_name)
- if target.isEnabledFor(record.levelno):
- target.handle(record)
+ # Python 3.13 treats both ``isEnabledFor`` and ``handle`` as disabled
+ # during a nested logger call. Apply their stable public checks here,
+ # then dispatch directly so forwarded ReMe records are not dropped.
+ if target.disabled or target.manager.disable >= record.levelno or record.levelno < target.getEffectiveLevel():
+ return
+ filtered = target.filter(record)
+ if filtered:
+ target.callHandlers(filtered if isinstance(filtered, logging.LogRecord) else record)
class _QwenPawStdlibFormatter(logging.Formatter):
diff --git a/tests/integration/test_auto_tag.py b/tests/integration/test_auto_tag.py
new file mode 100644
index 00000000..3c154292
--- /dev/null
+++ b/tests/integration/test_auto_tag.py
@@ -0,0 +1,287 @@
+"""Real-LLM integration tests for ``auto_tag_step``.
+
+The fixtures mimic the final Markdown written by the Auto Fin and Daily Paper
+plugins, then invoke AutoTagStep through a normal application Job. The tests
+load the repository ``.env`` and therefore call the configured real LLM.
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+import frontmatter
+
+INTEGRATION_DIR = Path(__file__).resolve().parent
+REPOSITORY = INTEGRATION_DIR.parents[1]
+sys.path.insert(0, str(REPOSITORY))
+sys.path.insert(0, str(INTEGRATION_DIR))
+
+# pylint: disable=wrong-import-position
+from _workspace_fixture import workspace_env # noqa: E402
+
+from reme.utils import load_env # noqa: E402
+
+AUTO_TAG_JOB = {
+ "integration_auto_tag": {
+ "backend": "base",
+ "enable_serve": False,
+ "steps": [{"backend": "auto_tag_step"}],
+ },
+}
+
+AUTO_FIN_REPORT = """\
+---
+name: auto_fin
+description: 宁德时代海外电池业务与产能进展的盘后研究
+kind: auto-fin-brief
+---
+
+# 宁德时代：欧洲电池业务进入产能兑现期
+
+> 本文围绕宁德时代这一家公司，复盘其欧洲电池工厂的量产进展与客户交付节奏。
+
+## 核心变化
+
+宁德时代确认匈牙利工厂首条电芯产线开始试生产。管理层称，后续爬坡速度仍取决于良率、当地供应链和
+客户认证。该进展可能缩短欧洲客户的交付半径，但资本开支和产能利用率仍是主要风险。
+
+## 观察框架
+
+后续应继续跟踪宁德时代的海外产能利用率、单位成本与订单兑现情况。本文只提供新闻研究和回顾线索，
+不提供收益、目标价或买卖建议。
+"""
+
+DAILY_PAPER_NOTES = {
+ "daily/2026-09-10/openai-agent-eval.md": """\
+---
+name: openai-agent-eval
+description: OpenAI 智能体可靠性评测论文解读
+kind: daily-paper-analysis
+arxiv_id: "2609.10001"
+---
+
+# OpenAI 智能体可靠性评测
+
+这篇论文以 OpenAI 为唯一机构研究对象，分析其智能体在长任务中的失败恢复机制。实验比较了重试预算、
+工具错误和上下文压缩对完成率的影响，并讨论 OpenAI 对可靠性评测的设计选择。
+""",
+ "daily/2026-09-10/anthropic-context.md": """\
+---
+name: anthropic-context
+description: Anthropic 长上下文研究论文解读
+kind: daily-paper-analysis
+arxiv_id: "2609.10002"
+---
+
+# Anthropic 长上下文研究
+
+论文只研究 Anthropic 的长上下文模型。作者测试信息位于不同位置时的召回差异，并分析 Anthropic 模型的
+注意力退化现象；上下文压缩只是实验方法，不是本文要标记的现实实体。
+""",
+ "daily/2026-09-10/nvidia-blackwell.md": """\
+---
+name: nvidia-blackwell
+description: NVIDIA Blackwell 训练系统论文解读
+kind: daily-paper-analysis
+arxiv_id: "2609.10003"
+---
+
+# NVIDIA Blackwell 训练系统
+
+本文的机构研究对象是 NVIDIA。论文评估 Blackwell 集群的大模型训练吞吐、故障恢复和互连扩展效率，
+并给出 NVIDIA 在超大规模训练系统上的工程取舍。
+""",
+}
+
+DAILY_PAPER_DIGEST = """\
+---
+name: 每日论文简报-2026-09-10
+description: OpenAI、Anthropic 与 NVIDIA 三项研究的每日论文简报
+kind: daily-paper-brief
+---
+
+# 每日论文简报：智能体、长上下文与训练系统
+
+今天的三篇论文分别围绕三个相互独立的机构实体展开：OpenAI 的智能体可靠性评测、Anthropic 的长上下文
+研究，以及 NVIDIA 的 Blackwell 训练系统。这三家机构都是本期简报的并列核心，而非顺带提及。
+
+## 来源
+
+- [[daily/2026-09-10/openai-agent-eval.md]]
+- [[daily/2026-09-10/anthropic-context.md]]
+- [[daily/2026-09-10/nvidia-blackwell.md]]
+"""
+
+GENERIC_TAGS = {
+ "ai",
+ "人工智能",
+ "金融",
+ "股票",
+ "论文",
+ "研究",
+ "智能体",
+ "长上下文",
+ "训练系统",
+ "电池",
+ "半导体",
+}
+
+
+def _write(workspace: Path, relative: str, content: str) -> Path:
+ target = workspace / relative
+ target.parent.mkdir(parents=True, exist_ok=True)
+ target.write_text(content, encoding="utf-8")
+ return target
+
+
+def _post(path: Path) -> frontmatter.Post:
+ return frontmatter.loads(path.read_text(encoding="utf-8"))
+
+
+def _tags(path: Path) -> list[str]:
+ value = _post(path).metadata.get("memory_tags")
+ assert isinstance(value, list), f"memory_tags was not written as a list: {value!r}"
+ assert all(isinstance(item, str) and item.strip() for item in value)
+ assert len(value) <= 3
+ assert not ({item.casefold() for item in value} & {item.casefold() for item in GENERIC_TAGS})
+ return value
+
+
+def _assert_tag(tags: list[str], expected: str) -> None:
+ assert expected.casefold() in {tag.casefold() for tag in tags}, f"expected entity {expected!r}, got {tags!r}"
+
+
+def _assert_any_tag(tags: list[str], expected: set[str]) -> None:
+ actual = {tag.casefold() for tag in tags}
+ accepted = {tag.casefold() for tag in expected}
+ assert actual & accepted, f"expected one of {sorted(expected)!r}, got {tags!r}"
+
+
+async def _run_tag_job(env, changes: list[dict[str, str]]):
+ app = await env.make_app(jobs=AUTO_TAG_JOB)
+ response = await app.run_job("integration_auto_tag", changes=changes)
+ assert response.success is True, f"auto-tag failed: {response.answer!r}; metadata={response.metadata!r}"
+ auto_tag = response.metadata["auto_tag"]
+ assert auto_tag["processed"] == len(changes)
+ assert auto_tag["succeeded"] == len(changes)
+ assert auto_tag["failed"] == 0
+ assert auto_tag["ignored"] == []
+ return app, response
+
+
+def test_auto_tag_auto_fin_report_uses_company_entity():
+ """An Auto Fin report should be tagged with its company, not broad finance topics."""
+
+ async def run():
+ load_env(REPOSITORY / ".env")
+ with workspace_env(load_env_file=False) as env:
+ relative = "daily/2026-09-10/auto_fin.md"
+ path = _write(env.workspace_dir, relative, AUTO_FIN_REPORT)
+ before = _post(path)
+ try:
+ _app, _response = await _run_tag_job(env, [{"change": "added", "path": relative}])
+ tags = _tags(path)
+ _assert_any_tag(tags, {"宁德时代", "CATL"})
+ assert len(tags) == 1, f"single-entity report received extra tags: {tags!r}"
+ after = _post(path)
+ assert after.content == before.content
+ assert {key: value for key, value in after.metadata.items() if key != "memory_tags"} == before.metadata
+ finally:
+ await env.close_all()
+
+ asyncio.run(run())
+
+
+def test_auto_tag_daily_paper_batch_tags_analyses_and_digest():
+ """The three analyses get one entity each and the digest gets all three."""
+
+ async def run():
+ load_env(REPOSITORY / ".env")
+ with workspace_env(load_env_file=False) as env:
+ paths = {
+ relative: _write(env.workspace_dir, relative, content)
+ for relative, content in DAILY_PAPER_NOTES.items()
+ }
+ digest_rel = "daily/2026-09-10/daily-paper-brief.md"
+ paths[digest_rel] = _write(env.workspace_dir, digest_rel, DAILY_PAPER_DIGEST)
+ before = {relative: _post(path) for relative, path in paths.items()}
+ changes = [{"change": "added", "path": relative} for relative in paths]
+ try:
+ _app, response = await _run_tag_job(env, changes)
+ expected = {
+ "daily/2026-09-10/openai-agent-eval.md": "OpenAI",
+ "daily/2026-09-10/anthropic-context.md": "Anthropic",
+ "daily/2026-09-10/nvidia-blackwell.md": "NVIDIA",
+ }
+ for relative, entity in expected.items():
+ tags = _tags(paths[relative])
+ assert len(tags) == 1, f"single-entity analysis received extra tags: {relative} -> {tags!r}"
+ _assert_tag(tags, entity)
+
+ digest_tags = _tags(paths[digest_rel])
+ assert {tag.casefold() for tag in digest_tags} == {
+ "openai",
+ "anthropic",
+ "nvidia",
+ }
+ for relative, path in paths.items():
+ after = _post(path)
+ assert after.content == before[relative].content
+ assert {key: value for key, value in after.metadata.items() if key != "memory_tags"} == before[
+ relative
+ ].metadata
+ auto_tag = response.metadata["auto_tag"]
+ assert [item["path"] for item in auto_tag["results"]] == list(paths)
+ finally:
+ await env.close_all()
+
+ asyncio.run(run())
+
+
+def test_auto_tag_modified_note_reuses_existing_canonical_tag():
+ """A modified note should reuse an existing workspace spelling for the same entity."""
+
+ async def run():
+ load_env(REPOSITORY / ".env")
+ with workspace_env(load_env_file=False) as env:
+ _write(
+ env.workspace_dir,
+ "daily/2026-09-09/openai-history.md",
+ "---\nname: openai-history\nmemory_tags: [OpenAI]\n---\n# OpenAI 历史记录\n",
+ )
+ relative = "daily/2026-09-10/openai-update.md"
+ target = _write(
+ env.workspace_dir,
+ relative,
+ """\
+---
+name: openai-update
+description: OpenAI, Inc. 产品更新记录
+memory_tags: [大模型]
+status: reviewed
+---
+
+# OpenAI, Inc. 产品更新
+
+这份记忆只围绕 OpenAI 公司，记录其产品发布节奏。文中的“大模型”是技术类别，不是现实实体标签。
+""",
+ )
+ body_before = _post(target).content
+ try:
+ _app, response = await _run_tag_job(env, [{"change": "modified", "path": relative}])
+ tags = _tags(target)
+ assert [tag.casefold() for tag in tags] == ["openai"]
+ post = _post(target)
+ assert post.content == body_before
+ assert post.metadata["status"] == "reviewed"
+ assert response.metadata["auto_tag"]["results"][0]["change"] == "modified"
+ finally:
+ await env.close_all()
+
+ asyncio.run(run())
+
+
+if __name__ == "__main__":
+ test_auto_tag_auto_fin_report_uses_company_entity()
+ test_auto_tag_daily_paper_batch_tags_analyses_and_digest()
+ test_auto_tag_modified_note_reuses_existing_canonical_tag()
diff --git a/tests/unit/test_auto_dream.py b/tests/unit/test_auto_dream.py
index e87b82b8..b31ea9e0 100644
--- a/tests/unit/test_auto_dream.py
+++ b/tests/unit/test_auto_dream.py
@@ -3,22 +3,30 @@
# pylint: disable=protected-access
import asyncio
+import json
import tempfile
from pathlib import Path
-from unittest.mock import patch
+from unittest.mock import AsyncMock, patch
+import frontmatter
+import pytest
import yaml
from reme.components.application_context import ApplicationContext
from reme.components.agent_wrapper import BaseAgentWrapper
from reme.components.file_catalog import BaseFileCatalog
from reme.components.file_store import BaseFileStore
+from reme.components.job import BaseJob
from reme.components.runtime_context import RuntimeContext
+from reme.components.tag_index import LocalTagIndex
+from reme.config import resolve_app_config
from reme.schema import DreamState, FileNode
+from reme.steps.evolve.auto_tag import AutoTagStep
from reme.steps.evolve.dream.extract import DreamExtractStep
from reme.steps.evolve.dream.finish import DreamFinishStep
from reme.steps.evolve.dream.integrate import DreamIntegrateStep, _snapshot_digest
from reme.steps.evolve.dream.utils import parse_structured_reply, recent_dates, scan_day_files
+from reme.steps.file_io.frontmatter_update import FrontmatterUpdateStep
def _touch(path: Path, text: str = "x") -> Path:
@@ -110,6 +118,8 @@ class _SequenceAgent(BaseAgentWrapper):
async def reply(self, _message, **_kwargs):
self.calls += 1
outcome = self.outcomes.pop(0)
+ if callable(outcome):
+ outcome = outcome()
if isinstance(outcome, Exception):
raise outcome
return outcome
@@ -497,6 +507,175 @@ def test_integrate_uses_one_application_wide_lock(tmp_path):
assert first._integration_lock() is second._integration_lock() # pylint: disable=protected-access
+@pytest.mark.asyncio
+async def test_integrate_emits_actual_changes_once_across_units(tmp_path, monkeypatch):
+ """Creation followed by updates stays added; receipt-only updates emit nothing."""
+ created = "digest/wiki/created.md"
+ updated = "digest/procedure/updated.md"
+ untouched = "digest/personal/untouched.md"
+ _touch(tmp_path / updated, "old")
+ _touch(tmp_path / untouched, "unchanged")
+
+ def create():
+ _touch(tmp_path / created, "new")
+ return {"result": json.dumps({"action": "CREATE", "target_path": created})}
+
+ def update():
+ _touch(tmp_path / created, "new with more evidence")
+ _touch(tmp_path / updated, "updated existing memory")
+ return {"result": json.dumps({"action": "REFINE", "target_path": created})}
+
+ agent = _SequenceAgent(
+ create,
+ update,
+ {"result": json.dumps({"action": "CORROBORATE", "target_path": untouched})},
+ )
+ state = DreamState(
+ units=[{"name": str(i), "bucket": "wiki", "paths": ["daily/source.md"]} for i in range(3)],
+ )
+ context = RuntimeContext(dream=state.model_dump(), file_store=_FileStore(tmp_path))
+ step = DreamIntegrateStep(app_context=ApplicationContext(workspace_dir=str(tmp_path)), agent_wrapper=agent)
+ monkeypatch.setattr("reme.steps.evolve.dream.integrate.llm_available", lambda _step: True)
+
+ await step(context)
+
+ assert context.response.success is True
+ assert context["changes"] == [
+ {"change": "modified", "path": updated},
+ {"change": "added", "path": created},
+ ]
+ assert untouched in context.response.metadata["dream"]["nodes_updated"]
+ assert untouched not in context.response.metadata["dream"]["modified_paths"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("agent_error", [False, True])
+async def test_integrate_keeps_added_changes_across_retry_recovery(tmp_path, monkeypatch, agent_error):
+ """Files from both attempts remain eligible for tagging after receipt recovery."""
+ first, second = "digest/wiki/first.md", "digest/wiki/second.md"
+
+ def attempt_one():
+ _touch(tmp_path / first, "first")
+ _touch(tmp_path / second, "second")
+ return RuntimeError("agent failed") if agent_error else {"result": "{}"}
+
+ def attempt_two():
+ _touch(tmp_path / first, "first with more evidence")
+ return RuntimeError("agent failed") if agent_error else {"result": "{}"}
+
+ agent = _SequenceAgent(attempt_one, attempt_two)
+ state = DreamState(units=[{"name": "unit", "bucket": "wiki", "paths": ["daily/source.md"]}])
+ context = RuntimeContext(dream=state.model_dump(), file_store=_FileStore(tmp_path))
+ step = DreamIntegrateStep(app_context=ApplicationContext(workspace_dir=str(tmp_path)), agent_wrapper=agent)
+ monkeypatch.setattr("reme.steps.evolve.dream.integrate.llm_available", lambda _step: True)
+
+ await step(context)
+
+ assert agent.calls == 2
+ assert context.response.success is True
+ assert context.response.metadata["dream"]["warnings"]
+ assert context["changes"] == [{"change": "added", "path": path} for path in (first, second)]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("with_units", [False, True])
+async def test_integrate_clears_changes_when_skipping_or_missing_llm(tmp_path, monkeypatch, with_units):
+ """Early returns cannot pass caller-supplied paths into AutoTag."""
+ app_context = ApplicationContext(workspace_dir=str(tmp_path))
+ state = DreamState(units=[{"name": "unit", "paths": ["daily/source.md"]}] if with_units else [])
+ agent = _ReplyAgent()
+ context = RuntimeContext(dream=state.model_dump(), changes=[{"change": "added", "path": "daily/source.md"}])
+ monkeypatch.setattr("reme.steps.evolve.dream.integrate.llm_available", lambda _step: False)
+
+ await DreamIntegrateStep(app_context=app_context, agent_wrapper=agent)(context)
+ response = await AutoTagStep(app_context=app_context, agent_wrapper=agent)(context)
+
+ assert context["changes"] == []
+ assert response.success is not with_units
+ assert response.metadata["auto_tag"]["processed"] == 0
+ assert agent.calls == 0
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("job_name", ["auto_dream", "dream_cron"])
+@pytest.mark.parametrize("tag_fails", [False, True])
+@pytest.mark.parametrize("integrate_fails", [False, True])
+async def test_dream_jobs_tag_outputs_and_preserve_checkpoint_results(
+ tmp_path,
+ monkeypatch,
+ job_name,
+ tag_fails,
+ integrate_fails,
+):
+ """Both configured pipelines tag durable outputs without changing dream success."""
+ app_context = ApplicationContext(workspace_dir=str(tmp_path))
+ catalog, store = _Catalog(), _FileStore(tmp_path)
+ store.tag_index = LocalTagIndex()
+ source = "daily/2026-09-11/source.md"
+ targets = ["digest/wiki/first.md", "digest/wiki/second.md"]
+ _touch(tmp_path / source, "Source about ReMe")
+ unit = {"name": "unit", "bucket": "wiki", "summary": "ReMe memory", "paths": [source]}
+
+ async def reply(_message, **kwargs):
+ if kwargs["job_tools"] == ["read"]:
+ return {"result": json.dumps({"units": [unit]})}
+ if "list_tags" in kwargs["job_tools"]:
+ injected = kwargs["injected_job_kwargs"]
+ path = injected["_allowed_paths"][0]
+ if tag_fails and path == targets[0]:
+ raise RuntimeError("tagging unavailable")
+ update_context = RuntimeContext(
+ path=path,
+ metadata={"memory_tags": ["ReMe"]},
+ **injected,
+ )
+ await FrontmatterUpdateStep(file_store=store)(update_context)
+ assert update_context.response.success
+ return {"result": "Tagged ReMe"}
+ for path in targets:
+ previous = (tmp_path / path).read_text(encoding="utf-8") if (tmp_path / path).exists() else ""
+ _touch(tmp_path / path, previous + "ReMe evidence\n")
+ if integrate_fails:
+ raise RuntimeError("integration unavailable")
+ return {"result": json.dumps({"action": "CREATE", "target_path": targets[0]})}
+
+ agent = _ReplyAgent()
+ monkeypatch.setattr(agent, "reply", AsyncMock(side_effect=reply))
+ monkeypatch.setattr("reme.steps.evolve.dream.extract.llm_available", lambda _step: True)
+ monkeypatch.setattr("reme.steps.evolve.dream.integrate.llm_available", lambda _step: True)
+ config = resolve_app_config(config="default", log_config=False)["jobs"][job_name]
+ # Execute the cron's configured steps once without starting a scheduler.
+ job = BaseJob(name=job_name, steps=config["steps"], app_context=app_context)
+ await job.start()
+ try:
+ response = await job(
+ date="2026-09-11",
+ scan_days=1,
+ agent_wrapper=agent,
+ file_store=store,
+ file_catalog=catalog,
+ )
+ finally:
+ await job.close()
+
+ assert response.success is not integrate_fails
+ assert response.answer.startswith("AutoDream completed")
+ assert response.metadata["modified"] is True
+ dream, tagging = response.metadata["dream"], response.metadata["auto_tag"]
+ assert (source in dream["checkpoint_paths"]) is not integrate_fails
+ assert (source in dream["failed_paths"]) is integrate_fails
+ assert tagging["processed"] == 2
+ assert tagging["failed"] == int(tag_fails)
+ assert tagging["succeeded"] == 2 - int(tag_fails)
+ assert [{"change": item["change"], "path": item["path"]} for item in tagging["results"]] == [
+ {"change": "added", "path": path} for path in targets
+ ]
+ for path in targets:
+ post = frontmatter.loads((tmp_path / path).read_text(encoding="utf-8"))
+ assert post.metadata.get("memory_tags") == (None if tag_fails and path == targets[0] else ["ReMe"])
+ assert (tmp_path / source).read_text(encoding="utf-8") == "Source about ReMe"
+
+
def test_extract_without_llm_marks_changed_paths_failed(tmp_path):
"""A missing LLM must not let finish checkpoint unprocessed source files."""
diff --git a/tests/unit/test_auto_memory_cc.py b/tests/unit/test_auto_memory_cc.py
index 46deeece..9ae05c1c 100644
--- a/tests/unit/test_auto_memory_cc.py
+++ b/tests/unit/test_auto_memory_cc.py
@@ -3,9 +3,17 @@
# pylint: disable=protected-access
from types import SimpleNamespace
+from unittest.mock import AsyncMock
+import frontmatter
import pytest
+from reme.components.agent_wrapper import BaseAgentWrapper
+from reme.components.application_context import ApplicationContext
+from reme.components.file_store import LocalFileStore
+from reme.components.job import BaseJob
+from reme.config import resolve_app_config
+from reme.enumeration import ComponentEnum
from reme.steps.evolve.auto_memory_cc import AutoMemoryCCStep
@@ -27,3 +35,108 @@ async def test_reme_cc_store_preserves_existing_session_layout(tmp_path):
assert increment == [{"uuid": "new"}]
assert step._session_link(session_id) == f"[[session/claude_code/{session_id}.jsonl]]"
assert not (tmp_path / "session" / "claude_code" / "claude_code").exists()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("tag_fails", [False, True])
+async def test_cc_job_tags_created_updated_and_renamed_notes_only(tmp_path, monkeypatch, tag_fails):
+ """The configured CC job inherits changes, skips no-ops, and preserves its main result."""
+ monkeypatch.chdir(tmp_path)
+ app_context = ApplicationContext(workspace_dir=str(tmp_path))
+ store = LocalFileStore(name="default", embedding_store="", tag_index="default")
+ app_context.components[ComponentEnum.FILE_STORE] = {"default": store}
+ configs = resolve_app_config(config="default", log_config=False)["jobs"]
+ session_id, day = "session-1", "2026-09-11"
+ source = f"[[session/claude_code/{session_id}.jsonl]]"
+ entries = []
+ monkeypatch.setattr(AutoMemoryCCStep, "_load_cc_session", AsyncMock(return_value=entries))
+ mode = "create"
+ tag_paths = []
+ memory_calls = []
+
+ async def reply(_message, **kwargs):
+ if "list_tags" in kwargs["job_tools"]:
+ injected = kwargs["injected_job_kwargs"]
+ path = injected["_allowed_paths"][0]
+ tag_paths.append(path)
+ if tag_fails:
+ raise RuntimeError("tagging unavailable")
+ result = await app_context.jobs["frontmatter_update"](
+ path=path,
+ metadata={"memory_tags": ["ReMe"]},
+ **injected,
+ )
+ assert result.success
+ return {"result": "Tagged ReMe"}
+ memory_calls.append(mode)
+ if mode == "create":
+ target = tmp_path / f"daily/{day}/note.md"
+ target.parent.mkdir(parents=True)
+ post = frontmatter.Post("ReMe memory", name="note", session_id=session_id, source_conversation=source)
+ elif mode == "unchanged":
+ return {"result": "No new facts"}
+ else:
+ target = tmp_path / kwargs["injected_job_kwargs"]["_allowed_paths"][0]
+ post = frontmatter.loads(target.read_text(encoding="utf-8"))
+ post.content += "\nMore ReMe evidence"
+ if mode == "rename":
+ post.metadata["name"] = "renamed"
+ target.write_text(frontmatter.dumps(post), encoding="utf-8")
+ return {"result": "Recorded memory"}
+
+ agent = AsyncMock(spec=BaseAgentWrapper)
+ agent.reply.side_effect = reply
+ await store.start()
+ try:
+ for name in ("daily_list", "move", "frontmatter_update", "auto_memory_cc"):
+ job = BaseJob(
+ name=name,
+ steps=configs[name]["steps"],
+ app_context=app_context,
+ agent_wrapper=agent,
+ date=day,
+ )
+ app_context.jobs[name] = job
+ await job.start()
+ job = app_context.jobs["auto_memory_cc"]
+ for index, mode in enumerate(("create", "unchanged", "update", "rename")):
+ entries.append(
+ {"uuid": str(index), "type": "user", "message": {"role": "user", "content": f"ReMe fact {index}"}},
+ )
+ before_tags = len(tag_paths)
+ response = await job(session_id=session_id)
+ assert response.success is True
+ assert response.metadata["source_conversation"] == source
+ if mode == "unchanged":
+ assert response.answer == "No new facts"
+ assert response.metadata["modified"] is False
+ assert response.metadata["auto_tag"]["processed"] == 0
+ assert len(tag_paths) == before_tags
+ else:
+ path = f"daily/{day}/{'renamed' if mode == 'rename' else 'note'}.md"
+ assert response.answer == "Recorded memory"
+ assert response.metadata["path"] == path
+ assert response.metadata["modified"] is True
+ assert response.metadata["created"] is (mode == "create")
+ tagging = response.metadata["auto_tag"]
+ assert tagging["processed"] == 1
+ assert tagging["failed"] == int(tag_fails)
+ assert tagging["results"][0]["change"] == ("added" if mode == "create" else "modified")
+ assert tag_paths[-1] == path
+ post = frontmatter.loads((tmp_path / path).read_text(encoding="utf-8"))
+ assert post.metadata.get("memory_tags") == (None if tag_fails else ["ReMe"])
+ assert post.metadata["source_conversation"] == source
+
+ # Repeating a Stop with the same UUIDs must run neither agent again.
+ before_calls = (len(memory_calls), len(tag_paths))
+ repeated = await job(session_id=session_id)
+ assert repeated.success is True
+ assert repeated.answer == "Skipped: no messages"
+ assert repeated.metadata["auto_tag"]["processed"] == 0
+ assert (len(memory_calls), len(tag_paths)) == before_calls
+ assert not (tmp_path / f"daily/{day}/note.md").exists()
+ assert not (tmp_path / "session/dialog").exists()
+ finally:
+ for job in reversed(list(app_context.jobs.values())):
+ await job.close()
+ await store.close()
diff --git a/tests/unit/test_auto_tag.py b/tests/unit/test_auto_tag.py
new file mode 100644
index 00000000..3336a381
--- /dev/null
+++ b/tests/unit/test_auto_tag.py
@@ -0,0 +1,194 @@
+"""Focused tests for the standalone automatic tagging Step."""
+
+# pylint: disable=missing-function-docstring
+
+from pathlib import Path
+
+import frontmatter
+import pytest
+
+from reme.components.agent_wrapper import BaseAgentWrapper
+from reme.components.file_store import LocalFileStore
+from reme.components.runtime_context import RuntimeContext
+from reme.components.tag_index import LocalTagIndex
+from reme.schema import Response
+from reme.steps.evolve.auto_tag import AutoTagStep
+
+
+class _TaggingWrapper(BaseAgentWrapper):
+ def __init__(
+ self,
+ workspace: Path,
+ *,
+ fail_name: str = "",
+ tag_key: str = "memory_tags",
+ tags: list[object] | None = None,
+ ) -> None:
+ super().__init__(name="tagger")
+ self.workspace = workspace
+ self.fail_name = fail_name
+ self.tag_key = tag_key
+ self.tags = ["宁德时代", "黄金"] if tags is None else tags
+ self.calls: list[tuple[str, dict]] = []
+
+ async def reply(self, inputs, **kwargs) -> dict:
+ text = str(inputs)
+ self.calls.append((text, kwargs))
+ path = kwargs["injected_job_kwargs"]["_allowed_paths"][0]
+ if Path(path).name == self.fail_name:
+ raise RuntimeError("tagging failed")
+ target = self.workspace / path
+ post = frontmatter.loads(target.read_text(encoding="utf-8"))
+ post.metadata[self.tag_key] = self.tags
+ target.write_text(frontmatter.dumps(post), encoding="utf-8")
+ return {"result": f"tagged {path}", "last_message": {}}
+
+
+def _write_note(path: Path) -> None:
+ path.parent.mkdir(parents=True, exist_ok=True)
+ path.write_text("---\nname: note\ndescription: useful note\n---\nbody\n", encoding="utf-8")
+
+
+def _file_store(*, name: str = "default", **tag_index_kwargs) -> LocalFileStore:
+ store = LocalFileStore(name=name, embedding_store="", tag_index="")
+ store.tag_index = LocalTagIndex(**tag_index_kwargs)
+ return store
+
+
+@pytest.mark.asyncio
+async def test_auto_tag_handles_noop_invalid_changes_and_no_tag_index(tmp_path, monkeypatch):
+ monkeypatch.chdir(tmp_path)
+ wrapper = _TaggingWrapper(tmp_path)
+
+ context = RuntimeContext(changes=[])
+ context.response.answer = "Skipped: no messages"
+ response = await AutoTagStep(agent_wrapper=wrapper)(context)
+ assert response.success is True
+ assert response.answer == "Skipped: no messages"
+ assert response.metadata["auto_tag"]["processed"] == 0
+
+ response = await AutoTagStep(agent_wrapper=wrapper)(
+ RuntimeContext(changes="daily/note.md"),
+ )
+ assert response.success is False
+ assert response.answer == "AutoTagStep requires changes: list[dict]"
+
+ note = tmp_path / "daily/2026-09-09/note.md"
+ _write_note(note)
+ change = RuntimeContext(changes=[{"change": "added", "path": "daily/2026-09-09/note.md"}])
+ response = await AutoTagStep(agent_wrapper=wrapper, file_store=LocalFileStore(embedding_store="", tag_index=""))(
+ change,
+ )
+
+ assert response.success is True
+ assert response.answer == "Tagged 0 file(s); 1 failed"
+ assert not wrapper.calls
+ assert "memory_tags" not in frontmatter.loads(note.read_text(encoding="utf-8")).metadata
+ assert response.metadata["auto_tag"]["results"][0]["error"] == "tag index is not configured"
+
+
+@pytest.mark.asyncio
+async def test_auto_tag_filters_paths_and_continues_after_one_file_fails(tmp_path, monkeypatch):
+ monkeypatch.chdir(tmp_path)
+ first = tmp_path / "daily/2026-09-09/first.md"
+ failed = tmp_path / "daily/2026-09-09/failed.md"
+ _write_note(first)
+ _write_note(failed)
+ (tmp_path / "daily/2026-09-09/notes").mkdir()
+ (tmp_path / "daily/2026-09-09/plain.txt").write_text("text", encoding="utf-8")
+
+ wrapper = _TaggingWrapper(tmp_path, fail_name="failed.md")
+ step = AutoTagStep(agent_wrapper=wrapper, file_store=_file_store())
+ context = RuntimeContext(
+ changes=[
+ {"change": "modified", "path": "daily/2026-09-09/failed.md"},
+ {"change": "added", "path": "daily/2026-09-09/notes"},
+ {"change": "added", "path": "daily/2026-09-09/plain.txt"},
+ {"change": "modified", "path": "daily/2026-09-09/first.md"},
+ {"change": "added", "path": "daily/2026-09-09/first.md"},
+ {"change": "deleted", "path": "daily/2026-09-09/deleted.md"},
+ ],
+ )
+ context.response.answer = "Generated report"
+
+ response = await step(context)
+
+ assert response.success is True
+ assert response.answer == "Generated report"
+ assert [call[1]["injected_job_kwargs"] for call in wrapper.calls] == [
+ {
+ "file_store": "default",
+ "_allowed_paths": ["daily/2026-09-09/failed.md"],
+ "_allowed_frontmatter_keys": ["memory_tags"],
+ },
+ {
+ "file_store": "default",
+ "_allowed_paths": ["daily/2026-09-09/first.md"],
+ "_allowed_frontmatter_keys": ["memory_tags"],
+ },
+ ]
+ assert all(
+ call[1]["job_tools"] == ["read", "list_tags", "frontmatter_read", "frontmatter_update"]
+ for call in wrapper.calls
+ )
+ assert frontmatter.loads(first.read_text(encoding="utf-8")).metadata["memory_tags"] == ["宁德时代", "黄金"]
+ assert "memory_tags" not in frontmatter.loads(failed.read_text(encoding="utf-8")).metadata
+ assert response.metadata["auto_tag"]["processed"] == 2
+ assert response.metadata["auto_tag"]["succeeded"] == 1
+ assert response.metadata["auto_tag"]["failed"] == 1
+ assert response.metadata["auto_tag"]["ignored"] == [
+ {"path": "daily/2026-09-09/notes", "reason": "not a file"},
+ {"path": "daily/2026-09-09/plain.txt", "reason": "not a Markdown file"},
+ {"path": "daily/2026-09-09/deleted.md", "reason": "unsupported change: deleted"},
+ ]
+ assert response.metadata["auto_tag"]["results"] == [
+ {
+ "change": "modified",
+ "path": "daily/2026-09-09/failed.md",
+ "success": False,
+ "error": "tagging failed",
+ },
+ {
+ "change": "added",
+ "path": "daily/2026-09-09/first.md",
+ "success": True,
+ "summary": "tagged daily/2026-09-09/first.md",
+ },
+ ]
+
+
+@pytest.mark.asyncio
+async def test_auto_tag_uses_configured_key_and_normalizes_agent_output(tmp_path, monkeypatch):
+ monkeypatch.chdir(tmp_path)
+ note = tmp_path / "memory/note.md"
+ _write_note(note)
+ wrapper = _TaggingWrapper(
+ tmp_path,
+ tag_key="keywords",
+ tags=["OpenAI", "openai", "Sam Altman", "++", 100, "宁德时代", "黄金"],
+ )
+ store = _file_store(name="archive", tag_key="keywords", max_tags_per_file=2, max_tag_length=8)
+ step = AutoTagStep(agent_wrapper=wrapper, file_store=store)
+
+ async def update_frontmatter(name, /, **kwargs):
+ assert name == "frontmatter_update"
+ assert kwargs["_allowed_frontmatter_keys"] == ["keywords"]
+ assert kwargs["file_store"] == "archive"
+ post = frontmatter.loads(note.read_text(encoding="utf-8"))
+ post.metadata.update(kwargs["metadata"])
+ note.write_text(frontmatter.dumps(post), encoding="utf-8")
+ return Response(answer="updated")
+
+ monkeypatch.setattr(step, "run_job", update_frontmatter)
+
+ context = RuntimeContext(changes=[{"change": "modified", "path": "memory/note.md"}])
+ context.response.answer = "Created memory/note.md"
+ response = await step(context)
+
+ assert response.success is True
+ assert response.answer == "Created memory/note.md"
+ assert frontmatter.loads(note.read_text(encoding="utf-8")).metadata["keywords"] == [
+ "OpenAI",
+ "宁德时代",
+ ]
+ assert wrapper.calls[0][1]["injected_job_kwargs"]["file_store"] == "archive"
diff --git a/tests/unit/test_background_steps.py b/tests/unit/test_background_steps.py
index 6de14302..87867a5b 100644
--- a/tests/unit/test_background_steps.py
+++ b/tests/unit/test_background_steps.py
@@ -837,6 +837,7 @@ def test_update_catalog_yields_to_event_loop_while_building_batch():
class _CountingEmbeddingStore:
dimensions = 2
max_batch_size = 10
+ is_healthy = True
def __init__(self):
self.calls = 0
@@ -1344,19 +1345,24 @@ def test_auto_resource_handles_file_removed_before_stat():
_install_file_jobs(app_ctx, fs)
try:
source = write_file(cwd / "resource" / "2026-01-01" / "vanishing.txt", "content")
+ original_is_file = Path.is_file
original_stat = Path.stat
- source_stat_calls = 0
+
+ def existing_is_file(path, *args, **kwargs):
+ if path == source:
+ return True
+ return original_is_file(path, *args, **kwargs)
def disappearing_stat(path, *args, **kwargs):
- nonlocal source_stat_calls
if path == source:
- source_stat_calls += 1
- if source_stat_calls > 1:
- raise FileNotFoundError("file disappeared")
+ raise FileNotFoundError("file disappeared")
return original_stat(path, *args, **kwargs)
step = AutoTextResourceStep(app_context=app_ctx, file_store=fs)
- with patch.object(Path, "stat", disappearing_stat):
+ with (
+ patch.object(Path, "is_file", existing_is_file),
+ patch.object(Path, "stat", disappearing_stat),
+ ):
resp = await step(
RuntimeContext(changes=[{"change": "added", "path": str(source)}]),
)
@@ -1997,7 +2003,7 @@ def test_auto_memory_reports_modified_for_create_and_false_for_skip():
with tempfile.TemporaryDirectory() as tmpdir, temp_chdir(tmpdir):
cwd = Path.cwd()
app_ctx = _make_app_context(cwd)
- fs = LocalFileStore(name="test_store", embedding_store="")
+ fs = LocalFileStore(name="test_store", embedding_store="", tag_index="")
wrapper = _FakeAgentWrapper()
await fs.start()
_install_file_jobs(app_ctx, fs)
@@ -2012,28 +2018,29 @@ def test_auto_memory_reports_modified_for_create_and_false_for_skip():
app_context=app_ctx,
file_store=fs,
agent_wrapper=wrapper,
- enable_tags=True,
)
- resp = await step(
- RuntimeContext(
- messages=[{"name": "user", "role": "user", "content": "remember project detail"}],
- session_id="s1",
- ),
+ context = RuntimeContext(
+ messages=[{"name": "user", "role": "user", "content": "remember project detail"}],
+ session_id="s1",
)
+ resp = await step(context)
resp = resp or step.context.response
assert resp.success is True
assert resp.metadata["created"] is True
assert resp.metadata["modified"] is True
- assert "tags: []" in (cwd / "daily" / today / "memory.md").read_text(encoding="utf-8")
+ assert context["changes"] == [{"change": "added", "path": f"daily/{today}/memory.md"}]
+ assert "tags:" not in (cwd / "daily" / today / "memory.md").read_text(encoding="utf-8")
wrapper.on_reply = None
- resp = await step(RuntimeContext(messages=[], session_id="s2"))
+ context = RuntimeContext(messages=[], session_id="s2")
+ resp = await step(context)
resp = resp or step.context.response
assert resp.success is True
assert resp.metadata["modified"] is False
assert resp.metadata["n_messages"] == 0
+ assert context["changes"] == []
finally:
await fs.close()
print("✓ test_auto_memory_reports_modified_for_create_and_false_for_skip passed")
@@ -2041,58 +2048,6 @@ def test_auto_memory_reports_modified_for_create_and_false_for_skip():
asyncio.run(run())
-def test_auto_memory_normalizes_tags_after_existing_note_update():
- """Existing notes receive a refreshed, normalized tags field capped at eight entries."""
-
- async def run():
- with tempfile.TemporaryDirectory() as tmpdir, temp_chdir(tmpdir):
- cwd = Path.cwd()
- app_ctx = _make_app_context(cwd)
- fs = LocalFileStore(name="test_store", embedding_store="")
- wrapper = _FakeAgentWrapper()
- await fs.start()
- _install_file_jobs(app_ctx, fs)
- try:
- today = datetime.datetime.now().strftime("%Y-%m-%d")
- note_path = cwd / "daily" / today / "memory.md"
- write_file(
- note_path,
- "---\nname: memory\nsession_id: s1\n"
- "source_conversation: '[[session/dialog/s1.jsonl]]'\n"
- "tags: [old]\n---\nold body\n",
- )
-
- wrapper.on_reply = lambda *_: write_file(
- note_path,
- "---\nname: memory\nsession_id: s1\n"
- "source_conversation: '[[session/dialog/s1.jsonl]]'\n"
- "tags: [GPT-5, C++, C#, .NET, 100, 'memory system', '++', ReMe, reme, tag7, tag8, tag9]\n"
- "---\nupdated body\n",
- )
-
- step = AutoMemoryStep(
- app_context=app_ctx,
- file_store=fs,
- agent_wrapper=wrapper,
- enable_tags=True,
- )
- resp = await step(
- RuntimeContext(
- messages=[{"name": "user", "role": "user", "content": "updated project detail"}],
- session_id="s1",
- ),
- )
- resp = resp or step.context.response
-
- assert resp.success is True
- metadata = step._frontmatter(f"daily/{today}/memory.md")
- assert metadata["tags"] == ["GPT-5", "C++", "C#", ".NET", "100", "ReMe", "tag7", "tag8"]
- finally:
- await fs.close()
-
- asyncio.run(run())
-
-
def test_auto_memory_uses_message_day_for_historical_create():
"""AutoMemoryStep creates historical daily notes from message timestamps."""
diff --git a/tests/unit/test_evolve_utils.py b/tests/unit/test_evolve_utils.py
index b8e3312c..85d5ab69 100644
--- a/tests/unit/test_evolve_utils.py
+++ b/tests/unit/test_evolve_utils.py
@@ -9,7 +9,7 @@ from agentscope.message import Msg
import pytest
from reme.steps.evolve._evolve import agent_reply_result_text, format_history
-from reme.steps.evolve.auto_memory import AutoMemoryStep, _normalize_tags, _sanitize_msg_for_save
+from reme.steps.evolve.auto_memory import AutoMemoryStep, _sanitize_msg_for_save
def test_agent_reply_result_text_uses_last_text_block():
@@ -75,32 +75,6 @@ def test_sanitize_msg_for_save_drops_tool_results_and_base64_data():
assert sanitized.content[1].name == "memory_search"
-def test_auto_memory_normalizes_frontmatter_tags():
- """Tags keep technical punctuation, reject phrases, de-duplicate, and stop at eight."""
- assert _normalize_tags(
- [
- "GPT-5",
- "C++",
- "C#",
- ".NET",
- "100",
- 100,
- "memory system",
- "++",
- "ReMe",
- "reme",
- "tag7",
- "tag8",
- "tag9",
- ],
- ) == ["GPT-5", "C++", "C#", ".NET", "100", "ReMe", "tag7", "tag8"]
- # pylint: disable=use-implicit-booleaness-not-comparison
- assert _normalize_tags(None) == []
- assert _normalize_tags("GPT-5") == []
- # pylint: enable=use-implicit-booleaness-not-comparison
- assert _normalize_tags(["x" * 65, True, {}, "valid"]) == ["valid"]
-
-
def test_auto_memory_accepts_message_timestamp_aliases():
"""AutoMemoryStep preserves historical message timestamps from common benchmark fields."""
top_level = AutoMemoryStep._to_msg(
diff --git a/tests/unit/test_faiss_index_maintenance.py b/tests/unit/test_faiss_index_maintenance.py
index 15960f18..ca2a490c 100644
--- a/tests/unit/test_faiss_index_maintenance.py
+++ b/tests/unit/test_faiss_index_maintenance.py
@@ -36,6 +36,7 @@ class FakeEmbeddingStore:
dimensions = 2
max_batch_size = 10
+ is_healthy = True
def _embed(self, text: str) -> np.ndarray:
if "beta" in text or "fresh" in text:
diff --git a/tests/unit/test_file_store_consistency.py b/tests/unit/test_file_store_consistency.py
index a2693ed7..b7750017 100644
--- a/tests/unit/test_file_store_consistency.py
+++ b/tests/unit/test_file_store_consistency.py
@@ -49,6 +49,7 @@ class FakeEmbeddingStore:
dimensions = 2
max_batch_size = 10
+ is_healthy = True
def _embed(self, text: str) -> np.ndarray:
if "beta" in text or "fresh" in text:
@@ -1519,6 +1520,42 @@ def test_search_filter_applies_to_vector_and_keyword_results(store_factory):
run(go())
+def test_empty_exact_path_filter_matches_nothing():
+ """An explicitly empty path domain must not widen into an unfiltered search."""
+ candidate = chunk("a", "daily/a.md", "fresh topic")
+
+ assert LocalFileStore._matches_search_filter(candidate, {"paths": []}) is False
+
+
+@pytest.mark.parametrize("store_factory", [_new_local_store, _new_zvec_store])
+def test_path_filter_uses_one_domain_for_vector_and_keyword(store_factory):
+ """Vector and BM25 branches apply the same ordinary path and metadata filters."""
+
+ async def go():
+ with tempfile.TemporaryDirectory() as tmp, temp_chdir(tmp):
+ store = store_factory(name="t_filtered_domain")
+ await store.start()
+ store.embedding_store = FakeEmbeddingStore()
+ _ensure_zvec_collection(store)
+ await store.upsert(
+ [
+ (node("daily/a.md"), [chunk("a", "daily/a.md", "fresh topic", kind="daily")]),
+ (node("daily/b.md"), [chunk("b", "daily/b.md", "fresh topic", kind="other")]),
+ (node("resource/c.md"), [chunk("c", "resource/c.md", "fresh topic", kind="daily")]),
+ ],
+ )
+
+ search_filter = {
+ "paths": ["daily/a.md", "daily/b.md"],
+ "metadata": {"kind": "daily"},
+ }
+ assert [item.id for item in await store.vector_search("fresh", 5, search_filter)] == ["a"]
+ assert [item.id for item in await store.keyword_search("fresh", 5, search_filter)] == ["a"]
+ await store.close()
+
+ run(go())
+
+
def test_faiss_rebuilds_stale_sidecar_and_updates_same_id_text():
"""FAISS sidecar rebuilds when persisted rows no longer match chunks."""
diff --git a/tests/unit/test_frontmatter_steps.py b/tests/unit/test_frontmatter_steps.py
index 1ea9a6ef..51a49f34 100644
--- a/tests/unit/test_frontmatter_steps.py
+++ b/tests/unit/test_frontmatter_steps.py
@@ -14,6 +14,7 @@ import os
import tempfile
from pathlib import Path
+import frontmatter
import pytest
from reme.components.file_store import LocalFileStore
@@ -89,6 +90,58 @@ async def test_update_no_suffix_autoappends_md():
await store.close()
+@pytest.mark.asyncio
+async def test_update_honors_injected_frontmatter_key_scope():
+ """Injected key scope rejects the entire update when any key is outside it."""
+ with tempfile.TemporaryDirectory() as tmp, temp_chdir(tmp):
+ note = _seed(Path(tmp), NOTE, BODY)
+ store = await _make_store()
+
+ before = note.read_bytes()
+ resp = await _run(
+ FrontmatterUpdateStep,
+ store,
+ path=NOTE,
+ metadata={"tags": ["new"], "name": "renamed"},
+ _allowed_frontmatter_keys=["tags"],
+ )
+ assert resp.success is False
+ assert resp.metadata["error"] == "frontmatter key(s) not allowed: 'name'"
+ assert note.read_bytes() == before
+
+ resp = await _run(
+ FrontmatterUpdateStep,
+ store,
+ path=NOTE,
+ metadata={"tags": ["new"]},
+ _allowed_frontmatter_keys=["tags"],
+ )
+ assert resp.success is True
+ assert frontmatter.loads(note.read_text(encoding="utf-8")).metadata == {"name": "n", "tags": ["new"]}
+ await store.close()
+
+
+@pytest.mark.asyncio
+async def test_update_empty_frontmatter_key_scope_denies_all_updates():
+ """An empty injected list is restrictive, unlike an omitted constraint."""
+ with tempfile.TemporaryDirectory() as tmp, temp_chdir(tmp):
+ note = _seed(Path(tmp), NOTE, BODY)
+ store = await _make_store()
+ before = note.read_bytes()
+
+ resp = await _run(
+ FrontmatterUpdateStep,
+ store,
+ path=NOTE,
+ metadata={"tags": ["new"]},
+ _allowed_frontmatter_keys=[],
+ )
+
+ assert resp.success is False
+ assert note.read_bytes() == before
+ await store.close()
+
+
@pytest.mark.asyncio
async def test_delete_no_suffix_autoappends_md():
"""frontmatter_delete on a suffix-less path resolves to the ``.md`` file."""
diff --git a/tests/unit/test_hermes_agent_integration.py b/tests/unit/test_hermes_agent_integration.py
new file mode 100644
index 00000000..6c0d37a5
--- /dev/null
+++ b/tests/unit/test_hermes_agent_integration.py
@@ -0,0 +1,569 @@
+"""Focused tests for the external Hermes memory-provider plugin."""
+
+# pylint: disable=missing-class-docstring,missing-function-docstring
+# pylint: disable=protected-access,wrong-import-position,unused-import
+
+from __future__ import annotations
+
+import sys
+import types
+import asyncio
+import importlib
+import threading
+import time
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import pytest
+
+_PLUGIN_PARENT = Path(__file__).resolve().parents[2] / "integrations"
+if str(_PLUGIN_PARENT) not in sys.path:
+ sys.path.insert(0, str(_PLUGIN_PARENT))
+
+
+try:
+ import agent.memory_provider # type: ignore[import-not-found] # noqa: F401
+except ImportError:
+ agent_module = types.ModuleType("agent")
+ memory_provider_module = types.ModuleType("agent.memory_provider")
+
+ class MemoryProvider:
+ """Minimal Hermes contract used when hermes-agent is not installed."""
+
+ @dataclass(frozen=True)
+ class RecallStatus:
+ provider_label: str
+ count: int
+ glyph: str = "🧠"
+
+ memory_provider_module.MemoryProvider = MemoryProvider
+ memory_provider_module.RecallStatus = RecallStatus
+ agent_module.memory_provider = memory_provider_module
+ sys.modules["agent"] = agent_module
+ sys.modules["agent.memory_provider"] = memory_provider_module
+
+PLUGIN_MODULE = importlib.import_module("hermes_agent")
+BACKEND_MODULE = importlib.import_module("hermes_agent.backend")
+CONFIG_MODULE = importlib.import_module("hermes_agent.config")
+EMBEDDED_MODULE = importlib.import_module("hermes_agent.embedded_backend")
+CLIENT_MODULE = importlib.import_module("hermes_agent.client")
+
+ReMeMemoryProvider = PLUGIN_MODULE.ReMeMemoryProvider
+ReMeBackendError = BACKEND_MODULE.ReMeBackendError
+ReMeConfig = CONFIG_MODULE.ReMeConfig
+ReMeConfigError = CONFIG_MODULE.ReMeConfigError
+config_path = CONFIG_MODULE.config_path
+load_config = CONFIG_MODULE.load_config
+parse_config = CONFIG_MODULE.parse_config
+save_config = CONFIG_MODULE.save_config
+EmbeddedReMeBackend = EMBEDDED_MODULE.EmbeddedReMeBackend
+ReMeHttpClient = CLIENT_MODULE.ReMeHttpClient
+scoped_session_id = PLUGIN_MODULE._scoped_session_id
+
+
+def test_config_defaults_to_http(tmp_path):
+ config = load_config(tmp_path)
+
+ assert config.mode == "http"
+ assert config.endpoint == "http://127.0.0.1:2333"
+
+
+def test_provider_schema_exposes_mode_specific_and_advanced_fields():
+ fields = {field["key"]: field for field in ReMeMemoryProvider().get_config_schema()}
+
+ assert set(fields) == {
+ "mode",
+ "endpoint",
+ "workspace_dir",
+ "reme_config",
+ "recall_limit",
+ "recall_timeout",
+ "request_timeout",
+ "health_timeout",
+ "health_retry_seconds",
+ "shutdown_timeout",
+ }
+ assert fields["endpoint"]["when"] == {"mode": "http"}
+ assert fields["workspace_dir"]["when"] == {"mode": "embedded"}
+
+
+def test_current_config_precedes_legacy(tmp_path):
+ (tmp_path / "reme.json").write_text(
+ '{"endpoint": "http://legacy:1"}',
+ encoding="utf-8",
+ )
+ current = config_path(tmp_path)
+ current.parent.mkdir()
+ current.write_text('{"endpoint": "http://current:2"}', encoding="utf-8")
+
+ assert load_config(tmp_path).endpoint == "http://current:2"
+
+
+def test_sparse_dashboard_config_inherits_legacy_values(tmp_path):
+ (tmp_path / "reme.json").write_text(
+ '{"endpoint": "http://legacy:2444", "recall_limit": 3}',
+ encoding="utf-8",
+ )
+ current = config_path(tmp_path)
+ current.parent.mkdir()
+ current.write_text('{"recall_limit": 7}', encoding="utf-8")
+
+ config = load_config(tmp_path)
+
+ assert config.endpoint == "http://legacy:2444"
+ assert config.recall_limit == 7
+
+
+def test_embedded_config_normalizes_workspace(tmp_path):
+ config = parse_config(
+ {"mode": " EMBEDDED ", "workspace_dir": str(tmp_path / "workspace")},
+ hermes_home=tmp_path,
+ )
+
+ assert config.mode == "embedded"
+ assert config.workspace_dir == str((tmp_path / "workspace").absolute())
+
+
+def test_embedded_config_requires_workspace(tmp_path):
+ with pytest.raises(ReMeConfigError, match="workspace_dir"):
+ parse_config({"mode": "embedded"}, hermes_home=tmp_path)
+
+
+@pytest.mark.parametrize("value", [float("nan"), float("inf"), float("-inf")])
+def test_config_rejects_non_finite_timeouts(tmp_path, value):
+ with pytest.raises(ReMeConfigError, match="positive number"):
+ parse_config({"request_timeout": value}, hermes_home=tmp_path)
+
+
+@pytest.mark.parametrize(
+ "endpoint",
+ [
+ "http://user:secret@127.0.0.1:2333",
+ "http://127.0.0.1:2333?token=secret",
+ "http://127.0.0.1:2333#fragment",
+ "http://127.0.0.1:invalid",
+ ],
+)
+def test_config_and_client_reject_unsafe_endpoint_shapes(tmp_path, endpoint):
+ with pytest.raises(ReMeConfigError, match="absolute http"):
+ parse_config({"endpoint": endpoint}, hermes_home=tmp_path)
+ with pytest.raises(ValueError, match="absolute http"):
+ ReMeHttpClient(endpoint, timeout=1)
+
+
+def test_save_config_uses_dashboard_layout_and_private_permissions(tmp_path):
+ saved = save_config({"mode": "http", "recall_limit": 7}, tmp_path)
+ path = config_path(tmp_path)
+
+ assert saved.recall_limit == 7
+ assert path.is_file()
+ assert path.stat().st_mode & 0o777 == 0o600
+
+
+class _FakeResponse:
+ def __init__(self, answer="", metadata=None, success=True):
+ self.answer = answer
+ self.metadata = metadata or {}
+ self.success = success
+
+ def model_dump(self):
+ return {
+ "answer": self.answer,
+ "metadata": self.metadata,
+ "success": self.success,
+ }
+
+
+class _FakeApplication:
+ instances = []
+
+ def __init__(self, **config):
+ self.config = config
+ self.started = False
+ self.closed = False
+ self.calls = []
+ self.__class__.instances.append(self)
+
+ async def start(self):
+ self.started = True
+
+ async def close(self):
+ self.closed = True
+
+ async def run_job(self, name, **kwargs):
+ self.calls.append((name, kwargs))
+ if name == "health_check":
+ return _FakeResponse(metadata={"health": {"healthy": True}})
+ return _FakeResponse(answer=name, metadata={"counts": {"returned": 1}})
+
+
+def test_embedded_backend_owns_application_lifecycle(monkeypatch, tmp_path):
+ import reme
+ import reme.config
+
+ _FakeApplication.instances.clear()
+ monkeypatch.setattr(reme, "Application", _FakeApplication)
+ monkeypatch.setattr(
+ reme.config,
+ "resolve_app_config",
+ lambda **kwargs: {
+ "workspace_dir": kwargs["workspace_dir"],
+ "marker": kwargs["config"],
+ },
+ )
+ backend = EmbeddedReMeBackend(str(tmp_path), start_timeout=2)
+
+ backend.start()
+ assert backend.health(timeout=2)["success"] is True
+ assert backend.search("needle", limit=3, timeout=2)["answer"] == "search"
+ backend.auto_memory("session", [{"role": "user", "content": "hello"}], timeout=2)
+ backend.close(timeout=2)
+
+ app = _FakeApplication.instances[0]
+ assert app.started is True
+ assert app.closed is True
+ assert app.config == {
+ "workspace_dir": str(tmp_path),
+ "marker": "default",
+ }
+ assert [name for name, _ in app.calls] == ["health_check", "search", "auto_memory"]
+ assert backend.state == "closed"
+
+
+class _FakeBackend:
+ label = "fake"
+
+ def __init__(self):
+ self.writes = []
+ self.closed = False
+
+ def start(self):
+ return None
+
+ def health(self, *, timeout):
+ del timeout
+ return {"success": True, "metadata": {"health": {"healthy": True}}}
+
+ def search(self, query, *, limit, timeout):
+ del query, limit, timeout
+ return {
+ "success": True,
+ "answer": " remembered ",
+ "metadata": {"counts": {"returned": 2}},
+ }
+
+ def auto_memory(self, session_id, messages, *, timeout):
+ del timeout
+ self.writes.append((session_id, messages))
+ return {"success": True}
+
+ def close(self, *, timeout):
+ del timeout
+ self.closed = True
+
+
+def test_provider_selects_backend_recalls_and_writes(monkeypatch, tmp_path):
+ backend = _FakeBackend()
+ monkeypatch.setattr(PLUGIN_MODULE, "load_config", lambda home=None: ReMeConfig())
+ monkeypatch.setattr(PLUGIN_MODULE, "_backend_for", lambda config: backend)
+ provider = ReMeMemoryProvider()
+ provider.initialize("session/one", hermes_home=tmp_path, agent_identity="work")
+
+ assert provider.prefetch("project decision") == "remembered"
+ assert provider.recall_status().count == 2
+ provider.sync_turn("hello", "hi")
+ provider.shutdown()
+
+ assert len(backend.writes) == 1
+ assert backend.writes[0][0].startswith("hermes-work-session-one-")
+ assert backend.closed is True
+
+
+def test_session_scope_distinguishes_profiles_and_ambiguous_names():
+ assert scoped_session_id("profile/a", "session") != scoped_session_id(
+ "profile-a",
+ "session",
+ )
+ assert scoped_session_id("profile", "session/a") != scoped_session_id(
+ "profile",
+ "session-a",
+ )
+
+
+def test_reinitialize_closes_previous_backend(monkeypatch, tmp_path):
+ backends = [_FakeBackend(), _FakeBackend()]
+ monkeypatch.setattr(PLUGIN_MODULE, "load_config", lambda home=None: ReMeConfig())
+ monkeypatch.setattr(PLUGIN_MODULE, "_backend_for", lambda config: backends.pop(0))
+ provider = ReMeMemoryProvider()
+
+ provider.initialize("first", hermes_home=tmp_path)
+ first = provider._backend
+ provider.initialize("second", hermes_home=tmp_path)
+
+ assert first is not None and first.closed is True
+ assert provider._backend is not first
+ provider.shutdown()
+
+
+def test_provider_failure_does_not_escape_model_path(monkeypatch, tmp_path):
+ backend = _FakeBackend()
+ backend.search = lambda *args, **kwargs: (_ for _ in ()).throw(
+ ReMeBackendError("offline"),
+ )
+ monkeypatch.setattr(PLUGIN_MODULE, "load_config", lambda home=None: ReMeConfig())
+ monkeypatch.setattr(PLUGIN_MODULE, "_backend_for", lambda config: backend)
+ provider = ReMeMemoryProvider()
+ provider.initialize("session", hermes_home=tmp_path)
+
+ assert provider.prefetch("query") == ""
+ assert provider.recall_status() is None
+ provider.shutdown()
+
+
+def test_provider_reports_embedded_workspace_for_hermes_backup(monkeypatch, tmp_path):
+ workspace = tmp_path / "workspace"
+ monkeypatch.setattr(
+ PLUGIN_MODULE,
+ "load_config",
+ lambda home=None: ReMeConfig(mode="embedded", workspace_dir=str(workspace)),
+ )
+
+ assert ReMeMemoryProvider().backup_paths() == [str(workspace)]
+
+
+def test_backend_creation_is_serialized(monkeypatch):
+ provider = ReMeMemoryProvider()
+ provider._config = ReMeConfig()
+ created = []
+
+ def factory(config):
+ del config
+ time.sleep(0.05)
+ backend = _FakeBackend()
+ created.append(backend)
+ return backend
+
+ monkeypatch.setattr(PLUGIN_MODULE, "_backend_for", factory)
+ gate = threading.Barrier(3)
+ results = []
+
+ def ensure():
+ gate.wait()
+ results.append(provider._ensure_backend())
+
+ threads = [threading.Thread(target=ensure) for _ in range(2)]
+ for thread in threads:
+ thread.start()
+ gate.wait()
+ for thread in threads:
+ thread.join(timeout=2)
+
+ assert results == [True, True]
+ assert len(created) == 1
+ provider.shutdown()
+
+
+def test_shutdown_defers_close_until_inflight_recall_finishes():
+ entered = threading.Event()
+ release = threading.Event()
+
+ class BlockingBackend(_FakeBackend):
+ def search(self, query, *, limit, timeout):
+ del query, limit, timeout
+ entered.set()
+ release.wait(timeout=2)
+ return {"success": True, "answer": "remembered", "metadata": {}}
+
+ backend = BlockingBackend()
+ provider = ReMeMemoryProvider()
+ provider._config = ReMeConfig()
+ provider._backend = backend
+ provider._backend_available = True
+ provider._shutdown_timeout = 0.05
+ recall = threading.Thread(target=provider.prefetch, args=("query",))
+ recall.start()
+ assert entered.wait(timeout=1)
+
+ provider.shutdown()
+ assert backend.closed is False
+ release.set()
+ recall.join(timeout=2)
+
+ assert recall.is_alive() is False
+ assert backend.closed is True
+
+
+def test_shutdown_drains_all_accepted_writes_before_closing_backend():
+ entered = threading.Event()
+ release = threading.Event()
+
+ class BlockingBackend(_FakeBackend):
+ def auto_memory(self, session_id, messages, *, timeout):
+ del timeout
+ self.writes.append((session_id, messages))
+ if len(self.writes) == 1:
+ entered.set()
+ release.wait(timeout=2)
+
+ backend = BlockingBackend()
+ provider = ReMeMemoryProvider()
+ provider._config = ReMeConfig()
+ provider._backend = backend
+ provider._backend_available = True
+ provider._shutdown_timeout = 1
+ for index in range(3):
+ provider.sync_turn(f"user {index}", f"assistant {index}", session_id=f"session-{index}")
+ assert entered.wait(timeout=1)
+
+ shutdown = threading.Thread(target=provider.shutdown)
+ shutdown.start()
+ deadline = time.monotonic() + 1
+ while not provider._shutdown_started and time.monotonic() < deadline:
+ time.sleep(0.001)
+ assert provider._shutdown_started is True
+ release.set()
+ shutdown.join(timeout=2)
+
+ assert shutdown.is_alive() is False
+ assert len(backend.writes) == 3
+ assert backend.closed is True
+
+
+def test_recall_timeout_includes_waiting_for_background_write():
+ write_entered = threading.Event()
+ write_release = threading.Event()
+ search_entered = threading.Event()
+
+ class BlockingBackend(_FakeBackend):
+ def auto_memory(self, session_id, messages, *, timeout):
+ del session_id, messages, timeout
+ write_entered.set()
+ write_release.wait(timeout=2)
+
+ def search(self, query, *, limit, timeout):
+ del query, limit, timeout
+ search_entered.set()
+ return {"success": True, "answer": "remembered", "metadata": {}}
+
+ backend = BlockingBackend()
+ provider = ReMeMemoryProvider()
+ provider._config = ReMeConfig()
+ provider._backend = backend
+ provider._backend_available = True
+ provider._recall_timeout = 0.05
+ provider.sync_turn("user", "assistant", session_id="session")
+ assert write_entered.wait(timeout=1)
+
+ started = time.monotonic()
+ assert provider.prefetch("query") == ""
+ elapsed = time.monotonic() - started
+
+ assert elapsed < 0.2
+ assert search_entered.is_set() is False
+ write_release.set()
+ provider.shutdown()
+
+
+def test_recall_timeout_includes_embedded_startup_failure_cleanup(monkeypatch, tmp_path):
+ import reme
+ import reme.config
+
+ class SlowApplication:
+ instances = []
+
+ def __init__(self, **config):
+ del config
+ self.closed = threading.Event()
+ self.thread_pool = object()
+ self.__class__.instances.append(self)
+
+ async def start(self):
+ time.sleep(0.25)
+
+ async def close(self):
+ await asyncio.sleep(0.4)
+ self.thread_pool = None
+ self.closed.set()
+
+ monkeypatch.setattr(reme, "Application", SlowApplication)
+ monkeypatch.setattr(reme.config, "resolve_app_config", lambda **kwargs: kwargs)
+ backend = EmbeddedReMeBackend(str(tmp_path), start_timeout=1)
+ monkeypatch.setattr(PLUGIN_MODULE, "_backend_for", lambda config: backend)
+ provider = ReMeMemoryProvider()
+ provider._config = ReMeConfig(
+ mode="embedded",
+ workspace_dir=str(tmp_path),
+ request_timeout=1,
+ recall_timeout=0.15,
+ shutdown_timeout=0.6,
+ )
+ provider._recall_timeout = 0.15
+ provider._shutdown_timeout = 0.6
+
+ started = time.monotonic()
+ assert provider.prefetch("query") == ""
+ elapsed = time.monotonic() - started
+
+ assert elapsed < 0.25
+ assert backend._thread is not None
+ backend._thread.join(timeout=1)
+ assert backend._thread.is_alive() is False
+ app = SlowApplication.instances[0]
+ assert app.closed.is_set()
+ assert app.thread_pool is None
+
+
+def test_embedded_start_timeout_closes_real_application_resources(monkeypatch, tmp_path):
+ import reme
+ import reme.config
+
+ from reme.application import Application
+ from reme.components import BaseComponent
+
+ component_closed = threading.Event()
+
+ class SlowComponent(BaseComponent):
+ component_type = "slow_test"
+
+ async def _start(self):
+ time.sleep(0.25)
+
+ async def _close(self):
+ component_closed.set()
+
+ app = Application(
+ workspace_dir=str(tmp_path),
+ service={"backend": "cli"},
+ thread_pool_max_workers=1,
+ enable_logo=False,
+ log_to_console=False,
+ log_to_file=False,
+ )
+ component = SlowComponent(name="slow", app_context=app.context)
+ app.context.components["slow_test"] = {"slow": component}
+ monkeypatch.setattr(reme, "Application", lambda **config: app)
+ monkeypatch.setattr(reme.config, "resolve_app_config", lambda **kwargs: kwargs)
+ backend = EmbeddedReMeBackend(str(tmp_path), start_timeout=1)
+
+ started = time.monotonic()
+ with pytest.raises(ReMeBackendError, match="timed out"):
+ backend.start(deadline=started + 0.15)
+ elapsed = time.monotonic() - started
+
+ assert elapsed < 0.25
+ assert backend._thread is not None
+ backend._thread.join(timeout=1)
+ assert backend._thread.is_alive() is False
+ assert component_closed.is_set()
+ assert component.is_started is False
+ assert app.context.thread_pool is None
+
+
+def test_shutdown_discard_keeps_sentinel_for_inflight_writer():
+ provider = ReMeMemoryProvider()
+ provider._write_queue.put({"session_id": "queued"})
+ provider._write_queue.put(None)
+
+ assert provider._discard_queued_writes() == 1
+ assert provider._write_queue.get_nowait() is None
diff --git a/tests/unit/test_injected_job_kwargs.py b/tests/unit/test_injected_job_kwargs.py
index 678ae0e7..5da892e8 100644
--- a/tests/unit/test_injected_job_kwargs.py
+++ b/tests/unit/test_injected_job_kwargs.py
@@ -14,7 +14,6 @@ from reme.components.agent_wrapper import AsAgentWrapper, BaseAgentWrapper, CcAg
from reme.components.file_store import LocalFileStore
from reme.schema import Response
from reme.steps.evolve.auto_memory import AutoMemoryStep
-from reme.steps.evolve.auto_memory_cc import AutoMemoryCCStep
class _Job:
@@ -237,51 +236,6 @@ def test_auto_memory_keeps_original_tool_names():
assert step.update_tools == ["read", "edit", "frontmatter_update", "write"]
-def test_auto_memory_tags_are_disabled_by_default_and_enabled_through_kwargs():
- assert AutoMemoryStep()._tags_enabled() is False
- assert AutoMemoryCCStep()._tags_enabled() is False
- assert AutoMemoryStep(enable_tags=True)._tags_enabled() is True
-
-
-def test_auto_memory_tags_prompt_follows_step_kwarg():
- step = AutoMemoryStep()
- prompt_kwargs = {
- "today": "2026-09-01",
- "note": "(none)",
- "session_id": "s1",
- "history": "user: remember GPT-5",
- }
-
- disabled_system = step.prompt_format("system_prompt", enable_tags=step._tags_enabled())
- disabled_create = step.prompt_format("user_message_create", enable_tags=step._tags_enabled(), **prompt_kwargs)
- disabled_update = step.prompt_format(
- "user_message_update",
- enable_tags=step._tags_enabled(),
- note_path="daily/2026-09-01/memory.md",
- **prompt_kwargs,
- )
- assert "`tags`" not in disabled_system
- assert 'metadata={"tags"' not in disabled_create
- assert '"tags"' not in disabled_update
-
- enabled_step = AutoMemoryStep(enable_tags=True)
- enabled_system = enabled_step.prompt_format("system_prompt", enable_tags=enabled_step._tags_enabled())
- enabled_create = enabled_step.prompt_format(
- "user_message_create",
- enable_tags=enabled_step._tags_enabled(),
- **prompt_kwargs,
- )
- enabled_update = enabled_step.prompt_format(
- "user_message_update",
- enable_tags=enabled_step._tags_enabled(),
- note_path="daily/2026-09-01/memory.md",
- **prompt_kwargs,
- )
- assert "`tags`" in enabled_system
- assert 'metadata={"tags"' in enabled_create
- assert '"tags"' in enabled_update
-
-
def test_auto_memory_create_prompts_match_upstream_date_arguments():
"""Auto-memory prompts keep the upstream model-supplied date argument."""
from pathlib import Path
@@ -289,8 +243,8 @@ def test_auto_memory_create_prompts_match_upstream_date_arguments():
prompt_file = Path("reme/steps/evolve/auto_memory.yaml")
evolve_prompt = prompt_file.read_text(encoding="utf-8")
assert "date={today}" in evolve_prompt or "`date`: {today}" in evolve_prompt or "`date`：{today}" in evolve_prompt
- assert '"tags": [, ...]' in evolve_prompt
- assert '"tags": []' in evolve_prompt or "using `[]`" in evolve_prompt
+ assert "enable_tags" not in evolve_prompt
+ assert "tags_key" not in evolve_prompt
def test_configs_define_original_jobs_without_daily_variants():
@@ -305,7 +259,14 @@ def test_configs_define_original_jobs_without_daily_variants():
assert name not in jobs, f"{config_name} unexpectedly defines {name}"
default = resolve_app_config(config="default", log_config=False)
- assert default["jobs"]["auto_memory"]["steps"][0]["enable_tags"] is False
+ assert default["jobs"]["auto_memory"]["steps"] == [
+ {"backend": "auto_memory_step"},
+ {"backend": "auto_tag_step"},
+ ]
+ assert default["jobs"]["auto_memory_cc"]["steps"] == [
+ {"backend": "auto_memory_cc_step"},
+ {"backend": "auto_tag_step"},
+ ]
if __name__ == "__main__":
diff --git a/tests/unit/test_keyword_index.py b/tests/unit/test_keyword_index.py
index 061c97b7..9d135284 100644
--- a/tests/unit/test_keyword_index.py
+++ b/tests/unit/test_keyword_index.py
@@ -351,6 +351,32 @@ def test_retrieve_score_ordering_by_tf():
run(go())
+def test_filtered_scoring_preserves_global_bm25_scores():
+ """Selected-document scoring filters results without redefining the corpus."""
+
+ async def go():
+ with tempfile.TemporaryDirectory() as tmp, temp_chdir(tmp):
+ bm25 = await create_bm25()
+ await bm25.add_docs(
+ {
+ "high": "python python python",
+ "mid": "python python other",
+ "low": "python alpha beta",
+ "unrelated": "java only",
+ },
+ )
+
+ global_scores = await bm25.retrieve("python", limit=4)
+ selected = await bm25.score_documents("python", {"mid", "low", "unrelated", "missing"})
+ filtered = await bm25.retrieve_filtered("python", 1, {"mid", "low", "unrelated"})
+
+ assert selected == {"mid": global_scores["mid"], "low": global_scores["low"]}
+ assert filtered == {"mid": global_scores["mid"]}
+ await bm25.close()
+
+ run(go())
+
+
def test_retrieve_idf_favours_rare_terms():
"""In a query of {common, rare}, the doc containing the rare term wins."""
diff --git a/tests/unit/test_package_versions.py b/tests/unit/test_package_versions.py
index 5cd8a26e..c36af6bb 100644
--- a/tests/unit/test_package_versions.py
+++ b/tests/unit/test_package_versions.py
@@ -56,12 +56,28 @@ def test_studio_packages_have_independent_identity() -> None:
assert main_config["project"]["optional-dependencies"]["core"].count("reme-ai[as]") == 1
assert main_config["project"]["optional-dependencies"]["core"].count("reme_studio") == 1
assert "qwenpaw" not in main_config["project"]["optional-dependencies"]
- assert auto_fin_config["project"]["version"] == "0.1.2"
- assert daily_paper_config["project"]["version"] == "0.1.2"
+ assert auto_fin_config["project"]["version"] == "0.1.3"
+ assert daily_paper_config["project"]["version"] == "0.1.3"
assert main_config["tool"]["setuptools"]["packages"]["find"]["include"] == ["reme", "reme.*"]
assert "reme_studio*" in main_config["tool"]["setuptools"]["packages"]["find"]["exclude"]
+def test_typescript_host_plugins_are_independent_packages() -> None:
+ """Keep each host adapter self-contained instead of restoring a shared npm package."""
+ manifests = {
+ host: json.loads((REPOSITORY / "integrations" / host / "package.json").read_text(encoding="utf-8"))
+ for host in ("dsh", "openclaw")
+ }
+
+ assert manifests["dsh"]["name"] == "@agentscope-ai/reme-dsh-plugin"
+ assert manifests["openclaw"]["name"] == "@agentscope-ai/reme-openclaw-plugin"
+ assert manifests["dsh"]["version"] == "0.1.0"
+ assert manifests["openclaw"]["version"] == "0.1.0"
+ assert manifests["dsh"].get("dependencies", {}) == {}
+ assert manifests["openclaw"].get("dependencies", {}) == {"typebox": "1.3.19"}
+ assert not (REPOSITORY / "typescript").exists()
+
+
def _write_version_fixture(repository: Path) -> None:
(repository / "reme").mkdir()
(repository / "reme" / "__init__.py").write_text('__version__ = "1.2.3"\n', encoding="utf-8")
@@ -167,8 +183,8 @@ def test_auto_fin_requires_reme_base() -> None:
assert len(reme_requirements) == 1
assert not reme_requirements[0].extras
- assert Version("0.4.1.8") not in reme_requirements[0].specifier
- assert Version("0.4.1.9") in reme_requirements[0].specifier
+ assert Version("0.4.1.11") not in reme_requirements[0].specifier
+ assert Version("0.4.1.12") in reme_requirements[0].specifier
def test_daily_paper_license_matches_repository() -> None:
@@ -185,8 +201,8 @@ def test_daily_paper_declares_runtime_dependencies() -> None:
by_name = {requirement.name: requirement for requirement in requirements}
assert not by_name["reme-ai"].extras
- assert Version("0.4.1.8") not in by_name["reme-ai"].specifier
- assert Version("0.4.1.9") in by_name["reme-ai"].specifier
+ assert Version("0.4.1.11") not in by_name["reme-ai"].specifier
+ assert Version("0.4.1.12") in by_name["reme-ai"].specifier
assert "pypdf" in by_name
diff --git a/tests/unit/test_plugin.py b/tests/unit/test_plugin.py
index 595b32e0..2df7c1dc 100644
--- a/tests/unit/test_plugin.py
+++ b/tests/unit/test_plugin.py
@@ -13,6 +13,7 @@ from reme.config.config_parser import _load_config
from reme.enumeration import ComponentEnum
from reme.plugin import Backend, Plugin, PluginManager, _load_backend
from reme.plugin_manifest import parse_plugin_manifest
+from reme.schema import ApplicationConfig
class _PluginStep(ComponentMixin):
@@ -191,6 +192,42 @@ def test_plugin_manager_loads_package_manifest(monkeypatch, tmp_path):
assert manager.merge_config({})["jobs"]["example"]["backend"] == "base"
+@pytest.mark.parametrize(
+ ("candidate", "judge", "candidate_package", "judge_package", "judge_backend"),
+ [
+ ("lme", "lme-judge", "reme_lme", "judge_lme", "lme_answer_judge_step"),
+ ("beam", "beam-judge", "reme_beam", "judge_beam", "beam_rubric_judge_step"),
+ ],
+)
+def test_benchmark_candidate_and_judge_plugins_compose(
+ monkeypatch,
+ candidate,
+ judge,
+ candidate_package,
+ judge_package,
+ judge_backend,
+):
+ root = Path(__file__).resolve().parents[2]
+ monkeypatch.syspath_prepend(str(root / "plugins" / candidate / "src"))
+ monkeypatch.syspath_prepend(str(root / "plugins" / judge / "src"))
+ _set_entry_points(
+ monkeypatch,
+ _FakeEntryPoint(candidate, candidate_package, lambda: None, "reme.plugins"),
+ _FakeEntryPoint(judge, judge_package, lambda: None, "reme.plugins"),
+ )
+
+ manager = PluginManager.discover([candidate, judge])
+ registry = ComponentRegistry()
+ manager.register(registry)
+ merged = manager.merge_config(_load_config("benchmark"))
+
+ assert {"auto_memory", "search", "agentic_answer", "answer_judge"} <= merged["jobs"].keys()
+ assert registry.get(ComponentEnum.STEP, judge_backend) is not None
+ assert "judge" in merged["components"]["as_llm"]
+ assert "judge" in merged["components"]["agent_wrapper"]
+ ApplicationConfig.model_validate(merged)
+
+
def test_plugin_manifest_rejects_legacy_defaults_field():
with pytest.raises(ValueError, match="unknown keys: defaults"):
parse_plugin_manifest("defaults: {}\n", plugin_name="example")
diff --git a/tests/unit/test_search_step.py b/tests/unit/test_search_step.py
index 65824d55..bf9165b0 100644
--- a/tests/unit/test_search_step.py
+++ b/tests/unit/test_search_step.py
@@ -1,5 +1,7 @@
"""Unit tests for workspace search Steps without embedding or LLM dependencies."""
+# pylint: disable=protected-access
+
import asyncio
import importlib.util
from pathlib import Path
@@ -7,6 +9,8 @@ from pathlib import Path
from agentscope.message import Msg
from reme.components.file_store import BaseFileStore
+from reme.components.file_store.local_file_store import LocalFileStore
+from reme.components.tag_index import LocalTagIndex
from reme.components import ApplicationContext
from reme.components.runtime_context import RuntimeContext
from reme.enumeration import LinkScopeEnum
@@ -42,15 +46,22 @@ class FakeSearchStore(BaseFileStore):
self.calls: list[tuple[str, str, int, dict]] = []
async def upsert(self, files: list[tuple[FileNode, list[FileChunk]]]) -> None:
- raise NotImplementedError
+ """Ignore writes in this read-only search fixture."""
+ del files
async def delete(self, path: str | list[str]) -> None:
- raise NotImplementedError
+ """Ignore deletes in this read-only search fixture."""
+ del path
async def clear(self) -> None:
- raise NotImplementedError
+ """Clear the fixture's in-memory results and recorded calls."""
+ self.vector_results.clear()
+ self.keyword_results.clear()
+ self.calls.clear()
async def get_nodes(self, paths: list[str] | None = None) -> list[FileNode]:
+ """Return no graph nodes for search-only tests."""
+ del paths
return []
async def get_outlinks(
@@ -58,6 +69,8 @@ class FakeSearchStore(BaseFileStore):
path: str,
scope: LinkScopeEnum = LinkScopeEnum.REAL,
) -> list[FileLink]:
+ """Return no outgoing links for search-only tests."""
+ del path, scope
return []
async def get_inlinks(
@@ -65,17 +78,42 @@ class FakeSearchStore(BaseFileStore):
path: str,
scope: LinkScopeEnum = LinkScopeEnum.REAL,
) -> list[FileLink]:
+ """Return no incoming links for search-only tests."""
+ del path, scope
return []
async def vector_search(self, query: str, limit: int, search_filter: dict) -> list[FileChunk]:
+ """Return the configured vector results."""
self.calls.append(("vector", query, limit, search_filter))
return self.vector_results[:limit]
async def keyword_search(self, query: str, limit: int, search_filter: dict) -> list[FileChunk]:
+ """Return the configured keyword results."""
self.calls.append(("keyword", query, limit, search_filter))
return self.keyword_results[:limit]
+class TaggedFakeSearchStore(FakeSearchStore):
+ """Fake store with a tag index and ordinary file-store filtering."""
+
+ def __init__(self, *, chunks: list[FileChunk]):
+ super().__init__(vector_results=chunks, keyword_results=chunks)
+ self.file_chunks = {chunk.id: chunk for chunk in chunks}
+ self.tag_index = LocalTagIndex()
+
+ async def vector_search(self, query: str, limit: int, search_filter: dict) -> list[FileChunk]:
+ self.calls.append(("vector", query, limit, search_filter))
+ return [chunk for chunk in self.vector_results if LocalFileStore._matches_search_filter(chunk, search_filter)][
+ :limit
+ ]
+
+ async def keyword_search(self, query: str, limit: int, search_filter: dict) -> list[FileChunk]:
+ self.calls.append(("keyword", query, limit, search_filter))
+ return [chunk for chunk in self.keyword_results if LocalFileStore._matches_search_filter(chunk, search_filter)][
+ :limit
+ ]
+
+
def _chunk(
chunk_id: str,
path: str,
@@ -898,6 +936,87 @@ def test_search_step_empty_query_fails_before_store_calls():
asyncio.run(run())
+def test_search_step_falls_back_for_unavailable_index_and_rejects_invalid_tags():
+ """Unavailable optional indexes preserve search, while malformed tags still fail."""
+
+ async def run():
+ hit = _chunk("hit", "daily/a.md", "text", "keyword", 3.0)
+ missing = FakeSearchStore(keyword_results=[hit])
+ unhealthy = TaggedFakeSearchStore(chunks=[hit])
+ unhealthy.tag_index.set_healthy(False)
+
+ for store in (missing, unhealthy):
+ resp = await SearchStep(file_store=store, expand_links=False)(
+ RuntimeContext(query="hello", limit=5, tags=["python"]),
+ )
+ assert resp.success is True
+ assert [result["id"] for result in resp.metadata["results"]] == ["hit"]
+ assert {call[0] for call in store.calls} == {"vector", "keyword"}
+ assert all(call[3] == {} for call in store.calls)
+ assert resp.metadata["tag_filter"] == {
+ "requested": True,
+ "applied": False,
+ "reason": "tag_index_unavailable",
+ }
+
+ invalid = TaggedFakeSearchStore(chunks=[])
+ resp = await SearchStep(file_store=invalid, expand_links=False)(
+ RuntimeContext(query="hello", limit=5, tags=["!", "++", "x" * 65]),
+ )
+ assert resp.success is False
+ assert resp.answer == "Error: tags contained no valid values"
+ assert not invalid.calls
+
+ asyncio.run(run())
+
+
+def test_search_step_combines_tags_with_existing_chunk_filters():
+ """Tags use OR internally and are ANDed with existing path/date behavior."""
+
+ async def run():
+ matching = _chunk("a", "daily/2024-03-01/a.md", "match", "keyword", 3.0)
+ old = _chunk("b", "daily/2023-03-01/b.md", "old", "keyword", 2.0)
+ wrong_prefix = _chunk("c", "resource/2024-03-01/c.md", "resource", "keyword", 1.0)
+ store = TaggedFakeSearchStore(chunks=[matching, old, wrong_prefix])
+ await store.tag_index.rebuild(
+ [
+ FileNode(path=matching.path, st_mtime=1.0, front_matter={"memory_tags": ["Python"]}),
+ FileNode(path=old.path, st_mtime=1.0, front_matter={"memory_tags": ["ReMe"]}),
+ FileNode(path=wrong_prefix.path, st_mtime=1.0, front_matter={"memory_tags": ["python"]}),
+ ],
+ )
+ step = SearchStep(file_store=store, expand_links=False)
+
+ resp = await step(
+ RuntimeContext(
+ query="hello",
+ limit=5,
+ tags=[" PYTHON ", "REME"],
+ start_date="2024-01-01",
+ search_filter={"path_prefix": "daily/"},
+ ),
+ )
+
+ assert resp.success is True
+ assert [result["id"] for result in resp.metadata["results"]] == ["a"]
+ assert resp.metadata["tag_filter"] == {
+ "requested": True,
+ "applied": True,
+ "tags": ["python", "reme"],
+ "matched_paths": 3,
+ }
+ assert {call[0] for call in store.calls} == {"vector", "keyword"}
+ assert all(set(call[3]["paths"]) == {matching.path, old.path, wrong_prefix.path} for call in store.calls)
+ store.calls.clear()
+ resp = await step(RuntimeContext(query="hello", limit=5, tags=["missing"]))
+ assert resp.success is True
+ assert resp.metadata["results"] == []
+ assert resp.metadata["tag_filter"]["matched_paths"] == 0
+ assert all(call[3]["paths"] == [] for call in store.calls)
+
+ asyncio.run(run())
+
+
def test_search_step_start_end_date_promoted_into_search_filter():
"""start_date and end_date from context are promoted into search_filter passed to store."""
diff --git a/tests/unit/test_tag_index.py b/tests/unit/test_tag_index.py
index 407bd02b..845eb279 100644
--- a/tests/unit/test_tag_index.py
+++ b/tests/unit/test_tag_index.py
@@ -7,15 +7,18 @@ from pathlib import Path
import pytest
+from reme.components.application_context import ApplicationContext
from reme.components.file_chunker import MarkdownFileChunker
from reme.components.file_store import LocalFileStore
from reme.components.tag_index import LocalTagIndex
from reme.config import resolve_app_config
+from reme.enumeration import ComponentEnum
from reme.schema import FileChunk, FileFrontMatter, FileNode
+from reme.steps.index.list_tags import ListTagsStep
-def _node(path: str, tags: object = None) -> FileNode:
- metadata = {} if tags is None else {"tags": tags}
+def _node(path: str, tags: object = None, *, key: str = "memory_tags") -> FileNode:
+ metadata = {} if tags is None else {key: tags}
return FileNode(path=path, st_mtime=1.0, front_matter=FileFrontMatter(**metadata))
@@ -23,18 +26,22 @@ def _chunk(chunk_id: str, path: str, text: str) -> FileChunk:
return FileChunk(id=chunk_id, path=path, text=text, start_line=1, end_line=1)
+def _standalone_file_store_with_tag_index(**kwargs) -> LocalFileStore:
+ return LocalFileStore(tag_index="default", **kwargs)
+
+
def test_tag_normalization_and_bidirectional_mutations() -> None:
"""Normalize FileNode tags and keep both lookup directions consistent."""
async def run() -> None:
index = LocalTagIndex(max_tags_per_file=3)
await index.start()
- await index.upsert_nodes([_node("daily/a.md", ["Python", "PYTHON", "C++", ".NET", "ignored"])])
+ await index.upsert_nodes([_node("daily/a.md", ["Python Tag", "PYTHON TAG", "C++", ".NET", "ignored"])])
- assert await index.tags_for_path("daily/a.md") == ["python", "c++", ".net"]
- assert await index.paths_for_tags(["PYTHON"]) == ["daily/a.md"]
+ assert await index.tags_for_path("daily/a.md") == ["python_tag", "c++", ".net"]
+ assert await index.paths_for_tags(["PYTHON TAG"]) == ["daily/a.md"]
assert index.tag_to_paths == {
- "python": {"daily/a.md"},
+ "python_tag": {"daily/a.md"},
"c++": {"daily/a.md"},
".net": {"daily/a.md"},
}
@@ -85,7 +92,7 @@ def test_queries_are_not_truncated_by_per_file_tag_limit() -> None:
"""Apply the count limit to indexed files without dropping lookup conditions."""
async def run() -> None:
- index = LocalTagIndex(max_tags_per_file=2)
+ index = LocalTagIndex(max_tags_per_file=2, max_tag_length=8)
await index.rebuild(
[
_node("daily/a.md", ["a", "b"]),
@@ -98,6 +105,233 @@ def test_queries_are_not_truncated_by_per_file_tag_limit() -> None:
"daily/a.md",
"daily/c.md",
]
+ assert index.normalize_query_tags([" A ", "B", "c c", "a", "too-long-tag", " "]) == ["a", "b", "c_c"]
+
+ asyncio.run(run())
+
+
+def test_list_tags_paginates_and_applies_default_sort_orders() -> None:
+ """List only active tags with compact counts and deterministic pagination."""
+
+ async def run() -> None:
+ index = LocalTagIndex()
+ await index.rebuild(
+ [
+ _node("daily/a.md", ["beta", "alpha"]),
+ _node("daily/b.md", ["gamma", "beta"]),
+ _node("daily/c.md", ["delta"]),
+ ],
+ )
+
+ assert await index.list_tags(page_size=2) == {
+ "total_tags": 4,
+ "total_pages": 2,
+ "page": 1,
+ "range": (1, 2),
+ "items": [("alpha", 1), ("beta", 2)],
+ }
+ assert await index.list_tags(page=2, page_size=2) == {
+ "total_tags": 4,
+ "total_pages": 2,
+ "page": 2,
+ "range": (3, 4),
+ "items": [("delta", 1), ("gamma", 1)],
+ }
+ assert (await index.list_tags(order_by="file_count"))["items"] == [
+ ("beta", 2),
+ ("alpha", 1),
+ ("delta", 1),
+ ("gamma", 1),
+ ]
+ assert (await index.list_tags(order_by="file_count", order="asc"))["items"] == [
+ ("alpha", 1),
+ ("delta", 1),
+ ("gamma", 1),
+ ("beta", 2),
+ ]
+ assert (await index.list_tags(order="desc"))["items"] == [
+ ("gamma", 1),
+ ("delta", 1),
+ ("beta", 2),
+ ("alpha", 1),
+ ]
+
+ await index.delete(["daily/c.md"])
+ result = await index.list_tags(page=3, page_size=2)
+ assert result == {
+ "total_tags": 3,
+ "total_pages": 2,
+ "page": 3,
+ "range": (0, 0),
+ "items": [],
+ }
+
+ await index.clear()
+ assert await index.list_tags(page=9) == {
+ "total_tags": 0,
+ "total_pages": 0,
+ "page": 9,
+ "range": (0, 0),
+ "items": [],
+ }
+
+ invalid_cases = [
+ ({"page": 0}, "page must be a positive integer"),
+ ({"page_size": True}, "page_size must be a positive integer"),
+ ({"page_size": 1001}, "page_size must be less than or equal to 1000"),
+ ({"order_by": "unknown"}, "order_by must be one of"),
+ ({"order": "sideways"}, "order must be one of"),
+ ]
+ for kwargs, message in invalid_cases:
+ with pytest.raises(ValueError, match=message):
+ await index.list_tags(**kwargs)
+
+ index.set_healthy(False)
+ with pytest.raises(RuntimeError, match="tag index is unavailable"):
+ await index.list_tags()
+
+ store = LocalFileStore(name="test", embedding_store="", tag_index="")
+ store.tag_index = LocalTagIndex()
+ await store.tag_index.rebuild([_node("daily/a.md", ["ReMe"])])
+
+ response = await ListTagsStep(file_store=store)(order_by="file_count")
+
+ assert response.answer == {
+ "total_tags": 1,
+ "total_pages": 1,
+ "page": 1,
+ "range": (1, 1),
+ "items": [("reme", 1)],
+ }
+
+ asyncio.run(run())
+
+ config = resolve_app_config(config="default", log_config=False)
+ job = config["jobs"]["list_tags"]
+ assert job["steps"] == [{"backend": "list_tags_step"}]
+ assert job["parameters"]["properties"]["page_size"]["default"] == 100
+ assert "[tag, file_count]" in job["description"]
+ assert "range" in job["description"]
+ assert "empty page" in job["parameters"]["properties"]["page"]["description"]
+
+
+@pytest.mark.asyncio
+async def test_list_tags_resolves_named_file_store_from_runtime_context(tmp_path) -> None:
+ """Injected tool context can route list_tags to the AutoTag Step's file store."""
+ context = ApplicationContext(workspace_dir=str(tmp_path))
+ default_store = LocalFileStore(name="default", embedding_store="", tag_index="")
+ archive_store = LocalFileStore(name="archive", embedding_store="", tag_index="")
+ default_store.tag_index = LocalTagIndex()
+ archive_store.tag_index = LocalTagIndex()
+ await default_store.tag_index.rebuild([_node("daily/default.md", ["default-tag"])])
+ await archive_store.tag_index.rebuild([_node("daily/archive.md", ["archive-tag"])])
+ context.components = {
+ ComponentEnum.FILE_STORE: {
+ "default": default_store,
+ "archive": archive_store,
+ },
+ }
+
+ response = await ListTagsStep(app_context=context)(file_store="archive")
+
+ assert response.answer["items"] == [("archive-tag", 1)]
+
+
+def test_configured_frontmatter_key_contract() -> None:
+ """Validate, apply, and invalidate changes to the configured source key."""
+
+ async def run() -> None:
+ index = LocalTagIndex(tag_key="keywords")
+ await index.rebuild(
+ [
+ _node("daily/a.md", ["ignored"]),
+ _node("daily/b.md", ["Python"], key="keywords"),
+ ],
+ )
+
+ assert index.tag_key == "keywords"
+ assert await index.paths_for_tags(["python"]) == ["daily/b.md"]
+ assert await index.paths_for_tags(["ignored"]) == []
+
+ asyncio.run(run())
+ invalid_cases = [
+ ("", "tag_key must be a non-empty string", False),
+ (" ", "tag_key must be a non-empty string", False),
+ (None, "tag_key must be a non-empty string", False),
+ (123, "tag_key must be a non-empty string", False),
+ ("name", "tag_key must not be a reserved frontmatter key", False),
+ ("description", "tag_key must not be a reserved frontmatter key", False),
+ ("kind", "tag_key must not be a reserved frontmatter key", False),
+ ("session_id", "tag_key must not be a reserved frontmatter key", False),
+ ("source_conversation", "tag_key must not be a reserved frontmatter key", False),
+ ("source_resource", "tag_key must not be a reserved frontmatter key", False),
+ ("status", "tag_key must not be a reserved frontmatter key", False),
+ ("", "tag_key must be a non-empty string", True),
+ ("name", "tag_key must not be a reserved frontmatter key", True),
+ ("description", "tag_key must not be a reserved frontmatter key", True),
+ ]
+ for tag_key, message, at_runtime in invalid_cases:
+ index = LocalTagIndex()
+ with pytest.raises(ValueError, match=message):
+ if at_runtime:
+ index.tag_key = tag_key
+ else:
+ LocalTagIndex(tag_key=tag_key)
+ if at_runtime:
+ assert index.tag_key == "memory_tags"
+
+ assert LocalTagIndex(tag_key="model_config").tag_key == "model_config"
+ index = LocalTagIndex()
+ index.tag_key = "keywords"
+ assert index.tag_key == "keywords"
+ assert not index.is_healthy
+
+
+def test_file_store_tag_index_binding_only_defaults_for_default_name() -> None:
+ """Support standalone defaults without silently substituting named dependencies."""
+ default_store = LocalFileStore(name="default-store", embedding_store="", tag_index="default")
+ custom_store = LocalFileStore(name="custom-store", embedding_store="", tag_index="custom")
+
+ default_dependency = default_store.dependency_bindings["tag_index"]
+ assert default_dependency.name == "default"
+ assert default_dependency.default_factory is LocalTagIndex
+ assert default_dependency.optional is False
+
+ custom_dependency = custom_store.dependency_bindings["tag_index"]
+ assert custom_dependency.name == "custom"
+ assert custom_dependency.default_factory is None
+ assert custom_dependency.optional is False
+
+
+def test_file_store_without_tag_index_name_disables_tag_index() -> None:
+ """Treat both an omitted tag-index setting and an explicit empty name as disabled."""
+ omitted = LocalFileStore(name="omitted", embedding_store="")
+ explicit = LocalFileStore(name="explicit", embedding_store="", tag_index="")
+
+ assert omitted.tag_index is None
+ assert omitted.tag_index_enabled is False
+ assert explicit.tag_index is None
+ assert explicit.tag_index_enabled is False
+
+
+@pytest.mark.parametrize("tag_index_name", ["", "custom", "missing"])
+def test_file_store_resolves_configured_tag_index(tag_index_name: str, tmp_path: Path) -> None:
+ """Resolve tag indexes by configured component name and fail on missing names."""
+
+ async def run() -> None:
+ context = ApplicationContext(workspace_dir=str(tmp_path))
+ index = LocalTagIndex(name="custom", tag_key="keywords")
+ context.components = {ComponentEnum.TAG_INDEX: {"custom": index}}
+ store = LocalFileStore(app_context=context, embedding_store="", tag_index=tag_index_name)
+
+ if tag_index_name == "missing":
+ with pytest.raises(ValueError, match="tag_index 'missing' not found"):
+ await store.start()
+ assert not store.is_started
+ else:
+ await store._resolve_bindings()
+ assert store.tag_index is (index if tag_index_name else None)
+ assert store.tag_index_enabled is bool(tag_index_name)
asyncio.run(run())
@@ -105,11 +339,18 @@ def test_queries_are_not_truncated_by_per_file_tag_limit() -> None:
def test_file_store_updates_tag_index_from_file_nodes(monkeypatch, tmp_path: Path) -> None:
"""Keep daily and digest tags aligned through file-store mutations."""
+ disabled_store = LocalFileStore(name="test", embedding_store="", tag_index="")
+ assert disabled_store.tag_index_enabled is False
+ with pytest.raises(RuntimeError, match="tag index is not configured"):
+ disabled_store.require_tag_index()
+
async def run() -> None:
monkeypatch.chdir(tmp_path)
- store = LocalFileStore(name="test", embedding_store="", tag_index="default")
+ store = _standalone_file_store_with_tag_index(name="test", embedding_store="")
await store.start()
assert isinstance(store.tag_index, LocalTagIndex)
+ assert store.tag_index_enabled is True
+ assert store.require_tag_index() is store.tag_index
await store.upsert(
[
@@ -140,9 +381,9 @@ def test_tag_failures_do_not_block_other_indexes_and_retry_rebuild(monkeypatch,
async def run() -> None:
monkeypatch.chdir(tmp_path)
- store = LocalFileStore(name="test", embedding_store="", tag_index="default")
+ store = _standalone_file_store_with_tag_index(name="test", embedding_store="")
await store.start()
- assert store.tag_index is not None
+ assert store.tag_index_enabled
original_rebuild = store.tag_index.rebuild
async def fail_incremental(_nodes) -> None:
@@ -180,9 +421,9 @@ def test_failed_tag_reconciliation_makes_queries_fail_closed(monkeypatch, tmp_pa
async def run() -> None:
monkeypatch.chdir(tmp_path)
- store = LocalFileStore(name="test", embedding_store="", tag_index="default")
+ store = _standalone_file_store_with_tag_index(name="test", embedding_store="")
await store.start()
- assert store.tag_index is not None
+ assert store.tag_index_enabled
await store.upsert([(_node("daily/a.md", ["old"]), [])])
async def fail(_items) -> None:
@@ -207,9 +448,9 @@ def test_tag_rebuild_graph_read_failure_does_not_block_upsert(monkeypatch, tmp_p
async def run() -> None:
monkeypatch.chdir(tmp_path)
- store = LocalFileStore(name="test", embedding_store="", tag_index="default")
+ store = _standalone_file_store_with_tag_index(name="test", embedding_store="")
await store.start()
- assert store.tag_index is not None
+ assert store.tag_index_enabled
assert store.file_graph is not None
store._tag_index_rebuild_required = True
original_get_nodes = store.file_graph.get_nodes
@@ -237,9 +478,9 @@ def test_explicit_reindex_restores_tag_index(monkeypatch, tmp_path: Path) -> Non
async def run() -> None:
monkeypatch.chdir(tmp_path)
- store = LocalFileStore(name="test", embedding_store="", tag_index="default")
+ store = _standalone_file_store_with_tag_index(name="test", embedding_store="")
await store.start()
- assert store.tag_index is not None
+ assert store.tag_index_enabled
await store.upsert(
[
(_node("daily/a.md", ["ReMe"]), []),
@@ -256,6 +497,13 @@ def test_explicit_reindex_restores_tag_index(monkeypatch, tmp_path: Path) -> Non
result = await store.reindex("all")
assert result["tag"] == {"indexed": 1, "scope": "tag"}
assert await store.tag_index.paths_for_tags(["reme"]) == ["daily/a.md"]
+ await store.file_graph.upsert_nodes([_node("daily/a.md", ["new"], key="keywords")])
+
+ store.tag_index.tag_key = "keywords"
+ await store.reindex("tag")
+
+ assert await store.tag_index.paths_for_tags(["old"]) == []
+ assert await store.tag_index.paths_for_tags(["new"]) == ["daily/a.md"]
await store.close()
asyncio.run(run())
@@ -266,9 +514,9 @@ def test_tag_delete_failures_do_not_block_core_deletion(monkeypatch, tmp_path: P
async def run() -> None:
monkeypatch.chdir(tmp_path)
- store = LocalFileStore(name="test", embedding_store="", tag_index="default")
+ store = _standalone_file_store_with_tag_index(name="test", embedding_store="")
await store.start()
- assert store.tag_index is not None
+ assert store.tag_index_enabled
chunk = _chunk("chunk-a", "daily/a.md", "alpha memory")
await store.upsert([(_node("daily/a.md", ["alpha"]), [chunk])])
@@ -298,10 +546,10 @@ def test_existing_markdown_chunker_supplies_frontmatter_tags(monkeypatch, tmp_pa
monkeypatch.chdir(tmp_path)
note = tmp_path / "daily" / "a.md"
note.parent.mkdir()
- note.write_text("---\ntags: [Python, ReMe]\n---\nbody\n", encoding="utf-8")
+ note.write_text("---\nmemory_tags: [Python, ReMe]\n---\nbody\n", encoding="utf-8")
node, chunks = await MarkdownFileChunker().chunk(note)
- store = LocalFileStore(name="test", embedding_store="", tag_index="default")
+ store = _standalone_file_store_with_tag_index(name="test", embedding_store="")
await store.start()
await store.upsert([(node, chunks)])
@@ -316,14 +564,14 @@ def test_file_store_rebuilds_non_persistent_tag_index_from_graph(monkeypatch, tm
async def run() -> None:
monkeypatch.chdir(tmp_path)
- first = LocalFileStore(name="test", embedding_store="", tag_index="default")
+ first = _standalone_file_store_with_tag_index(name="test", embedding_store="")
await first.start()
await first.upsert([(_node("daily/a.md", ["ReMe"]), [])])
await first.close()
assert not list((tmp_path / "metadata").glob("tag_index/**/*"))
- restored = LocalFileStore(name="test", embedding_store="", tag_index="default")
+ restored = _standalone_file_store_with_tag_index(name="test", embedding_store="")
await restored.start()
assert await restored.tag_index.paths_for_tags(["reme"]) == ["daily/a.md"]
await restored.close()
@@ -331,16 +579,22 @@ def test_file_store_rebuilds_non_persistent_tag_index_from_graph(monkeypatch, tm
asyncio.run(run())
-def test_default_config_documents_optional_tag_index_without_enabling_it() -> None:
- """Document tag indexing in the default config without enabling another index or watcher."""
+def test_default_config_enables_tag_index_with_explicit_key() -> None:
+ """Keep auto-memory generation and file-store indexing on the same configured key."""
config = resolve_app_config(config="default", log_config=False)
assert config["jobs"]["index_update_loop"]["watch_dirs"] == ["daily_dir", "digest_dir"]
assert "tag_index_loop" not in config["jobs"]
- assert "tag_index" not in config["components"]
- assert "tag_index" not in config["components"]["file_store"]["default"]
-
- default_yaml = Path("reme/config/default.yaml").read_text(encoding="utf-8")
- assert "# tag_index:" in default_yaml
- assert "# tag_index: default" in default_yaml
+ assert config["components"]["tag_index"]["default"]["tag_key"] == "memory_tags"
+ assert config["components"]["tag_index"]["default"]["max_tags_per_file"] == 3
+ assert config["components"]["file_store"]["default"]["tag_index"] == "default"
+ assert config["jobs"]["search"]["parameters"]["properties"]["tags"]["default"] == []
+ assert config["jobs"]["auto_memory"]["steps"] == [
+ {"backend": "auto_memory_step"},
+ {"backend": "auto_tag_step"},
+ ]
+ assert config["jobs"]["auto_memory_cc"]["steps"] == [
+ {"backend": "auto_memory_cc_step"},
+ {"backend": "auto_tag_step"},
+ ]
diff --git a/tests/unit/test_zvec_file_store.py b/tests/unit/test_zvec_file_store.py
index ba1566f4..037486ac 100644
--- a/tests/unit/test_zvec_file_store.py
+++ b/tests/unit/test_zvec_file_store.py
@@ -38,6 +38,7 @@ class FakeEmbeddingStore:
dimensions = 2
max_batch_size = 10
+ is_healthy = True
def _embed(self, text: str) -> np.ndarray:
if "beta" in text or "fresh" in text:
diff --git a/typescript/README.md b/typescript/README.md
deleted file mode 100644
index 9357adf1..00000000
--- a/typescript/README.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# ReMe for TypeScript agents
-
-[中文说明](./README_ZH.md)
-
-`@agentscope-ai/reme` connects DeepSeek Harness and OpenClaw to ReMe's local-first, file-native long-term memory. The package also exposes a host-independent ReMe HTTP client.
-
-
-
-## Capabilities
-
-- Injects memory guidance and provides explicit `reme_search` lookup.
-- Captures completed conversations through background `auto_memory` batches.
-- Runs optional daily `auto_dream` consolidation in the workspace timezone.
-- Keeps durable memory in user-owned `daily` and `digest` Markdown files.
-- Uses each host's native lifecycle, tools, settings, and shutdown hooks.
-- Excludes plugin context and tool results from automatic memory capture.
-
-## Documentation
-
-| Host | English | 中文 |
-| ---------------- | --------------------------- | ------------------------------------ |
-| DeepSeek Harness | [Guide](./docs/dsh.md) | [使用指南](./docs/dsh.zh-CN.md) |
-| OpenClaw | [Guide](./docs/openclaw.md) | [使用指南](./docs/openclaw.zh-CN.md) |
-
-## Quick start
-
-Start ReMe:
-
-```bash
-pip install "reme-ai[core]"
-reme start workspace_dir=/absolute/path/to/workspace
-```
-
-Install the adapter for your host:
-
-```bash
-# DeepSeek Harness
-dsh plugin --profile web add @agentscope-ai/reme
-
-# OpenClaw
-openclaw plugins install clawhub:@agentscope-ai/reme
-```
-
-The default endpoint is `http://127.0.0.1:2333`. ReMe HTTP does not use API-key authentication, so keep it on loopback or another trusted network unless it is protected by a proxy.
-
-## Client library
-
-```ts
-import { ReMeClient, formatReMeContext } from "@agentscope-ai/reme";
-```
-
-Host adapters are exported from `@agentscope-ai/reme/dsh` and `@agentscope-ai/reme/openclaw`. See the host guides for requirements, configuration, screenshots, troubleshooting, and release behavior.
diff --git a/typescript/README_ZH.md b/typescript/README_ZH.md
deleted file mode 100644
index 5b108fac..00000000
--- a/typescript/README_ZH.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# 面向 TypeScript Agent 的 ReMe
-
-[English](./README.md)
-
-`@agentscope-ai/reme` 将 DeepSeek Harness 和 OpenClaw 连接到 ReMe 本地优先、文件原生的长期记忆，并提供不依赖宿主的 ReMe HTTP 客户端。
-
-
-
-## 核心能力
-
-- 注入长期记忆使用指引，并提供显式的 `reme_search` 检索。
-- 通过后台 `auto_memory` 批次沉淀已完成的对话。
-- 按 workspace 时区运行可选的每日 `auto_dream` 记忆整理。
-- 将持久记忆保存在用户拥有的 `daily` 和 `digest` Markdown 文件中。
-- 使用各宿主原生的生命周期、工具、设置和关停 Hook。
-- 自动记忆会排除插件上下文和工具结果，避免循环写回。
-
-## 使用文档
-
-| 宿主 | English | 中文 |
-| ---------------- | --------------------------- | ------------------------------------ |
-| DeepSeek Harness | [Guide](./docs/dsh.md) | [使用指南](./docs/dsh.zh-CN.md) |
-| OpenClaw | [Guide](./docs/openclaw.md) | [使用指南](./docs/openclaw.zh-CN.md) |
-
-## 快速开始
-
-启动 ReMe：
-
-```bash
-pip install "reme-ai[core]"
-reme start workspace_dir=/absolute/path/to/workspace
-```
-
-安装对应宿主的适配器：
-
-```bash
-# DeepSeek Harness
-dsh plugin --profile web add @agentscope-ai/reme
-
-# OpenClaw
-openclaw plugins install clawhub:@agentscope-ai/reme
-```
-
-默认地址为 `http://127.0.0.1:2333`。ReMe HTTP 不使用 API Key 认证；除非前面有受保护的代理，否则应只监听 loopback 或其他可信网络。
-
-## 客户端库
-
-```ts
-import { ReMeClient, formatReMeContext } from "@agentscope-ai/reme";
-```
-
-宿主适配器分别从 `@agentscope-ai/reme/dsh` 和 `@agentscope-ai/reme/openclaw` 导出。环境要求、完整配置、截图、排障和发布行为请查看对应的宿主文档。
diff --git a/typescript/docs/openclaw.md b/typescript/docs/openclaw.md
deleted file mode 100644
index de9a616a..00000000
--- a/typescript/docs/openclaw.md
+++ /dev/null
@@ -1,72 +0,0 @@
-# ReMe memory for OpenClaw
-
-[中文说明](./openclaw.zh-CN.md)
-
-ReMe gives OpenClaw file-native long-term memory while keeping durable memory in a workspace you own. The plugin uses
-OpenClaw's native lifecycle, hooks, tools, and memory slot.
-
-## What the plugin does
-
-- Registers `reme_search` for explicit memory lookup.
-- Recalls relevant memory before conversational root-agent runs.
-- Captures completed user/assistant turns in background batches.
-- Runs optional daily `auto_dream` memory consolidation in the workspace timezone.
-- Excludes subagent, cron, heartbeat, memory, and overflow runs by default.
-- Wraps recalled content in `` and marks it as untrusted historical data.
-
-## Requirements
-
-- OpenClaw `2026.7.1` or later.
-- Node.js `22.22.3+`, `24.15.0+`, or `25.9.0+` on the corresponding supported major-version line.
-- A running ReMe HTTP service with the `search`, `auto_memory`, and `auto_dream` jobs.
-
-## Start ReMe
-
-Install ReMe and start its local HTTP service:
-
-```bash
-pip install "reme-ai[core]"
-reme start workspace_dir=/absolute/path/to/workspace
-```
-
-The default endpoint is `http://127.0.0.1:2333`. ReMe's HTTP service does not use API-key authentication, so keep it
-on loopback or another trusted network unless you provide a protected proxy boundary.
-
-## Install the OpenClaw plugin
-
-Install explicitly from ClawHub:
-
-```bash
-openclaw plugins install clawhub:@agentscope-ai/reme
-```
-
-When another memory plugin is enabled, select `reme` for `plugins.slots.memory`. OpenClaw remains authoritative for
-conversation access and prompt-injection permissions; grant them to ReMe when your policy requires explicit consent.
-The plugin does not rewrite Gateway configuration.
-
-## Configuration
-
-| Option | Default | Meaning |
-| --------------------- | ----------------------- | --------------------------------------------- |
-| `endpoint` | `http://127.0.0.1:2333` | ReMe HTTP service URL |
-| `language` | `en` | Memory guidance language: `en` or `zh` |
-| `autoRecall` | `true` | Recall before conversational root-agent runs |
-| `searchLimit` | `5` | Maximum search results |
-| `recallMinScore` | `0` | Minimum automatic-recall score |
-| `autoMemoryEnabled` | `true` | Capture completed conversational turns |
-| `autoMemoryInterval` | `5` | Submit after this many completed turns |
-| `autoDreamEnabled` | `true` | Enable daily memory consolidation |
-| `dreamCron` | `0 23 * * *` | Daily schedule in the workspace timezone |
-| `dreamHint` | empty | Optional guidance sent to `auto_dream` |
-| `rootAgentsOnly` | `true` | Exclude subagents from guidance and capture |
-| `timezone` | `Asia/Shanghai` | IANA timezone used for batches and scheduling |
-| `requestTimeoutMs` | `10000` | Recall and explicit-search timeout |
-| `backgroundTimeoutMs` | `3600000` | Automatic-memory and dream timeout |
-| `shutdownTimeoutMs` | `5000` | Best-effort Gateway shutdown drain budget |
-
-Configuration changes apply to subsequent runs. Failed automatic-memory batches are retained for retry, and the
-Gateway shutdown hook attempts to flush pending work within `shutdownTimeoutMs`.
-
-## Source and license
-
-ReMe is developed at [agentscope-ai/ReMe](https://github.com/agentscope-ai/ReMe) and released under Apache-2.0.
diff --git a/typescript/docs/openclaw.zh-CN.md b/typescript/docs/openclaw.zh-CN.md
deleted file mode 100644
index 01444319..00000000
--- a/typescript/docs/openclaw.zh-CN.md
+++ /dev/null
@@ -1,71 +0,0 @@
-# OpenClaw 的 ReMe 长期记忆插件
-
-[English](./openclaw.md)
-
-ReMe 为 OpenClaw 提供文件原生的长期记忆，并将持久记忆保存在用户拥有的 workspace 中。插件使用 OpenClaw
-原生的生命周期、Hook、工具接口和 memory slot。
-
-## 插件能力
-
-- 注册 `reme_search`，支持显式检索记忆。
-- 在根 Agent 的对话运行前自动召回相关记忆。
-- 在后台分批捕获已完成的用户/助手对话。
-- 按 workspace 时区运行可选的每日 `auto_dream` 记忆整理。
-- 默认排除子 Agent、Cron、Heartbeat、Memory 和 Overflow 触发的运行。
-- 使用 `` 包裹召回内容，并将其标记为不可信历史数据。
-
-## 环境要求
-
-- OpenClaw `2026.7.1` 或更高版本。
-- 对应受支持主版本线上的 Node.js `22.22.3+`、`24.15.0+` 或 `25.9.0+`。
-- 已启动 ReMe HTTP 服务，并提供 `search`、`auto_memory` 和 `auto_dream` Job。
-
-## 启动 ReMe
-
-安装 ReMe 并启动本地 HTTP 服务：
-
-```bash
-pip install "reme-ai[core]"
-reme start workspace_dir=/absolute/path/to/workspace
-```
-
-默认地址为 `http://127.0.0.1:2333`。ReMe HTTP 服务不使用 API Key 认证，因此除非前面部署了受保护的代理边界，
-否则应仅监听 loopback 或其他可信网络。
-
-## 安装 OpenClaw 插件
-
-明确指定从 ClawHub 安装：
-
-```bash
-openclaw plugins install clawhub:@agentscope-ai/reme
-```
-
-如果已经启用了其他记忆插件，请将 `plugins.slots.memory` 设为 `reme`。对话访问和 Prompt 注入权限仍由
-OpenClaw 管理；策略要求显式授权时，需要为 ReMe 开启相应权限。插件不会修改 Gateway 配置。
-
-## 配置
-
-| 配置项 | 默认值 | 作用 |
-| --------------------- | ----------------------- | ------------------------------------ |
-| `endpoint` | `http://127.0.0.1:2333` | ReMe HTTP 服务地址 |
-| `language` | `en` | 记忆指引语言：`en` 或 `zh` |
-| `autoRecall` | `true` | 在根 Agent 对话运行前自动召回 |
-| `searchLimit` | `5` | 搜索结果上限 |
-| `recallMinScore` | `0` | 自动召回的最低搜索分数 |
-| `autoMemoryEnabled` | `true` | 捕获已完成的对话 |
-| `autoMemoryInterval` | `5` | 每完成多少轮提交一次 |
-| `autoDreamEnabled` | `true` | 启用每日记忆整理 |
-| `dreamCron` | `0 23 * * *` | workspace 时区下的每日计划 |
-| `dreamHint` | 空字符串 | 传给 `auto_dream` 的可选指引 |
-| `rootAgentsOnly` | `true` | 不为子 Agent 注入指引或捕获对话 |
-| `timezone` | `Asia/Shanghai` | 每日批次和计划使用的 IANA 时区 |
-| `requestTimeoutMs` | `10000` | 自动召回和显式搜索超时 |
-| `backgroundTimeoutMs` | `3600000` | 自动记忆和 Auto Dream 超时 |
-| `shutdownTimeoutMs` | `5000` | Gateway 退出时尽力排空任务的时间预算 |
-
-配置修改会从后续运行开始生效。失败的自动记忆批次会保留等待重试，Gateway 退出时会在 `shutdownTimeoutMs` 范围内
-尝试刷新未完成任务。
-
-## 源码与许可证
-
-ReMe 在 [agentscope-ai/ReMe](https://github.com/agentscope-ai/ReMe) 开发，并使用 Apache-2.0 许可证发布。
diff --git a/typescript/figures/dsh/memory-context-injection.png b/typescript/figures/dsh/memory-context-injection.png
deleted file mode 100644
index c105deb9..00000000
Binary files a/typescript/figures/dsh/memory-context-injection.png and /dev/null differ
diff --git a/typescript/figures/dsh/memory-search-tool.png b/typescript/figures/dsh/memory-search-tool.png
deleted file mode 100644
index 42b8b114..00000000
Binary files a/typescript/figures/dsh/memory-search-tool.png and /dev/null differ
diff --git a/typescript/figures/dsh/reme-memory-settings.png b/typescript/figures/dsh/reme-memory-settings.png
deleted file mode 100644
index fceeeede..00000000
Binary files a/typescript/figures/dsh/reme-memory-settings.png and /dev/null differ
diff --git a/typescript/figures/dsh/reme-status-auto-dream.png b/typescript/figures/dsh/reme-status-auto-dream.png
deleted file mode 100644
index d9e197c8..00000000
Binary files a/typescript/figures/dsh/reme-status-auto-dream.png and /dev/null differ
diff --git a/typescript/figures/dsh/reme-status-auto-memory.png b/typescript/figures/dsh/reme-status-auto-memory.png
deleted file mode 100644
index 0ddb845f..00000000
Binary files a/typescript/figures/dsh/reme-status-auto-memory.png and /dev/null differ
diff --git a/typescript/figures/dsh/reme-status-components.png b/typescript/figures/dsh/reme-status-components.png
deleted file mode 100644
index 0ee26116..00000000
Binary files a/typescript/figures/dsh/reme-status-components.png and /dev/null differ
diff --git a/typescript/figures/dsh/reme-status-journal.png b/typescript/figures/dsh/reme-status-journal.png
deleted file mode 100644
index 2775ab79..00000000
Binary files a/typescript/figures/dsh/reme-status-journal.png and /dev/null differ
diff --git a/typescript/figures/dsh/reme-status-knowledge.png b/typescript/figures/dsh/reme-status-knowledge.png
deleted file mode 100644
index d219c852..00000000
Binary files a/typescript/figures/dsh/reme-status-knowledge.png and /dev/null differ
diff --git a/typescript/figures/dsh/reme-status-overview.png b/typescript/figures/dsh/reme-status-overview.png
deleted file mode 100644
index df0dcf7b..00000000
Binary files a/typescript/figures/dsh/reme-status-overview.png and /dev/null differ
diff --git a/typescript/scripts/pack-clawhub.mjs b/typescript/scripts/pack-clawhub.mjs
deleted file mode 100644
index 415fc063..00000000
--- a/typescript/scripts/pack-clawhub.mjs
+++ /dev/null
@@ -1,94 +0,0 @@
-import { execFile } from "node:child_process";
-import {
- copyFile,
- cp,
- mkdir,
- mkdtemp,
- readFile,
- rm,
- writeFile,
-} from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
-
-const execFileAsync = promisify(execFile);
-const packageDirectory = fileURLToPath(new URL("..", import.meta.url));
-const destinationDirectory = path.resolve(process.argv[2] ?? packageDirectory);
-const temporaryDirectory = await mkdtemp(
- path.join(tmpdir(), "reme-clawhub-pack-"),
-);
-const stagingDirectory = path.join(temporaryDirectory, "package");
-
-async function stageReadme(source, destination, oldLink, newLink) {
- const content = await readFile(path.join(packageDirectory, source), "utf8");
- await writeFile(
- path.join(stagingDirectory, destination),
- content.replace(oldLink, newLink),
- );
-}
-
-try {
- await mkdir(stagingDirectory, { recursive: true });
- await mkdir(destinationDirectory, { recursive: true });
-
- const packageManifest = JSON.parse(
- await readFile(path.join(packageDirectory, "package.json"), "utf8"),
- );
- delete packageManifest.scripts?.prepare;
-
- await Promise.all([
- cp(
- path.join(packageDirectory, "dist"),
- path.join(stagingDirectory, "dist"),
- {
- recursive: true,
- },
- ),
- cp(path.join(packageDirectory, "dsh"), path.join(stagingDirectory, "dsh"), {
- recursive: true,
- }),
- writeFile(
- path.join(stagingDirectory, "package.json"),
- `${JSON.stringify(packageManifest, null, 2)}\n`,
- ),
- copyFile(
- path.join(packageDirectory, "openclaw.plugin.json"),
- path.join(stagingDirectory, "openclaw.plugin.json"),
- ),
- stageReadme(
- "docs/openclaw.md",
- "README.md",
- "(./openclaw.zh-CN.md)",
- "(./README_ZH.md)",
- ),
- stageReadme(
- "docs/openclaw.zh-CN.md",
- "README_ZH.md",
- "(./openclaw.md)",
- "(./README.md)",
- ),
- ]);
-
- const { stdout } = await execFileAsync(
- "npm",
- [
- "pack",
- "--json",
- "--ignore-scripts",
- "--pack-destination",
- destinationDirectory,
- ],
- { cwd: stagingDirectory },
- );
- const [{ filename }] = JSON.parse(stdout);
- console.log(
- JSON.stringify({
- filename,
- tarball: path.join(destinationDirectory, filename),
- }),
- );
-} finally {
- await rm(temporaryDirectory, { force: true, recursive: true });
-}
diff --git a/typescript/scripts/test-package.mjs b/typescript/scripts/test-package.mjs
deleted file mode 100644
index c976241c..00000000
--- a/typescript/scripts/test-package.mjs
+++ /dev/null
@@ -1,122 +0,0 @@
-import { execFile } from "node:child_process";
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
-
-const execFileAsync = promisify(execFile);
-const packageDirectory = new URL("..", import.meta.url);
-const sourceManifest = JSON.parse(
- await readFile(new URL("../package.json", import.meta.url), "utf8"),
-);
-const temporaryDirectory = await mkdtemp(
- path.join(tmpdir(), "reme-package-smoke-"),
-);
-
-try {
- const packResult = await execFileAsync(
- "npm",
- [
- "pack",
- "--json",
- "--ignore-scripts",
- "--pack-destination",
- temporaryDirectory,
- ],
- { cwd: packageDirectory },
- );
- const [{ filename }] = JSON.parse(packResult.stdout);
- const tarball = path.join(temporaryDirectory, filename);
- const consumerEntry = path.join(temporaryDirectory, "consumer.mjs");
- await writeFile(
- path.join(temporaryDirectory, "package.json"),
- JSON.stringify({ private: true, type: "module" }),
- );
- await execFileAsync(
- "npm",
- ["install", "--ignore-scripts", "--no-audit", "--no-fund", tarball],
- { cwd: temporaryDirectory },
- );
- await writeFile(
- consumerEntry,
- [
- 'import assert from "node:assert/strict";',
- 'import { readFile } from "node:fs/promises";',
- 'import { ReMeClient, formatReMeContext } from "@agentscope-ai/reme";',
- 'assert.equal(typeof ReMeClient, "function");',
- 'assert.equal(typeof formatReMeContext, "function");',
- 'assert.ok(import.meta.resolve("@agentscope-ai/reme/openclaw").endsWith("/dist/openclaw/index.js"));',
- 'assert.match(import.meta.resolve("@agentscope-ai/reme/dsh"), /dist\\/dsh\\/index\\.js$/);',
- 'assert.match(import.meta.resolve("@agentscope-ai/reme/client"), /dist\\/dsh\\/client\\.js$/);',
- 'const manifestUrl = import.meta.resolve("@agentscope-ai/reme/package.json");',
- 'const manifest = JSON.parse(await readFile(new URL(manifestUrl), "utf8"));',
- `assert.equal(manifest.version, ${JSON.stringify(
- sourceManifest.version,
- )});`,
- 'assert.match(await readFile(new URL("README_ZH.md", manifestUrl), "utf8"), /TypeScript Agent/);',
- 'assert.match(await readFile(new URL("docs/dsh.md", manifestUrl), "utf8"), /Memory context injection/);',
- 'assert.match(await readFile(new URL("docs/openclaw.md", manifestUrl), "utf8"), /OpenClaw/);',
- 'assert.ok((await readFile(new URL("figures/dsh/reme-status-overview.png", manifestUrl))).length > 0);',
- ].join("\n"),
- );
- await execFileAsync("node", [consumerEntry], { cwd: temporaryDirectory });
-
- const clawHubOutputDirectory = path.join(temporaryDirectory, "clawhub-pack");
- await mkdir(clawHubOutputDirectory, { recursive: true });
- const packClawHubScript = fileURLToPath(
- new URL("./pack-clawhub.mjs", import.meta.url),
- );
- const clawHubPackResult = await execFileAsync(
- "node",
- [packClawHubScript, clawHubOutputDirectory],
- { cwd: packageDirectory },
- );
- const { tarball: clawHubTarball } = JSON.parse(clawHubPackResult.stdout);
- const clawHubConsumerDirectory = path.join(
- temporaryDirectory,
- "clawhub-consumer",
- );
- await mkdir(clawHubConsumerDirectory, { recursive: true });
- await writeFile(
- path.join(clawHubConsumerDirectory, "package.json"),
- JSON.stringify({ private: true, type: "module" }),
- );
- await execFileAsync(
- "npm",
- ["install", "--ignore-scripts", "--no-audit", "--no-fund", clawHubTarball],
- { cwd: clawHubConsumerDirectory },
- );
- const clawHubPackageDirectory = path.join(
- clawHubConsumerDirectory,
- "node_modules",
- "@agentscope-ai",
- "reme",
- );
- const clawHubReadme = await readFile(
- path.join(clawHubPackageDirectory, "README.md"),
- "utf8",
- );
- const clawHubReadmeZh = await readFile(
- path.join(clawHubPackageDirectory, "README_ZH.md"),
- "utf8",
- );
- assert.match(clawHubReadme, /^# ReMe memory for OpenClaw/m);
- assert.doesNotMatch(clawHubReadme, /DeepSeek Harness/);
- assert.match(clawHubReadme, /\[中文说明\]\(\.\/README_ZH\.md\)/);
- assert.match(clawHubReadmeZh, /^# OpenClaw 的 ReMe 长期记忆插件/m);
- assert.doesNotMatch(clawHubReadmeZh, /DeepSeek Harness/);
- assert.match(clawHubReadmeZh, /\[English\]\(\.\/README\.md\)/);
- assert.equal(
- JSON.parse(
- await readFile(
- path.join(clawHubPackageDirectory, "package.json"),
- "utf8",
- ),
- ).version,
- sourceManifest.version,
- );
-} finally {
- await rm(temporaryDirectory, { force: true, recursive: true });
-}
diff --git a/typescript/src/dsh/guidance.ts b/typescript/src/dsh/guidance.ts
deleted file mode 100644
index 19bd3f72..00000000
--- a/typescript/src/dsh/guidance.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import type { DshSession } from "./types.js";
-export { memoryGuidance } from "../core/guidance.js";
-
-export const REME_PLUGIN_SOURCE = "reme-memory";
-
-export function hasGuidance(
- session: DshSession,
- pendingMessages: readonly unknown[] = [],
-): boolean {
- return (
- (session.events || []).some(
- (event) => event.type === "user/message" && isGuidance(event.data),
- ) || pendingMessages.some(isGuidance)
- );
-}
-
-function isGuidance(value: unknown): boolean {
- const source = isRecord(value) ? value.source : undefined;
- return (
- isRecord(source) &&
- source.kind === "plugin" &&
- source.plugin === REME_PLUGIN_SOURCE &&
- source.form === "instructions"
- );
-}
-
-function isRecord(value: unknown): value is Record {
- return typeof value === "object" && value !== null;
-}
diff --git a/typescript/src/dsh/scheduler.ts b/typescript/src/dsh/scheduler.ts
deleted file mode 100644
index 930501ab..00000000
--- a/typescript/src/dsh/scheduler.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { nextDailyRun } from "../core/scheduling.js";
diff --git a/typescript/src/index.ts b/typescript/src/index.ts
deleted file mode 100644
index 1846d99b..00000000
--- a/typescript/src/index.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-export { ReMeClient } from "./core/client.js";
-export { formatReMeContext } from "./core/context.js";
-
-/** Empty Host face used to compose this package's DSH browser bundle. */
-export function apply(): void {}
-export type {
- AutoMemoryOptions,
- DreamOptions,
- LoggerLike,
- ReMeClientConfig,
- ReMeClientLike,
- ReMeComponentHealth,
- ReMeComponentMemory,
- ReMeHealth,
- ReMeHealthResult,
- ReMeMemoryStatus,
- ReMeMessage,
- ReMeResult,
- ReMeStatusResult,
- SearchOptions,
-} from "./core/types.js";
diff --git a/typescript/tests/bundle.test.mjs b/typescript/tests/bundle.test.mjs
deleted file mode 100644
index 7f1216e3..00000000
--- a/typescript/tests/bundle.test.mjs
+++ /dev/null
@@ -1,76 +0,0 @@
-import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
-import test from "node:test";
-
-test("declares DSH and OpenClaw entries in one installable package", async () => {
- const manifest = JSON.parse(
- await readFile(new URL("../package.json", import.meta.url), "utf8"),
- );
- const patch = await readFile(
- new URL("../dsh/cordis.patch.yml", import.meta.url),
- "utf8",
- );
- const openClawManifest = JSON.parse(
- await readFile(new URL("../openclaw.plugin.json", import.meta.url), "utf8"),
- );
- assert.equal(manifest.name, "@agentscope-ai/reme");
- assert.equal(manifest.exports["./dsh"].import, "./dist/dsh/index.js");
- assert.equal(
- manifest.exports["./openclaw"].import,
- "./dist/openclaw/index.js",
- );
- assert.equal(manifest.exports["./client"].default, "./dist/dsh/client.js");
- assert.equal(manifest.exports["./package.json"], "./package.json");
- assert.equal(manifest.dsh.client.platform, "web");
- assert.ok(
- manifest.dsh.client.inject.includes(
- "@deepseek-ai/dsh-client-ui-settings-plugins",
- ),
- );
- assert.ok(
- manifest.dsh.client.inject.includes(
- "@deepseek-ai/dsh-client-ui-primitives",
- ),
- );
- assert.ok(
- manifest.dsh.client.inject.includes("@deepseek-ai/dsh-client-connection"),
- );
- assert.ok(
- !manifest.dsh.client.inject.includes("@deepseek-ai/dsh-client-runtime"),
- );
- assert.equal(manifest.dsh.bundle.patch, "./dsh/cordis.patch.yml");
- assert.deepEqual(manifest.openclaw.extensions, ["./dist/openclaw/index.js"]);
- assert.equal(
- manifest.peerDependencies["@deepseek-ai/dsh-llm"],
- "^0.1.2-rc.1",
- );
- assert.equal(
- manifest.peerDependencies["@deepseek-ai/dsh-tools"],
- "^0.1.2-rc.1",
- );
- assert.match(patch, /remeMemory: true/);
- assert.match(patch, /@agentscope-ai\/reme\/dsh/);
- assert.match(patch, /name: ["']@agentscope-ai\/reme["']$/m);
- assert.equal(openClawManifest.id, "reme");
- assert.equal(openClawManifest.kind, "memory");
-});
-
-test("builds a lazy DSH browser module for the ReMe settings card", async () => {
- const bundle = await readFile(
- new URL("../dist/dsh/client.js", import.meta.url),
- "utf8",
- );
- const statusPage = await readFile(
- new URL("../src/dsh/client/status-page.tsx", import.meta.url),
- "utf8",
- );
- assert.match(bundle, /window\.__ModuleLoader__\.load/);
- assert.match(bundle, /id: "@agentscope-ai\/reme"/);
- assert.match(bundle, /settings\.plugin\.item/);
- assert.match(bundle, /settings\.section/);
- assert.match(bundle, /reme-status/);
- assert.match(bundle, /Personal Knowledge Base/);
- assert.match(statusPage, /个人知识库/);
- assert.match(bundle, /health_check/);
- assert.match(bundle, /reme-settings-component-grid/);
-});