dsh-deja 0.21.6 → 0.22.0

package/README.md

@@ -8,7 +8,7 @@ DeepSeek Harness can already search its own sessions — that is what the built-
 `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 thirty-four other coding agents — Claude Code,
+deja indexes the session files that forty other coding agents — Claude Code,
 Codex, Cursor, opencode, Antigravity, Grok Build, Kimi, Cline and Zed among
 them — 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
@@ -58,6 +58,12 @@ 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.
 
+The same recall also wires what `deja install dsh-auto` wires: after a read,
+edit or write the model gets what past sessions said about that file, after a
+command that failed it gets what this machine ran after the same error before,
+a compaction keeps what the session was in the middle of, and a session that
+ends drops its live stamp.
+
 ```yaml
 - insert:
     - id: deja

package/docs/zh.md

@@ -6,7 +6,7 @@
 
 DeepSeek Harness 自带的 `session-query` 已经可以检索它自己的会话。这个插件回答的是另一个问题：你在这台机器上**其他**智能体里做过什么。
 
-deja 索引 Claude Code、Codex、Cursor、opencode、Antigravity、Grok Build、Kimi、Cline、Zed 等其他三十四个智能体本来就写在磁盘上的会话文件。不需要提前录制：历史已经在那里，包括安装 deja 之前的那些月份。如果你上周才转到 dsh，上周之前做过的事仍然可以在 dsh 里查到。
+deja 索引 Claude Code、Codex、Cursor、opencode、Antigravity、Grok Build、Kimi、Cline、Zed 等其他四十个智能体本来就写在磁盘上的会话文件。不需要提前录制：历史已经在那里，包括安装 deja 之前的那些月份。如果你上周才转到 dsh，上周之前做过的事仍然可以在 dsh 里查到。
 
 ## 安装
 
@@ -42,6 +42,8 @@ dsh plugin --profile web add github:vshulcz/deja-vu#path:extensions/dsh
 
 以及默认开启的自动召回：每个会话一次，插件把这个项目里以前的会话定下来的事加进来；每一步之前，插件会问 deja 这台机器的历史能否回答当前提问，并把结果加入运行时上下文。多数情况下它保持沉默，只有确实有内容时才开口。
 
+同一套召回也接上了 `deja install dsh-auto` 接的那些：读、改、写一个文件之后，模型会拿到以前的会话对这个文件说过什么；命令失败之后，会拿到这台机器上次遇到同样错误后跑过的命令；压缩时保留会话正在做的事；会话结束时撤掉它的在线标记。
+
 ```yaml
 - insert:
     - id: deja

package/index.js

@@ -2,16 +2,17 @@
 //
 // 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 thirty-one more agents, on this
+// in Claude Code, Codex, Cursor, opencode and thirty-seven 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";
+import { execFile, execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-import { argv, contributions, guarded } from "./lib.js";
+import { argv, contributions, exitStatus, guarded, resultText } from "./lib.js";
 
 const require = createRequire(import.meta.url);
 
@@ -105,7 +106,7 @@ function tools(ctx) {
   guarded(() => 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.",
+      "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, and before the first edit in a task and before calling a change done or ready to merge. Match on the most specific token available: an exact error string, function name, file path or flag.",
     parameters: {
       query: {
         type: "string",
@@ -291,8 +292,14 @@ function autoDigest(ctx) {
   );
 }
 
+// dsh names a session "session-<uuid>" and its log's folder the same; deja
+// indexes it by the uuid, so that is the id every hook is given.
+function bareSessionId(id) {
+  return String(id || "").replace(/^session-/, "");
+}
+
 function sessionId(agent) {
-  return (agent && (agent.sessionId || (agent.session && agent.session.id))) || "";
+  return bareSessionId((agent && (agent.sessionId || (agent.session && agent.session.id))) || "");
 }
 
 // The workspace a session belongs to. One web or tui process serves sessions
@@ -307,7 +314,10 @@ function sessionCwd(agent) {
 function autoRecall(ctx) {
   let asked = "";
   let askedIn = "";
+  let askedBy = "";
   let recalled = "";
+  const compacted = new Set();
+  watchCompaction(ctx, compacted);
 
   guarded(() =>
     ctx.systemPrompt.context({
@@ -319,11 +329,17 @@ function autoRecall(ctx) {
         const prompt = lastHumanText(agent);
         if (!prompt) return "";
         const cwd = sessionCwd(agent);
-        // The same question asked in another workspace is a different question.
-        if (prompt !== asked || cwd !== askedIn) {
+        const sid = sessionId(agent);
+        const afterCompaction = compacted.delete(sid);
+        // The same question asked in another workspace is a different question,
+        // and so is one asked again after its session compacted: deja then
+        // answers with the recovery packet, which only a prompt naming the
+        // session gets back.
+        if (prompt !== asked || cwd !== askedIn || sid !== askedBy || afterCompaction) {
           asked = prompt;
           askedIn = cwd;
-          recalled = run(["hook-prompt", "--plain"], JSON.stringify({ prompt, cwd }));
+          askedBy = sid;
+          recalled = run(["hook-prompt", "--plain"], JSON.stringify({ prompt, cwd, session_id: sid }));
         }
         // Silence is the common case: this speaks only when the history answers.
         return recalled;
@@ -332,6 +348,169 @@ function autoRecall(ctx) {
   );
 }
 
+// runAsync is run for a seam dsh awaits, so the event loop goes on while deja
+// answers. It never rejects.
+function runAsync(args, input) {
+  return new Promise((resolve) => {
+    try {
+      const child = execFile(DEJA, args, { encoding: "utf8", timeout: 20000, maxBuffer: 8 * 1024 * 1024 }, (err, stdout) =>
+        resolve(err ? "" : String(stdout || "").trim()),
+      );
+      child.on("error", () => resolve(""));
+      child.stdin.on("error", () => {});
+      child.stdin.end(input);
+    } catch {
+      resolve("");
+    }
+  });
+}
+
+// Compaction shadows the turns it summarises but leaves them in the session
+// log, so deja reads the session there as compaction/start lands and keeps a
+// recovery packet: the task, each command with how it went, what was still
+// open. The log is written behind the session, so it is flushed first. dsh
+// assembles a step's context before its agent/pre-step waterfall, where the
+// compaction runs, so the step that compacts waits there for the capture and
+// the packet rides the recall of the next step, or of the next turn.
+function watchCompaction(ctx, compacted) {
+  if (typeof ctx.on !== "function") return;
+  const capturing = new Map();
+  const listen = (c) =>
+    c.on("session/event", (session, event) => {
+      if (!session || !event || event.type !== "compaction/start") return;
+      const sid = bareSessionId(session.id || (session.header && session.header.id));
+      if (!sid) return;
+      const cwd = (session.header && session.header.cwd) || process.cwd();
+      // One compaction can follow another inside a step; two captures at once
+      // contend for the index and the loser marks the packet unavailable, so
+      // each waits for the one before it.
+      const before = capturing.get(sid) || Promise.resolve();
+      const capture = before.then(async () => {
+        try {
+          if (c.sessions && typeof c.sessions.flush === "function") await c.sessions.flush(session);
+        } catch {}
+        await runAsync(["hook-precompact"], JSON.stringify({ session_id: sid, cwd, harness: "deepseek" }));
+        compacted.add(sid);
+      });
+      capturing.set(sid, capture);
+      capture.then(() => {
+        if (capturing.get(sid) === capture) capturing.delete(sid);
+      });
+    });
+  try {
+    if (typeof ctx.inject === "function") ctx.inject(["sessions"], listen);
+    else listen(ctx);
+  } catch {}
+  try {
+    ctx.on("agent/pre-step", async (step, next) => {
+      const sid = sessionId(step && step.agent);
+      if (capturing.has(sid)) await capturing.get(sid);
+      const decision = await next();
+      if (capturing.has(sid)) await capturing.get(sid);
+      return decision;
+    });
+  } catch {}
+}
+
+// The point of action, as `deja install dsh-auto` wires it. tools/post-execute
+// runs on every tool result, and an accept decision's additionalContexts reach
+// the model on the next step: a read, edit or write gets what deja knows about
+// the file, a bash that exited non-zero gets the fix this machine found for
+// that error before. The before-seam, tools/execute, has no channel to the
+// model.
+function toolNotes(ctx) {
+  if (typeof ctx.on !== "function") return;
+  try {
+    ctx.on("tools/post-execute", async (exec, result, next) => {
+      const decision = await next();
+      try {
+        if (!decision || decision.kind !== "accept" || !exec) return decision;
+        const note = await toolNote(exec, result);
+        if (!note) return decision;
+        return {
+          ...decision,
+          additionalContexts: [...(decision.additionalContexts || []), noteMessage(note)],
+        };
+      } catch {
+        return decision;
+      }
+    });
+  } catch {}
+}
+
+// A session is over when dsh disposes of it, or when the process goes: on
+// 0.1.1-rc.2 the headless profile exits without disposing anything, and only
+// process "exit" runs. The digest and the recall stamp a session live, which
+// keeps it out of its own MCP recall; dropping the stamp lets the next session
+// be answered with it now rather than twenty minutes from now.
+function sessionEnds(ctx) {
+  if (typeof ctx.on !== "function") return;
+  const live = new Set();
+  const end = (sid) => {
+    if (!sid || !live.has(sid)) return;
+    live.delete(sid);
+    run(["hook-session-end"], JSON.stringify({ session_id: sid }));
+  };
+  try {
+    ctx.on("session/created", (session) => {
+      const sid = bareSessionId(session && session.id);
+      if (sid) live.add(sid);
+    });
+    ctx.on("session/disposed", (session) => end(bareSessionId(session && session.id)));
+    process.on("exit", () => {
+      for (const sid of [...live]) end(sid);
+    });
+  } catch {}
+}
+
+async function toolNote(exec, result) {
+  const args = exec.arguments || {};
+  const base = { session_id: sessionId(exec.agent), cwd: sessionCwd(exec.agent) };
+  if ((exec.name === "read" || exec.name === "edit" || exec.name === "write") && args.file_path) {
+    return runAsync(["hook-tool", "--plain"], JSON.stringify({
+      tool_name: exec.name,
+      tool_input: { file_path: String(args.file_path) },
+      ...base,
+    }));
+  }
+  // The profile's other editor names the file "path"; view is its read.
+  if (exec.name === "str_replace_editor" && args.path) {
+    return runAsync(["hook-tool", "--plain"], JSON.stringify({
+      tool_name: args.command === "view" ? "read" : "edit",
+      tool_input: { file_path: String(args.path) },
+      ...base,
+    }));
+  }
+  // pwsh is the Windows shell, with the same markers.
+  if (exec.name === "bash" || exec.name === "pwsh") {
+    const status = exitStatus(resultText(result));
+    if (!(result && result.isError) && !status.failed) return "";
+    return runAsync(["hook-tool-after", "--plain"], JSON.stringify({
+      tool_name: exec.name === "pwsh" ? "powershell" : "bash",
+      tool_input: { command: String(args.command || "") },
+      tool_response: status.body,
+      ...base,
+    }));
+  }
+  return "";
+}
+
+// A context message the way dsh's own plugins build one: user role, a plugin
+// source so it is not read back as something the person typed, a fresh id,
+// frozen.
+function noteMessage(text) {
+  const message = {
+    role: "user",
+    content: [{ type: "text", text }],
+    source: { kind: "plugin", plugin: "deja", form: "notice" },
+    id: randomUUID(),
+  };
+  Object.freeze(message.content[0]);
+  Object.freeze(message.content);
+  Object.freeze(message.source);
+  return Object.freeze(message);
+}
+
 // 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
@@ -392,6 +571,8 @@ function apply(ctx, config) {
   if (adds.recall) {
     autoDigest(ctx);
     autoRecall(ctx);
+    toolNotes(ctx);
+    sessionEnds(ctx);
   }
 }
 

package/lib.js

@@ -39,6 +39,29 @@ export function guarded(register) {
   }
 }
 
+// resultText is the text a tool handed back to the model.
+export function resultText(result) {
+  const content = result && result.content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((part) => part && part.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("\n");
+}
+
+// exitStatus reads how a dsh command ended. dsh reports it in the text rather
+// than as an error result: a last line of "[exit code: N]" for a non-zero exit,
+// or "[killed by signal: X]". Only the last line counts, since output may quote
+// a marker anywhere else. The marker is cut from the body before the lookup:
+// an error whose last line is "[exit code: 1]" matches nothing on file.
+export function exitStatus(text) {
+  const signal = /\n\[killed by signal: [^\]\n]+\]$/.exec(text);
+  if (signal) return { body: text.slice(0, signal.index), failed: true };
+  const exit = /\n\[exit code: (\d+)\]$/.exec(text);
+  if (exit) return { body: text.slice(0, exit.index), failed: exit[1] !== "0" };
+  return { body: text, failed: false };
+}
+
 // contributions says what this package adds, given what `deja install` already
 // wrote into DSH_HOME and what the profile turned off. The rule is the same
 // everywhere: fill the gaps, never repeat the installer.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-deja",
-  "version": "0.21.6",
-  "description": "deja-vu memory for DeepSeek Harness: the session history of thirty-four other coding agents, searchable and recalled before each step — a local index, no LLM.",
+  "version": "0.22.0",
+  "description": "deja-vu memory for DeepSeek Harness: the session history of forty other coding agents, searchable and recalled before each step — a local index, no LLM.",
   "type": "module",
   "main": "index.js",
   "exports": {
@@ -62,7 +62,7 @@
     }
   },
   "dependencies": {
-    "@vshulcz/deja-vu": "^0.21.6"
+    "@vshulcz/deja-vu": "^0.22.0"
   },
   "scripts": {
     "test": "node --test test/*.test.js"