dsh-tdai-memory 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,56 @@
+# dsh-tdai-memory
+
+把 **TencentDB Agent Memory**（腾讯云开源的四层记忆系统，原为 OpenClaw 插件）移植进 DeepSeek Harness。
+
+## 能力
+
+- **L0 对话捕获**：每轮对话（turn 结束、请求边界）自动写入原始对话（JSONL + SQLite + FTS + 向量）
+- **L1 结构化记忆**：后台管线用 LLM 从对话中提取事实/偏好/事件（persona / episodic / instruction），写入 `records/` + SQLite + FTS + 向量
+- **L2 场景 / L3 画像**：场景块与用户画像生成（管线自动调度）
+- **自动召回注入**：每次组装提示词时，按当前用户消息检索相关记忆 + 画像，作为动态上下文注入（模型"凭空想起"）
+- **工具**：`tdai_memory_search`（L1 结构化检索）、`tdai_conversation_search`（L0 原文检索）
+
+数据目录复用现有 `~/.memory-tencentdb/memory-tdai`，**旧记忆无缝继承**。
+
+## 架构（移植方式）
+
+| 层 | 内容 |
+|---|---|
+| 核心 | `tdai-memory-openclaw-plugin` 的 host-neutral 核心（`src/core`、`src/utils`），tsc 编译为 ESM（`dist-dsh/`），零改动 |
+| 宿主适配 | `StandaloneHostAdapter`（官方 standalone 模式，OpenAI 兼容直调） |
+| dsh 壳 | `index.js`：配置映射、`session/event`+`session/flush` 捕获、`agent.ctx` 上的 `system-prompt/assemble` waterfall 召回注入、工具注册、生命周期 |
+| 备用 | `recall-inject.js`：preset 行形态的召回注入（挂在 agent preset 内时用） |
+
+关键接线（都是踩坑换来的）：
+
+- **捕获**：`session/flush` 监听器（await 语义，headless 退出前必完成）；`turn/start` 时间戳做 L0 cursor 下限；turn id 去重
+- **headless 一次性任务**：flush 内再等 `core.handleSessionEnd()`（L1 提取跑完才退出；否则 5s 关闭超时会杀掉提取）
+- **召回注入**：必须注册在 **`agent.ctx`** 上（组装在 agent 作用域进行，root 监听器收不到）；`session/created` 后延迟一 tick 从 `agents` 服务拿 agent
+
+## 配置（profile patch）
+
+```yaml
+- id: tdai-memory
+  name: './plugins/dsh-tdai-memory/index.js'
+  config:
+    extraction:
+      enabled: true
+      enableDedup: false      # dedup 的 LLM 输出解析不稳，先关
+    llm:                      # L1/L2/L3 提取模型（OpenAI 兼容）
+      baseUrl: 'https://opencode.ai/zen/go/v1'
+      apiKey: 'sk-...'
+      model: 'mimo-v2.5'      # deepseek-v4-flash 对提取 JSON 输出不合格
+    embedding:                # 向量（OpenAI 兼容 /v1/embeddings）
+      baseUrl: 'http://127.0.0.1:8088/v1'
+      apiKey: 'local-no-key'  # parseConfig 强制 apiKey 非空，本地端点可占位
+      model: 'Qwen3-Embedding-0.6B'
+      dimensions: 1024
+      sendDimensions: false
+```
+
+## 已知取舍
+
+- **提取模型**：`mimo-v2.5` 提取正确但单次 20-30s（后台执行，不阻塞对话）；`deepseek-v4-flash` 快但 JSON 输出不合规（提取 0 条）
+- **dedup**：LLM 冲突检测输出解析不稳（曾导致 stored=0），默认关闭；开启需换更稳的模型
+- **L1 记忆向量**：随存储写入（8088 embedding 快）；L0 向量走后台任务，headless 退出时由 `destroy()` drain
+- **升级**：上游拉新代码后，在 tdai 项目目录重跑 `npx tsc -p dsh-tsconfig.json`（产物在 `dist-dsh/`）

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,20 @@
+# Third-party notices
+
+## TencentDB Agent Memory core (vendored in `vendor/tdai`)
+
+`vendor/tdai` is a TypeScript-compiled copy of the host-neutral core of
+[TencentCloud/TencentDB-Agent-Memory](https://github.com/TencentCloud/TencentDB-Agent-Memory)
+(`tdai-memory-openclaw-plugin`, npm: `@tencentdb-agent-memory/memory-tencentdb`),
+compiled with `tsc -p dsh-tsconfig.json` (see the upstream repo for source).
+Its runtime dependencies are declared in this package's `dependencies`.
+
+MIT License — Copyright (c) 2026 TencentCloud
+
+## Runtime dependencies
+
+- `ai` / `@ai-sdk/openai` — Vercel AI SDK (Apache-2.0)
+- `@node-rs/jieba` — Rust jieba bindings (MIT)
+- `sqlite-vec` — vector search extension for SQLite (Apache-2.0 / MIT)
+- `json5` — JSON5 parser (MIT)
+- `undici` — HTTP client (MIT)
+- `@tencentdb-agent-memory/tcvdb-text` — TencentDB text utilities (MIT)

package/index.js

@@ -0,0 +1,328 @@
+/**
+ * dsh-tdai-memory — TencentDB Agent Memory ported into DeepSeek Harness.
+ *
+ * Reuses the host-neutral core of `tdai-memory-openclaw-plugin`
+ * (TdaiCore: L0 conversation capture -> L1 structured facts -> L2 scenes ->
+ * L3 persona; vector recall; memory/conversation search) through a thin
+ * DshHostAdapter. The existing data directory (~/.memory-tencentdb/memory-tdai)
+ * is reused as-is, so previously accumulated memories stay available.
+ *
+ * Wiring:
+ *  - `session/event` (turn/start, turn/end) -> L0 capture + pipeline trigger
+ *  - `system-prompt/assemble` waterfall -> per-turn recall injection
+ *    (relevant L1 memories + L3 persona + L2 scene navigation)
+ *  - tools `tdai_memory_search` / `tdai_conversation_search`
+ *  - LLM calls (L1/L2/L3 extraction) go through the standalone OpenAI-
+ *    compatible runner (config `llm`, falls back to TDAI_LLM_* env vars)
+ *  - embeddings through the configurable OpenAI-compatible endpoint
+ *    (defaults to the local Qwen3-Embedding-0.6B service on :8088)
+ */
+import os from "node:os";
+import { join } from "node:path";
+import z from "@deepseek-ai/schemastery";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { TdaiCore } from "./vendor/tdai/core/tdai-core.js";
+import { parseConfig } from "./vendor/tdai/config.js";
+import { StandaloneHostAdapter } from "./vendor/tdai/adapters/standalone/host-adapter.js";
+
+/** Cordis plugin name. */
+const name = "tdai-memory";
+/** Services this row injects. */
+const inject = ["sessions", "systemPrompt", "tools"];
+
+/** Runtime schema for the tdai-memory row. */
+const Config = z.object({
+  /** TDAI data directory; default: ~/.memory-tencentdb/memory-tdai. */
+  dataDir: z.string().default(""),
+  /** LLM used for L1/L2/L3 extraction (OpenAI-compatible). Falls back to TDAI_LLM_* env. */
+  llm: z.object({
+    baseUrl: z.string().default(""),
+    apiKey: z.string().default(""),
+    model: z.string().default(""),
+    maxTokens: z.number().default(4096),
+    timeoutMs: z.number().default(120000),
+  }),
+  /** Embedding endpoint (OpenAI-compatible /v1/embeddings). */
+  embedding: z.object({
+    baseUrl: z.string().default("http://127.0.0.1:8088/v1"),
+    apiKey: z.string().default(""),
+    model: z.string().default("Qwen3-Embedding-0.6B"),
+    dimensions: z.number().default(1024),
+    sendDimensions: z.boolean().default(false),
+  }),
+  /** Capture conversations into L0. */
+  captureEnabled: z.boolean().default(true),
+  /** L1 extraction pipeline (facts from conversations). */
+  extraction: z.object({
+    enabled: z.boolean().default(true),
+    /** Conflict detection before storing; extra LLM call, disable if flaky. */
+    enableDedup: z.boolean().default(true),
+  }),
+  /** Recall injection settings. */
+  recall: z.object({
+    enabled: z.boolean().default(true),
+    maxResults: z.number().default(5),
+    scoreThreshold: z.number().default(0.3),
+    timeoutMs: z.number().default(3000),
+  }),
+  /** Register the two search tools. */
+  toolsEnabled: z.boolean().default(true),
+});
+
+/** Extract plain text from a dsh message content (block array or string). */
+function extractText(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((b) => b && b.type === "text" && typeof b.text === "string")
+    .map((b) => b.text)
+    .join("\n")
+    .trim();
+}
+
+function apply(ctx, config) {
+  const dataDir = config.dataDir || join(os.homedir(), ".memory-tencentdb", "memory-tdai");
+
+  const tdaiConfig = parseConfig({
+    timezone: "system",
+    storeBackend: "sqlite",
+    capture: { enabled: config.captureEnabled },
+    extraction: { enabled: config.extraction.enabled, enableDedup: config.extraction.enableDedup },
+    recall: { ...config.recall },
+    embedding: {
+      enabled: true,
+      provider: "openai",
+      baseUrl: config.embedding.baseUrl,
+      apiKey: config.embedding.apiKey,
+      model: config.embedding.model,
+      dimensions: config.embedding.dimensions,
+      sendDimensions: config.embedding.sendDimensions,
+      timeoutMs: 10000,
+    },
+    llm: {
+      enabled: true,
+      baseUrl: config.llm.baseUrl || process.env.TDAI_LLM_BASE_URL || "",
+      apiKey: config.llm.apiKey || process.env.TDAI_LLM_API_KEY || "",
+      model: config.llm.model || process.env.TDAI_LLM_MODEL || "deepseek-v4-flash",
+      maxTokens: config.llm.maxTokens,
+      timeoutMs: config.llm.timeoutMs,
+    },
+  });
+
+  // Verbose tdai-internal logging goes to the console only when explicitly
+  // enabled; routine diagnostics use the dsh logger.
+  const verbose = !!process.env.DSH_TDAI_DEBUG;
+  const log = (level, m) => {
+    if (verbose) console.error(`[tdai-memory] ${m}`);
+    else if (level === "warn") ctx.logger.warn(`[tdai-memory] ${m}`);
+    else if (level === "error") ctx.logger.error(`[tdai-memory] ${m}`);
+  };
+  const logger = {
+    debug: (m) => log("debug", m),
+    info: (m) => log("info", m),
+    warn: (m) => log("warn", m),
+    error: (m) => log("error", m),
+  };
+
+  const hostAdapter = new StandaloneHostAdapter({
+    dataDir,
+    llmConfig: {
+      baseUrl: tdaiConfig.llm.baseUrl,
+      apiKey: tdaiConfig.llm.apiKey,
+      model: tdaiConfig.llm.model,
+      maxTokens: tdaiConfig.llm.maxTokens,
+      timeoutMs: tdaiConfig.llm.timeoutMs,
+    },
+    logger,
+    defaultUserId: "dsh-user",
+    platform: "dsh",
+  });
+
+  const core = new TdaiCore({ hostAdapter, config: tdaiConfig, instanceId: "dsh" });
+
+  /** turn id of the last turn/end per session (capture trigger). */
+  const lastTurnEnd = new Map();
+  /** turn ids already captured per session (dedup across flushes). */
+  const capturedTurns = new Map();
+  /** turn/start timestamp per session (L0 capture cursor floor). */
+  const turnStarts = new Map();
+  /** session keys seen this process (for final L1 flush on teardown). */
+  const seenSessions = new Set();
+  /** recall cache per session: same user text within TTL reuses the result. */
+  const recallCache = new Map();
+  const RECALL_CACHE_TTL_MS = 30_000;
+
+  // One-shot mode (dsh --profile headless): the process exits right after
+  // flush, so L1 must finish inside the flush listener. In web mode the
+  // long-lived process runs the pipeline in the background instead.
+  const isOneShot = process.argv.some((arg) => arg === "headless");
+
+  // ── capture: triggered on session/flush (awaitable; runs before process
+  //    exit in headless, and at every request boundary in web) ─────────────
+  ctx.on("session/event", (session, event) => {
+    if (event.type === "turn/start") {
+      turnStarts.set(session.id, event.time);
+    } else if (event.type === "turn/end") {
+      lastTurnEnd.set(session.id, event.data.turn);
+    }
+  });
+
+  ctx.on("session/flush", async (session) => {
+    try {
+      const turnId = lastTurnEnd.get(session.id);
+      if (turnId === undefined || capturedTurns.get(session.id) === turnId) return;
+      capturedTurns.set(session.id, turnId);
+      seenSessions.add(session.id);
+      const startedAt = turnStarts.get(session.id) ?? Date.now();
+      await captureTurn(session, startedAt);
+      if (isOneShot) {
+        // Run pending L1 extraction to completion before the process exits.
+        await core.handleSessionEnd(session.id).catch((error) => {
+          ctx.logger.warn(`[tdai-memory] L1 flush failed: ${String(error)}`);
+        });
+      }
+    } catch (error) {
+      ctx.logger.warn(`[tdai-memory] capture failed: ${String(error)}`);
+    }
+  });
+
+  async function captureTurn(session, startedAt) {
+    if (!tdaiConfig.capture.enabled) return;
+    const derived = session.deriveMessages();
+    const lastUserIdx = derived.map((m) => m.role).lastIndexOf("user");
+    if (lastUserIdx < 0) return;
+    const messages = derived
+      .slice(lastUserIdx)
+      .map((m) => {
+        const text = extractText(m.content);
+        if (!text) return null;
+        return {
+          id: m.id ?? `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+          role: m.role === "assistant" ? "assistant" : "user",
+          content: text,
+          timestamp: Date.now(),
+        };
+      })
+      .filter(Boolean);
+    if (messages.length === 0) return;
+    const lastUser = [...messages].reverse().find((m) => m.role === "user");
+    const result = await core.handleTurnCommitted({
+      userText: lastUser?.content ?? "",
+      assistantText: "",
+      messages,
+      sessionKey: session.id,
+      startedAt,
+    });
+    ctx.logger.debug(`[tdai-memory] captured turn: l0=${result.l0RecordedCount} notified=${result.schedulerNotified} vectors=${result.l0VectorsWritten}`);
+  }
+
+  // ── recall injection ────────────────────────────────────────────────────
+  // The prompt assembly runs inside the agent's own context (scope = agent),
+  // so the waterfall listener must be registered on `agent.ctx` — root-level
+  // listeners never see agent-scoped assemblies. Agents appear right after
+  // their session is announced, so defer one tick and attach there.
+  ctx.on("session/created", (session) => {
+    setTimeout(() => {
+      try {
+        const agents = ctx.get("agents");
+        const agent = agents?.get?.(session.id);
+        if (!agent?.ctx) return;
+        agent.ctx.on("system-prompt/assemble", async (assembly, context) => {
+          try {
+            if (!tdaiConfig.recall.enabled) return assembly;
+            const lastUser = [...session.deriveMessages()].reverse().find((m) => m.role === "user");
+            if (!lastUser) return assembly;
+            const text = extractText(lastUser.content);
+            if (!text) return assembly;
+            const now = Date.now();
+            const cached = recallCache.get(session.id);
+            if (cached && cached.text === text && now - cached.ts < RECALL_CACHE_TTL_MS) {
+              return injectRecall(assembly, cached.result);
+            }
+            const result = await Promise.race([
+              core.handleBeforeRecall(text, session.id),
+              new Promise((resolve) => setTimeout(() => resolve(null), tdaiConfig.recall.timeoutMs + 1000)),
+            ]).catch(() => null);
+            recallCache.set(session.id, { text, result: result ?? {}, ts: now });
+            return injectRecall(assembly, result ?? {});
+          } catch (error) {
+            ctx.logger.warn(`[tdai-memory] recall failed: ${String(error)}`);
+            return assembly;
+          }
+        });
+      } catch (error) {
+        ctx.logger.warn(`[tdai-memory] recall attach failed: ${String(error)}`);
+      }
+    }, 0);
+  });
+
+  function injectRecall(assembly, result) {
+    const extras = [];
+    if (result.prependContext) extras.push({ name: "tdai:recall", order: 1000, text: result.prependContext });
+    if (result.appendSystemContext) extras.push({ name: "tdai:profile", order: 1001, text: result.appendSystemContext });
+    if (extras.length === 0) return assembly;
+    return { ...assembly, contexts: [...assembly.contexts, ...extras] };
+  }
+
+  // ── tools ────────────────────────────────────────────────────────────────
+  if (config.toolsEnabled) {
+    ctx.tools.register(defineTool({
+      name: "tdai_memory_search",
+      description:
+        "Search structured long-term memories (facts, preferences, and experiences extracted from past conversations). " +
+        "Use this to recall what the user told you or what happened in earlier sessions.",
+      parameters: {
+        query: { type: "string", required: true, description: "The memory to search for." },
+        limit: { type: "integer", description: "Maximum results (default 5)." },
+      },
+      output: {
+        schema: { type: "string" },
+        render: (_args, value) => [{ type: "text", text: value }],
+      },
+      async execute(args) {
+        const result = await core.searchMemories({ query: args.query, limit: args.limit ?? 5 });
+        return result.text;
+      },
+    }));
+    ctx.tools.register(defineTool({
+      name: "tdai_conversation_search",
+      description:
+        "Search raw past conversation logs (L0) by keyword. Use this to look up exact quotes or details " +
+        "that structured memory search does not cover.",
+      parameters: {
+        query: { type: "string", required: true, description: "Text to find in past conversations." },
+        limit: { type: "integer", description: "Maximum results (default 5)." },
+      },
+      output: {
+        schema: { type: "string" },
+        render: (_args, value) => [{ type: "text", text: value }],
+      },
+      async execute(args) {
+        const result = await core.searchConversations({ query: args.query, limit: args.limit ?? 5 });
+        return result.text;
+      },
+    }));
+  }
+
+  // ── lifecycle ────────────────────────────────────────────────────────────
+  ctx.effect(async () => {
+    await core.initialize();
+    ctx.logger.info(`[tdai-memory] initialized (dataDir=${dataDir}, llm=${tdaiConfig.llm.model}, embedding=${tdaiConfig.embedding.model})`);
+    return async () => {
+      // Final flush: run pending L1 extraction for every session seen this
+      // process and wait for it to finish (headless exits right after the
+      // tree disposes, so this is what makes extraction complete in one-shot
+      // runs). Unknown keys are tolerated as no-ops.
+      for (const sessionKey of seenSessions) {
+        await core.handleSessionEnd(sessionKey).catch((error) => {
+          ctx.logger.warn(`[tdai-memory] final L1 flush failed for ${sessionKey}: ${String(error)}`);
+        });
+      }
+      await core.destroy().catch((error) => {
+        ctx.logger.warn(`[tdai-memory] destroy failed: ${String(error)}`);
+      });
+    };
+  }, "tdai-memory.initialize()");
+}
+
+export { Config, apply, inject, name };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "dsh-tdai-memory",
+  "version": "0.1.0",
+  "description": "TencentDB Agent Memory for DeepSeek Harness: L0 conversation capture, L1 structured memory extraction, L2 scenes / L3 persona, automatic recall injection, and memory search tools. Uses the existing ~/.memory-tencentdb/memory-tdai data directory.",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "recall-inject.js",
+    "vendor",
+    "README.md",
+    "README.zh.md",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.md"
+  ],
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "memory",
+    "tencentdb",
+    "agent-memory",
+    "rag",
+    "vector-search",
+    "persona"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Scorp1o117/dsh-tdai-memory.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Scorp1o117/dsh-tdai-memory/issues"
+  },
+  "dependencies": {
+    "@ai-sdk/openai": "^3.0.53",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@node-rs/jieba": "^2.0.1",
+    "@tencentdb-agent-memory/tcvdb-text": "^0.1.1",
+    "ai": "^6.0.164",
+    "json5": "^2.2.3",
+    "sqlite-vec": "0.1.7-alpha.2",
+    "undici": "^8.1.0"
+  }
+}
+

package/recall-inject.js

@@ -0,0 +1,80 @@
+/**
+ * tdai-recall-inject — agent-plane recall injection row for dsh-tdai-memory.
+ *
+ * Mounted INSIDE an agent preset (agent.cordis.yml), this row listens on the
+ * `system-prompt/assemble` waterfall in the preset's scope, so it runs for
+ * every assembly of every agent joined to that preset (agent -> preset scope
+ * chain). It asks the `tdaiMemory` service (provided by the root-level
+ * dsh-tdai-memory plugin) for relevant long-term memories and appends them
+ * as dynamic context sections (user-role snapshots):
+ *
+ *   - tdai:recall  — relevant L1 memories for the current user message
+ *   - tdai:profile — stable persona / scene navigation context
+ *
+ * The recall call is bounded by `recall.timeoutMs`; failures degrade to no
+ * injection and never break the assembly.
+ */
+import z from "@deepseek-ai/schemastery";
+
+/** Cordis plugin name. */
+const name = "tdai-recall-inject";
+/** Services consumed: the prompt registry and the memory core service. */
+const inject = ["systemPrompt", "tdaiMemory"];
+
+/** Runtime schema for the recall-inject row. */
+const Config = z.object({
+  /** Skip recall when the user message is shorter than this. */
+  minUserTextChars: z.number().default(1),
+  /** Per-session cache TTL for identical user text (ms). */
+  cacheTtlMs: z.number().default(30_000),
+});
+
+function apply(ctx, config) {
+  const cache = new Map();
+
+  ctx.on("system-prompt/assemble", async (assembly, context) => {
+    try {
+      const agent = context?.agent;
+      if (!agent) return assembly;
+      const session = agent.session;
+      if (!session) return assembly;
+      const lastUser = [...session.deriveMessages()].reverse().find((m) => m.role === "user");
+      if (!lastUser) return assembly;
+      const text = extractText(lastUser.content);
+      if (!text || text.length < config.minUserTextChars) return assembly;
+
+      const now = Date.now();
+      const cached = cache.get(session.id);
+      if (cached && cached.text === text && now - cached.ts < config.cacheTtlMs) {
+        return injectRecall(assembly, cached.result);
+      }
+      const result = await ctx.tdaiMemory
+        .handleBeforeRecall(text, session.id)
+        .catch(() => null);
+      cache.set(session.id, { text, result: result ?? {}, ts: now });
+      return injectRecall(assembly, result ?? {});
+    } catch {
+      return assembly;
+    }
+  });
+}
+
+function extractText(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((b) => b && b.type === "text" && typeof b.text === "string")
+    .map((b) => b.text)
+    .join("\n")
+    .trim();
+}
+
+function injectRecall(assembly, result) {
+  const extras = [];
+  if (result.prependContext) extras.push({ name: "tdai:recall", order: 1000, text: result.prependContext });
+  if (result.appendSystemContext) extras.push({ name: "tdai:profile", order: 1001, text: result.appendSystemContext });
+  if (extras.length === 0) return assembly;
+  return { ...assembly, contexts: [...assembly.contexts, ...extras] };
+}
+
+export { Config, apply, inject, name };

package/vendor/tdai/adapters/index.js

@@ -0,0 +1,15 @@
+/**
+ * TDAI Adapters — barrel re-export for all host adapter implementations.
+ *
+ * Each adapter translates a specific host environment's API into
+ * the host-neutral HostAdapter interface consumed by TdaiCore.
+ *
+ * Directory structure:
+ *   adapters/
+ *   ├── openclaw/      — OpenClaw plugin host (in-process, runEmbeddedPiAgent)
+ *   └── standalone/    — Gateway / Hermes sidecar (HTTP, OpenAI-compatible API)
+ */
+// OpenClaw adapter
+export { OpenClawHostAdapter, OpenClawLLMRunner, OpenClawLLMRunnerFactory } from "./openclaw/index.js";
+// Standalone adapter
+export { StandaloneHostAdapter, StandaloneLLMRunner, StandaloneLLMRunnerFactory } from "./standalone/index.js";

package/vendor/tdai/adapters/openclaw/host-adapter.js

@@ -0,0 +1,83 @@
+/**
+ * OpenClawHostAdapter — translates OpenClaw's plugin API into TDAI Core's
+ * unified HostAdapter interface.
+ *
+ * This is the "thin shell" that keeps OpenClaw-specific dependencies
+ * (OpenClawPluginApi, pluginConfig, resolveStateDir, event system)
+ * confined to the adapter layer while TDAI Core remains host-neutral.
+ *
+ * Usage (in index.ts):
+ *   const adapter = new OpenClawHostAdapter({ api, pluginDataDir, config });
+ *   const core = new TdaiCore({ hostAdapter: adapter, config: parsedConfig });
+ */
+import { OpenClawLLMRunnerFactory } from "./llm-runner.js";
+// ============================
+// OpenClawHostAdapter
+// ============================
+export class OpenClawHostAdapter {
+    hostType = "openclaw";
+    api;
+    pluginDataDir;
+    openclawConfig;
+    runnerFactory;
+    constructor(opts) {
+        this.api = opts.api;
+        this.pluginDataDir = opts.pluginDataDir;
+        this.openclawConfig = opts.openclawConfig;
+        this.runnerFactory = new OpenClawLLMRunnerFactory({
+            config: opts.openclawConfig,
+            agentRuntime: opts.api.runtime.agent,
+            logger: opts.api.logger,
+        });
+    }
+    /**
+     * Build a RuntimeContext from the current OpenClaw session.
+     *
+     * In OpenClaw, sessionKey and sessionId come from the event/ctx objects
+     * passed to hooks. This method returns a context with sensible defaults;
+     * callers can override sessionKey/sessionId per-hook invocation using
+     * `buildRuntimeContextForSession()`.
+     */
+    getRuntimeContext() {
+        return {
+            userId: "default_user",
+            sessionId: "",
+            sessionKey: "",
+            platform: "openclaw",
+            workspaceDir: process.cwd(),
+            dataDir: this.pluginDataDir,
+        };
+    }
+    /**
+     * Build a RuntimeContext for a specific session (used per-hook).
+     *
+     * This is an OpenClaw-specific convenience that merges session-level
+     * identifiers from hook ctx into the base context.
+     */
+    buildRuntimeContextForSession(sessionKey, sessionId) {
+        return {
+            ...this.getRuntimeContext(),
+            sessionKey,
+            sessionId: sessionId ?? "",
+        };
+    }
+    getLogger() {
+        return this.api.logger;
+    }
+    getLLMRunnerFactory() {
+        return this.runnerFactory;
+    }
+    // -- OpenClaw-specific accessors (for index.ts bridge) --------------------
+    /** Get the raw OpenClaw plugin API (for legacy callers during migration). */
+    getPluginApi() {
+        return this.api;
+    }
+    /** Get the OpenClaw config object (for legacy callers during migration). */
+    getOpenClawConfig() {
+        return this.openclawConfig;
+    }
+    /** Get the resolved plugin data directory. */
+    getPluginDataDir() {
+        return this.pluginDataDir;
+    }
+}

package/vendor/tdai/adapters/openclaw/index.js

@@ -0,0 +1,5 @@
+/**
+ * OpenClaw adapter — barrel exports.
+ */
+export { OpenClawHostAdapter } from "./host-adapter.js";
+export { OpenClawLLMRunner, OpenClawLLMRunnerFactory } from "./llm-runner.js";