@vshulcz/pi-deja 0.19.4 → 0.20.0

package/README.md

@@ -1,7 +1,7 @@
 # @vshulcz/pi-deja
 
 pi remembers its own sessions. This extension answers the other question: what
-was done in the twenty-two other coding agents on this machine — Claude Code,
+was done in the twenty-four other coding agents on this machine — Claude Code,
 Codex, Cursor, Gemini, OpenClaw and Hermes among them — including the months
 before pi was installed.
 
@@ -21,7 +21,7 @@ The deja binary comes with the package; a deja you installed yourself
 `deja install pi-auto` wires pi too, and is the shorter path if you have the
 CLI: it adds deja's MCP server and writes an extension of its own. When that
 extension is present this package stands down, so having both never injects
-twice.
+twice — and the same for omp, whose extension the installer writes elsewhere.
 
 omp loads `pi.extensions` manifests and emits the same `before_agent_start`
 event, so `pi install`'s omp counterpart picks this package up as well.
@@ -33,6 +33,12 @@ event, so `pi install`'s omp counterpart picks this package up as well.
 - **Every prompt** (`before_agent_start`): the prompt is matched against the
   index and, when a past session answers it, that session goes to the model
   with the prompt. Silence is the common case.
+- **After a failed command** (`tool_result`): the repair this machine used the
+  last time that error came up goes in beside the error, in the same turn.
+- **Before an edit** (`tool_result` on a read): what earlier sessions decided
+  about the file the agent just opened.
+- **After a compaction** (`session_compact`): the list of what this session was
+  already shown is cleared, so the recall it lost can come back.
 - **`/deja <query>`**: search the history by hand.
 
 ## Which binary

package/index.ts

@@ -6,7 +6,7 @@ import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-import { argv, contextText, installerExtensionPath, sessionKey } from "./lib.mjs";
+import { argv, contextText, installerExtensionPaths, sessionKey } from "./lib.mjs";
 
 const require = createRequire(import.meta.url);
 
@@ -72,11 +72,16 @@ export default function (pi: any) {
   // it already does everything below, and two copies would inject the
   // recall twice and register /deja twice.
   try {
-    if (existsSync(installerExtensionPath(homedir()))) return;
+    if (installerExtensionPaths(homedir()).some((p) => existsSync(p))) return;
   } catch {}
 
   let injected = false;
   let toldBuilding = false;
+  // The tool and compaction events carry no session id of their own, and
+  // recall dedupes per session: without one it repeats itself and forgets
+  // nothing. The prompt handler passes through first and pi keeps the id on
+  // the session manager, so it is read there and held.
+  let session = "";
 
   // pi keeps a footer status line: while the first index builds, that is
   // where the user can see it happening instead of wondering why recall is
@@ -141,6 +146,7 @@ export default function (pi: any) {
         return;
       }
       const key = sessionKey(event, ctx);
+      if (key) session = key;
       const raw = run(["hook-prompt"], JSON.stringify({ prompt: event.prompt || "", session_id: key }));
       if (!raw) return;
       const resp = JSON.parse(raw);
@@ -152,4 +158,76 @@ export default function (pi: any) {
       // memory is optional: never break the session over it
     }
   });
+
+  // The other half of the point of action, and the half this package was
+  // missing: a command has just failed, and this machine has fixed that same
+  // error before. pi hands tool_result the content the model is about to read
+  // and uses what the handler returns, so the repair goes in beside the error
+  // in the same turn. The installer's own extension has carried this since
+  // #3112/#3113; anyone who installed from npm had neither it nor the
+  // compaction handler below (#3180).
+  const repaired: Record<string, string> = {};
+  pi.on("tool_result", async (event: any, ctx: any) => {
+    try {
+      if (!event) return;
+      const key = sessionKey(event, ctx);
+      if (key) session = key;
+      // A file the agent just opened is the step before it changes that file,
+      // and pi has no handler that runs earlier whose return the model reads.
+      // So the file's own history goes out here: what was decided about it,
+      // from the sessions that decided it. deja answers once per session per
+      // fact, so re-reading the same file stays quiet.
+      if (event.toolName === "read") {
+        const path = String((event.input && (event.input.path || event.input.file_path)) || "");
+        if (!path) return;
+        const parts = Array.isArray(event.content) ? event.content : [];
+        const id = "read:" + String(event.toolCallId || "");
+        if (!(id in repaired)) {
+          repaired[id] = run(["hook-tool", "--plain"], JSON.stringify({
+            tool_name: "read",
+            tool_input: { file_path: path },
+            session_id: session,
+            cwd: process.cwd(),
+          }));
+        }
+        const note = repaired[id];
+        if (!note) return;
+        return { content: parts.concat([{ type: "text", text: note }]) };
+      }
+      if (!event.isError) return;
+      if (event.toolName !== "bash") return;
+      const parts = Array.isArray(event.content) ? event.content : [];
+      const output = parts
+        .filter((p: any) => p && p.type === "text" && typeof p.text === "string")
+        .map((p: any) => p.text)
+        .join("\n");
+      if (!output.trim()) return;
+      const id = String(event.toolCallId || "");
+      if (!(id in repaired)) {
+        repaired[id] = run(["hook-tool-after", "--plain"], JSON.stringify({
+          tool_name: "bash",
+          tool_response: output,
+          session_id: session,
+          cwd: process.cwd(),
+        }));
+      }
+      const line = repaired[id];
+      if (!line) return;
+      return { content: parts.concat([{ type: "text", text: line }]) };
+    } catch {
+      // never turn a failed command into a failed session
+    }
+  });
+
+  // Compaction throws away the blocks this session was shown, and the list
+  // that stops them repeating outlives them. session_compact fires once the
+  // summary has replaced the history, which is exactly when the session should
+  // be allowed to see those blocks again.
+  pi.on("session_compact", async (_event: any, ctx: any) => {
+    try {
+      const key = sessionKey(_event, ctx);
+      if (key) session = key;
+      run(["hook-precompact"], JSON.stringify({ session_id: session }));
+    } catch {}
+  });
 }

package/lib.mjs

@@ -13,6 +13,17 @@ export function installerExtensionPath(home) {
   return join(home || "", ".pi", "agent", "extensions", "deja.ts")
 }
 
+// installerExtensionPaths are every place `deja install` writes an extension
+// this package would duplicate. omp runs the same package and the installer
+// writes it under ~/.omp/agent/extensions/deja/index.js, so checking pi's path
+// alone left both running side by side (#3180).
+export function installerExtensionPaths(home) {
+  return [
+    installerExtensionPath(home),
+    join(home || "", ".omp", "agent", "extensions", "deja", "index.js"),
+  ]
+}
+
 // contextText pulls the recall out of whatever hook-context printed. deja
 // answers in the Claude Code hook shape; older builds and `--plain` print
 // bare text, so both are accepted.
@@ -40,8 +51,16 @@ export function argv(cmd, flags, text) {
 }
 
 // sessionKey is what per-prompt recall dedups on: a hit shown once in a
-// session is not shown again. Without one it repeats itself every message.
-// Same order as the extension `deja install pi-auto` writes.
+// session is not shown again. Without one it repeats itself every message —
+// which it did, because pi keeps the id on ctx.sessionManager and nowhere the
+// event or ctx.session shapes below look (#3179). The manager first, the same
+// order as the extension `deja install pi-auto` writes; the rest for hosts
+// that put an id on the event.
 export function sessionKey(event, ctx) {
+  try {
+    const m = ctx && ctx.sessionManager
+    const id = m && (typeof m.getSessionId === "function" ? m.getSessionId() : m.sessionId)
+    if (id) return String(id)
+  } catch {}
   return (event && (event.sessionId || event.session_id)) || (ctx && ctx.session && ctx.session.id) || ""
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vshulcz/pi-deja",
-  "version": "0.19.4",
-  "description": "deja-vu memory for pi: the coding sessions already on this machine — pi, Claude Code, Codex, Cursor and 19 more — recalled at session start and on every prompt, searchable with /deja. A local index, no LLM.",
+  "version": "0.20.0",
+  "description": "deja-vu memory for pi: the coding sessions already on this machine — pi, Claude Code, Codex, Cursor and 21 more — recalled at session start and on every prompt, searchable with /deja. A local index, no LLM.",
   "type": "module",
   "files": [
     "index.ts",
@@ -33,7 +33,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@vshulcz/deja-vu": "^0.19.4"
+    "@vshulcz/deja-vu": "^0.20.0"
   },
   "pi": {
     "extensions": [