@vshulcz/pi-deja 0.22.2 → 0.23.1

package/README.md

@@ -3,7 +3,7 @@
 English | [中文](https://github.com/vshulcz/deja-vu/blob/main/extensions/pi/docs/zh.md)
 
 pi remembers its own sessions. This extension answers the other question: what
-was done in the forty-one other coding agents on this machine — Claude Code,
+was done in the forty-two other coding agents on this machine — Claude Code,
 Codex, Cursor, Gemini, OpenClaw and Hermes among them — including the months
 before pi was installed.
 

package/index.ts

@@ -1,12 +1,12 @@
 // deja-vu for pi: recall from the coding sessions already on this machine at
 // session start and on every prompt, and /deja to search them by hand.
 import { execFileSync } from "node:child_process";
-import { accessSync, constants, existsSync } from "node:fs";
+import { accessSync, closeSync, constants, existsSync, openSync, readSync } from "node:fs";
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 
-import { argv, contextText, installerExtensionPaths, sessionKey } from "./lib.mjs";
+import { argv, branchHoldsRecall, contextText, installerExtensionPaths, sessionKey } from "./lib.mjs";
 
 const require = createRequire(import.meta.url);
 
@@ -72,7 +72,7 @@ export default function (pi: any) {
   // it already does everything below, and two copies would inject the
   // recall twice and register /deja twice.
   try {
-    if (installerExtensionPaths(homedir()).some((p) => existsSync(p))) return;
+    if (installerExtensionPaths(homedir(), process.env).some((p) => existsSync(p))) return;
   } catch {}
 
   // Once per session, not once per process: /new, a resume and a fork keep the
@@ -124,16 +124,58 @@ export default function (pi: any) {
     },
   });
 
+  // The session a fork was made from, named on its header by path, when the
+  // fork holds a copy of its turns: a fork at the first message copies
+  // nothing, and its source is no part of it. The id is on that file's own
+  // header; pi names the file <time>_<id>.jsonl.
+  const parents: Record<string, string> = {};
+  const parentID = (ctx: any): string => {
+    if (session in parents) return parents[session];
+    let id = "";
+    try {
+      const m = ctx.sessionManager;
+      const path = String((m.getHeader() || {}).parentSession || "");
+      const copied = (m.getBranch() || []).some((e: any) => e && e.type === "message");
+      if (path && copied) {
+        try {
+          const fd = openSync(path, "r");
+          const buf = Buffer.alloc(64 * 1024);
+          const n = readSync(fd, buf, 0, buf.length, 0);
+          closeSync(fd);
+          id = String(JSON.parse(buf.subarray(0, n).toString("utf8").split("\n", 1)[0]).id || "");
+        } catch {}
+        if (!id) {
+          const name = basename(path).replace(/\.jsonl$/, "");
+          id = name.slice(name.lastIndexOf("_") + 1);
+        }
+      }
+    } catch {}
+    if (session) parents[session] = id;
+    return id;
+  };
+
   pi.on("before_agent_start", async (event: any, ctx: any) => {
     try {
       const key = sessionKey(event, ctx);
       if (key) session = key;
+      // A resumed session holds the digest it opened with, and pi sends it to
+      // the model again with the rest of the session; a fork holds a copy of
+      // its source's. Asking for another put a second copy in front of the
+      // model, and in a fork one that led with the source itself.
+      const parent = parentID(ctx);
+      try {
+        if (!injected.has(session) && branchHoldsRecall(ctx.sessionManager.getBranch())) {
+          injected.add(session);
+          const stats = run(["statusline"], "");
+          if (stats) ctx.ui.setStatus("deja", stats);
+        }
+      } catch {}
       if (!injected.has(session)) {
         // The session goes with it: hook-context marks the one starting as
         // live, which keeps it out of its own MCP recall on this first turn
         // (#4394, as #4246 and #4273 did for Hermes and opencode).
         const { context: digest, receipt } = contextText(
-          run(["hook-context"], JSON.stringify({ session_id: session, cwd: process.cwd() })),
+          run(["hook-context"], JSON.stringify({ session_id: session, parent_session_id: parent, cwd: process.cwd() })),
         );
         if (digest) {
           injected.add(session);
@@ -145,7 +187,9 @@ export default function (pi: any) {
           // quiet reminder that memory is on rather than a one-off toast.
           const stats = run(["statusline"], "");
           if (stats) ctx.ui.setStatus("deja", stats);
-          return { message: { customType: "deja-recall", content: digest, display: false } };
+          // Marked, so a resume can tell the digest from a prompt's recall
+          // (#5314).
+          return { message: { customType: "deja-recall", content: digest, display: false, details: { digest: true } } };
         }
         // Nothing to recall: either there is no history yet, or the first
         // index is still building. Only the second is worth saying, once.
@@ -155,7 +199,7 @@ export default function (pi: any) {
         }
         return;
       }
-      const raw = run(["hook-prompt"], JSON.stringify({ prompt: event.prompt || "", session_id: session }));
+      const raw = run(["hook-prompt"], JSON.stringify({ prompt: event.prompt || "", session_id: session, parent_session_id: parent }));
       if (!raw) return;
       const resp = JSON.parse(raw);
       if (resp && resp.systemMessage) ctx.ui.notify(resp.systemMessage, "info");
@@ -251,7 +295,7 @@ export default function (pi: any) {
   // on a switch ctx may already name the next session.
   pi.on("session_shutdown", async (_event: any) => {
     try {
-      if (session) run(["hook-session-end"], JSON.stringify({ session_id: session }), 2000);
+      if (session) run(["hook-session-end"], JSON.stringify({ session_id: session, cwd: process.cwd() }), 2000);
     } catch {}
   });
 }

package/lib.mjs

@@ -7,19 +7,22 @@ import { join } from "node:path"
 // installerExtensionPath is where `deja install pi-auto` writes its own
 // extension. pi loads that file and this package side by side, and both
 // would inject recall and register /deja, so this package stands down when
-// the installer's copy is present. Mirrors PiConfigDir() in the installer,
-// which is ~/.pi/agent with no override — pi has none either.
-export function installerExtensionPath(home) {
-  return join(home || "", ".pi", "agent", "extensions", "deja.ts")
+// the installer's copy is present. Mirrors PiConfigDir() in the installer:
+// ~/.pi/agent, or PI_CODING_AGENT_DIR when pi was told to live elsewhere.
+export function installerExtensionPath(home, env = {}) {
+  let dir = String(env.PI_CODING_AGENT_DIR || "")
+  if (dir === "~") dir = home || ""
+  else if (dir.startsWith("~/") || dir.startsWith("~\\")) dir = join(home || "", dir.slice(2))
+  return join(dir || 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) {
+export function installerExtensionPaths(home, env = {}) {
   return [
-    installerExtensionPath(home),
+    installerExtensionPath(home, env),
     join(home || "", ".omp", "agent", "extensions", "deja", "index.js"),
   ]
 }
@@ -64,3 +67,38 @@ export function sessionKey(event, ctx) {
   } catch {}
   return (event && (event.sessionId || event.session_id)) || (ctx && ctx.session && ctx.session.id) || ""
 }
+
+// branchHoldsRecall reports whether what pi sends the model from this branch
+// holds a recall block this package injected: what follows the last
+// compaction, and the entries it kept from before it, firstKeptEntryId on.
+// pi keeps the block as a custom_message and sends it again on a resume, and
+// a fork copies it from its source.
+//
+// What counts is the start digest, not any recall: a prompt's recall goes
+// under the same customType, and a compaction that kept a later one but not
+// the digest left a resumed session with no digest (#5314). The digest
+// carries details.digest; a branch with no marked digest anywhere was written
+// before the mark, and any block of ours still counts there.
+export function branchHoldsRecall(branch) {
+  const entries = Array.isArray(branch) ? branch : []
+  const marked = entries.some(isDigest)
+  const counts = (e) => (marked ? isDigest(e) : e.type === "custom_message" && e.customType === "deja-recall")
+  let keep = ""
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i] || {}
+    if (keep === "" && e.type === "compaction") {
+      keep = String(e.firstKeptEntryId || "")
+      if (!keep) return false
+      continue
+    }
+    if (counts(e)) return true
+    if (keep && e.id === keep) return false
+  }
+  return false
+}
+
+// isDigest reports whether a branch entry is the start digest this package
+// sent, which it marks with details.digest.
+function isDigest(e) {
+  return !!e && e.type === "custom_message" && e.customType === "deja-recall" && !!(e.details && e.details.digest)
+}

package/package.json

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