dsh-deja 0.18.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vladislav Shulcz
+
+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,65 @@
+# dsh-deja
+
+English | [中文](README.zh.md)
+
+DeepSeek Harness can already search its own sessions — that is what the built-in
+`session-query` subsystem does. This plugin answers the other question: what you
+did in the *other* agents on this machine.
+
+deja indexes the session files that Claude Code, Codex, Cursor, opencode,
+Antigravity, Grok Build, Kimi, Cline, Zed and ten more agents already write to
+disk. Nothing has to have been recorded ahead of time: the history is already
+there, including the months before deja was installed. If you moved to dsh last
+week, everything you did before last week is still reachable from inside it.
+
+## Install
+
+```sh
+dsh plugin --profile web add dsh-deja
+```
+
+The plugin runs the `deja` binary. It is pulled in as a dependency, so npm
+installs it with the plugin; a `deja` already on `PATH` is used as-is, and
+`DEJA_BIN` overrides both.
+
+## What it adds
+
+Three tools the model can call:
+
+| Tool | Answers |
+|---|---|
+| `deja_recall` | Sessions matching an error string, function name, file path or flag. |
+| `deja_session` | The full digest of one past session, when the reasoning behind it matters. |
+| `deja_blame` | The sessions that discussed a file, before you edit or delete it. |
+
+One command: `/deja <what to look for>`.
+
+And, unless you turn it off, automatic recall: before each step the plugin asks
+deja whether this machine's history answers the prompt, and adds the answer to
+the runtime context. Silence is the common case — it speaks only when there is
+something to say.
+
+```yaml
+- insert:
+    - id: deja
+      name: dsh-deja
+      config:
+        autoRecall: false   # tools and /deja only
+```
+
+## How it is wired
+
+Recall arrives through `ctx.systemPrompt.context`, evaluated on every assembly.
+The obvious alternative — a middleware on `agent/pre-step` that splices a
+message into the step — loads fine, completes the turn, and never reaches the
+model: a later listener in that waterfall rebuilds its answer from the payload
+and the added message is dropped with nothing reported. This was settled by
+reading the requests dsh 0.1.1-rc.2 actually sent.
+
+## What it does not do
+
+No LLM, no embeddings, no network. The index is a local BM25 store over files
+that already exist, so a query answers in about a millisecond and nothing leaves
+the machine. Secrets are redacted at index time.
+
+Part of [deja-vu](https://github.com/vshulcz/deja-vu). MIT.

package/README.zh.md

@@ -0,0 +1,47 @@
+# dsh-deja
+
+[English](README.md) | 中文
+
+DeepSeek Harness 自带的 `session-query` 已经可以检索它自己的会话。这个插件回答的是另一个问题：你在这台机器上**其他**智能体里做过什么。
+
+deja 索引 Claude Code、Codex、Cursor、opencode、Antigravity、Grok Build、Kimi、Cline、Zed 等二十个智能体本来就写在磁盘上的会话文件。不需要提前录制：历史已经在那里，包括安装 deja 之前的那些月份。如果你上周才转到 dsh，上周之前做过的事仍然可以在 dsh 里查到。
+
+## 安装
+
+```sh
+dsh plugin --profile web add dsh-deja
+```
+
+插件调用 `deja` 可执行文件。它作为依赖随插件一起安装；如果 `PATH` 上已有 `deja` 就直接使用，`DEJA_BIN` 可覆盖两者。
+
+## 提供的能力
+
+三个模型可调用的工具：
+
+| 工具 | 回答什么 |
+|---|---|
+| `deja_recall` | 匹配报错文本、函数名、文件路径或命令行参数的历史会话。 |
+| `deja_session` | 单个历史会话的完整摘要，用于需要当时的判断依据时。 |
+| `deja_blame` | 在修改或删除某个文件之前，讨论过这个文件的历史会话。 |
+
+一个命令：`/deja <要查什么>`。
+
+以及默认开启的自动召回：每一步之前，插件会问 deja 这台机器的历史能否回答当前提问，并把结果加入运行时上下文。多数情况下它保持沉默，只有确实有内容时才开口。
+
+```yaml
+- insert:
+    - id: deja
+      name: dsh-deja
+      config:
+        autoRecall: false   # 只保留工具和 /deja
+```
+
+## 接入方式
+
+召回通过 `ctx.systemPrompt.context` 注入，该回调在每次 assembly 时求值。另一种看起来可行的做法——在 `agent/pre-step` 中间件里往这一步的消息列表里插入一条消息——插件能加载、回合也能正常结束，但内容到不了模型：该 waterfall 中后续的监听器会基于 payload 重建返回值，插入的消息被丢弃且没有任何报错。这一点是通过读取 dsh 0.1.1-rc.2 实际发出的请求确认的。
+
+## 不做什么
+
+不用大模型，不用向量嵌入，不联网。索引是本地 BM25，建立在本来就存在的文件之上，一次查询约一毫秒，数据不离开本机。密钥在建立索引时被脱敏。
+
+属于 [deja-vu](https://github.com/vshulcz/deja-vu) 项目。MIT 许可。

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: deja
+      name: dsh-deja

package/index.js

@@ -0,0 +1,216 @@
+// dsh-deja — the history you already have, inside DeepSeek Harness.
+//
+// dsh answers questions about its own sessions through the built-in
+// session-query subsystem. This plugin answers the other question: what you did
+// in Claude Code, Codex, Cursor, opencode and sixteen more agents, on this
+// machine, before dsh existed. The index is deja's; this file is the seam.
+
+import { createRequire } from "node:module";
+import { execFileSync } from "node:child_process";
+
+const require = createRequire(import.meta.url);
+
+// The tool registry lives in the host, not here. A plugin that throws on a
+// missing peer takes the whole profile down with it, so both imports degrade:
+// without them the command and automatic recall still work, only the
+// model-facing tools are skipped.
+let defineTool = null;
+let z = null;
+let createUserMessage = null;
+try {
+  ({ defineTool } = await import("@deepseek-ai/dsh-tools"));
+  z = (await import("@deepseek-ai/schemastery")).default;
+  ({ createUserMessage } = await import("@deepseek-ai/dsh-llm"));
+} catch {}
+
+const PLATFORM = process.platform === "win32" ? "windows" : process.platform;
+const ARCH = process.arch === "x64" ? "amd64" : process.arch;
+
+// resolveDeja finds the binary: an explicit override first, then the platform
+// package npm installed next to this one, then whatever is on PATH.
+function resolveDeja() {
+  if (process.env.DEJA_BIN) return process.env.DEJA_BIN;
+  const exe = PLATFORM === "windows" ? "deja.exe" : "deja";
+  try {
+    return require.resolve(`@vshulcz/deja-vu-${PLATFORM}-${ARCH}/bin/${exe}`);
+  } catch {
+    return exe;
+  }
+}
+
+const DEJA = resolveDeja();
+
+// run returns stdout, or "" when deja is missing or says nothing. Memory is
+// optional everywhere: a throw here would end the turn.
+function run(args, input) {
+  try {
+    return execFileSync(DEJA, args, {
+      encoding: "utf8",
+      timeout: 20000,
+      maxBuffer: 8 * 1024 * 1024,
+      input,
+      stdio: [input === undefined ? "ignore" : "pipe", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+const NOTHING = "Nothing in this machine's history matches that.";
+
+function tools(ctx) {
+  if (!defineTool || !z) return;
+
+  // Every tool here answers with the text deja printed, so one output
+  // declaration serves all three.
+  const TEXT_OUTPUT = {
+    schema: z.string(),
+    render: (_args, value) => [{ type: "text", text: String(value) }],
+  };
+
+  ctx.tools.register(defineTool({
+    name: "deja_recall",
+    description:
+      "Search this machine's own past AI coding sessions — every agent used on it, including months before deja was installed. Use before debugging an error or re-implementing anything that may already exist. Match on the most specific token available: an exact error string, function name, file path or flag.",
+    parameters: {
+      query: {
+        type: "string",
+        required: true,
+        description: "Specific tokens to match. Several words are ANDed.",
+      },
+      limit: {
+        type: "number",
+        description: "How many sessions to return. Default 5.",
+      },
+    },
+    output: TEXT_OUTPUT,
+    execute(args) {
+      const limit = Number.isFinite(args.limit) ? String(Math.max(1, Math.trunc(args.limit))) : "5";
+      return Promise.resolve(run(["search", "--json", "--limit", limit, String(args.query)]) || NOTHING);
+    },
+  }));
+
+  ctx.tools.register(defineTool({
+    name: "deja_session",
+    description:
+      "A full digest of the single best-matching past session — what was tried, what was decided, what it cost. Use after deja_recall when the reasoning behind an earlier decision matters, not just that it happened.",
+    parameters: {
+      query: {
+        type: "string",
+        required: true,
+        description: "A query, or a session id prefix returned by deja_recall.",
+      },
+    },
+    output: TEXT_OUTPUT,
+    execute(args) {
+      return Promise.resolve(run(["ctx", String(args.query)]) || NOTHING);
+    },
+  }));
+
+  ctx.tools.register(defineTool({
+    name: "deja_blame",
+    description:
+      "The past sessions that discussed a file, so you know why it is shaped the way it is before editing, refactoring or deleting it. Session history, not git authorship.",
+    parameters: {
+      path: {
+        type: "string",
+        required: true,
+        description: "Path to the file, absolute or relative to the workspace.",
+      },
+    },
+    output: TEXT_OUTPUT,
+    execute(args) {
+      return Promise.resolve(run(["blame", String(args.path), "--json"]) || NOTHING);
+    },
+  }));
+}
+
+function command(ctx) {
+  ctx.commands.register({
+    name: "deja",
+    description: "Search this machine's past AI coding sessions",
+    input: { hint: "what to look for" },
+    async handler(invocation) {
+      const query = String((invocation && invocation.rawInput) || "").trim();
+      if (!query) {
+        return { kind: "error", text: "Say what to look for: /deja <error, file, or decision>" };
+      }
+      const out = run([query]);
+      return { kind: "success", text: out || NOTHING };
+    },
+  });
+}
+
+function userText(message) {
+  const content = message && message.content;
+  if (!Array.isArray(content)) return typeof content === "string" ? content.trim() : "";
+  return content
+    .filter((part) => part && part.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("\n")
+    .trim();
+}
+
+// autoRecall puts the answer in front of the model without anyone asking for
+// it, through the seam the host evaluates on every assembly. The obvious
+// alternative — splicing a message into the "agent/pre-step" waterfall — looks
+// like it works and does not: a later listener rebuilds its answer from the
+// payload, and the added message is dropped with nothing reported.
+function autoRecall(ctx) {
+  let asked = "";
+  let recalled = "";
+
+  ctx.systemPrompt.context({
+    name: "deja:recall",
+    order: 120,
+    text: (assembly) => {
+      const agent = assembly && assembly.agent;
+      if (!agent) return "";
+      const prompt = lastHumanText(agent);
+      if (!prompt) return "";
+      if (prompt !== asked) {
+        asked = prompt;
+        recalled = run(["hook-prompt", "--plain"], JSON.stringify({ prompt, cwd: process.cwd() }));
+      }
+      // Silence is the common case: this speaks only when the history answers.
+      return recalled;
+    },
+  });
+}
+
+// lastHumanText is the newest thing the person actually typed. At assembly
+// time the message has already left the inbox and has not been appended as a
+// "user/message" yet — the only durable record of it is the inbox splice that
+// carried it in, so both are read. Anything a plugin contributed is skipped:
+// those carry a source of their own.
+function lastHumanText(agent) {
+  const events = agent && agent.session && agent.session.events;
+  if (!Array.isArray(events)) return "";
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (!event) continue;
+    if (event.type === "user/message" && isHuman(event.data)) return userText(event.data);
+    if (event.type === "agent/inbox/spliced") {
+      const inserted = event.data && event.data.inserted;
+      if (!Array.isArray(inserted)) continue;
+      for (let j = inserted.length - 1; j >= 0; j--) {
+        if (isHuman(inserted[j])) return userText(inserted[j]);
+      }
+    }
+  }
+  return "";
+}
+
+function isHuman(message) {
+  return Boolean(message) && (!message.source || message.source.kind === "user");
+}
+
+function apply(ctx, config) {
+  tools(ctx);
+  command(ctx);
+  if (!config || config.autoRecall !== false) autoRecall(ctx);
+}
+
+apply.inject = ["tools", "commands", "systemPrompt"];
+
+export default apply;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "dsh-deja",
+  "version": "0.18.0",
+  "description": "Brings the session history of nineteen other coding agents into DeepSeek Harness: recall, session digest and per-file history tools over a local index, plus optional automatic recall before each step.",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "cordis.patch.yml",
+    "README.md",
+    "README.zh.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vshulcz/deja-vu.git",
+    "directory": "packages/dsh-deja"
+  },
+  "homepage": "https://github.com/vshulcz/deja-vu/tree/main/packages/dsh-deja",
+  "bugs": {
+    "url": "https://github.com/vshulcz/deja-vu/issues"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "memory",
+    "recall",
+    "session-history",
+    "migration"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "dependencies": {
+    "@vshulcz/deja-vu": "0.18.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-tools": "^0.1.0"
+  }
+}