opencode-deja 0.19.2 → 0.19.3

package/README.md

@@ -1,8 +1,9 @@
 # opencode-deja
 
 opencode remembers its own sessions. This plugin answers the other question:
-what you did in Claude Code, Codex, Cursor, Gemini, Zed and fifteen more agents
-on this machine — including the months before you installed anything.
+what you did in the twenty-one other coding agents on this machine — Claude Code,
+Codex, Cursor, Gemini and Zed among them — including the months before you
+installed anything.
 
 It runs [deja](https://github.com/vshulcz/deja-vu), a local Go binary that
 indexes the transcripts those agents already wrote to disk. No LLM, no

package/index.js

@@ -14,6 +14,7 @@ import { join } from "node:path"
 import { accessSync, constants, existsSync, readFileSync } from "node:fs"
 
 import {
+  argv,
   clampLimit,
   cliPluginPath,
   configPaths,
@@ -30,6 +31,11 @@ const WINDOWS = process.platform === "win32"
 const PLATFORM = WINDOWS ? "windows" : process.platform
 const ARCH = process.arch === "x64" ? "amd64" : process.arch
 const EXE = WINDOWS ? "deja.exe" : "deja"
+// How many turns of a session will ask again after being answered with
+// nothing. Three covers the moments that pass — a locked index, a call that
+// timed out, an upgrade replacing the binary — without turning a store that
+// genuinely holds nothing into a shell-out on every turn.
+const emptyRetries = 3
 
 // The tool helper is a peer of the host, not of us: it is identity plus a zod
 // re-export. Without it the hooks still run and only the model-facing tools are
@@ -143,6 +149,15 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
 
   const digests = new Map()
   const told = new Set()
+  // How many times this session has been answered with nothing. An empty
+  // answer is cached so the plugin does not shell out every turn, but the
+  // reasons for it are not alike: no history is permanent, while a locked
+  // index, a timed-out call or a binary being replaced mid-`deja update` are
+  // over by the next turn. Cached alike, one bad moment cost the session all
+  // of its memory — every later turn read the emptiness rather than asking
+  // again. Counted, so a store that really is empty is still only asked a few
+  // times.
+  const empties = new Map()
 
   const hooks = {}
 
@@ -166,7 +181,7 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
         },
         async execute(args) {
           const limit = String(clampLimit(args.limit))
-          return answer(await ask(["search", "--json", "--limit", limit, String(args.query)]))
+          return answer(await ask(argv("search", ["--json", "--limit", limit], args.query)))
         },
       }),
       deja_session: tool({
@@ -176,7 +191,7 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
           query: schema.string().describe("A query, or a session id prefix returned by deja_recall."),
         },
         async execute(args) {
-          return answer(await ask(["ctx", String(args.query)]))
+          return answer(await ask(argv("ctx", [], args.query)))
         },
       }),
       deja_blame: tool({
@@ -186,7 +201,7 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
           path: schema.string().describe("Path to the file, absolute or relative to the project."),
         },
         async execute(args) {
-          return answer(await ask(["blame", String(args.path), "--json"]))
+          return answer(await ask(argv("blame", ["--json"], args.path)))
         },
       }),
       deja_fix: tool({
@@ -196,7 +211,7 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
           error: schema.string().describe("The failing output, copied as it was printed."),
         },
         async execute(args) {
-          return answer(await ask(["fix", String(args.error)]))
+          return answer(await ask(argv("fix", [], args.error)))
         },
       }),
       deja_how: tool({
@@ -206,7 +221,7 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
           what: schema.string().describe("The thing to run: a tool, a task, a script name."),
         },
         async execute(args) {
-          return answer(await ask(["how", String(args.what)]))
+          return answer(await ask(argv("how", [], args.what)))
         },
       }),
       deja_remember: tool({
@@ -216,7 +231,7 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
           text: schema.string().describe("The decision, in one or two sentences, with the reason it was taken."),
         },
         async execute(args) {
-          const written = await ask(["remember", String(args.text)])
+          const written = await ask(argv("remember", [], args.text))
           if (!installed) return MISSING
           return written || "deja did not record that."
         },
@@ -250,9 +265,13 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
         output.system.push(context)
         return
       }
-      // Nothing recalled: either this machine has no history yet, or the first
-      // index is still building. Only the second is worth saying, and saying it
-      // drops the empty answer so the next turn asks again.
+      // Nothing recalled: this machine has no history yet, the first index is
+      // still building, or the call did not get through. The build is the only
+      // one worth saying out loud, and saying it drops the empty answer so the
+      // next turn asks again.
+      const asks = (empties.get(key) || 0) + 1
+      empties.set(key, asks)
+      if (asks < emptyRetries) digests.delete(key)
       if (told.has(key)) return
       const status = await ask(["warmup-status"], undefined, 5000)
       if (!status) return
@@ -269,11 +288,15 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
   // Per-prompt recall, the relevance pass Claude Code gets on
   // UserPromptSubmit: the digest above is ranked by the project, this is ranked
   // by what the user just asked. Silent when nothing matches.
-  hooks["experimental.chat.messages.transform"] = async (_input, output) => {
+  hooks["experimental.chat.messages.transform"] = async (input, output) => {
     try {
-      const { parts, prompt } = lastUserText(output?.messages)
+      const { parts, prompt, sessionID } = lastUserText(output?.messages)
       if (!prompt) return
-      const raw = await ask(["hook-prompt"], JSON.stringify({ prompt, cwd }))
+      // The session id lets recall skip what it already showed this session.
+      // Without it every message re-injects the same block — measured on a real
+      // store, half of all injections were a word-for-word repeat.
+      const key = input?.sessionID || sessionID || ""
+      const raw = await ask(["hook-prompt"], JSON.stringify({ prompt, session_id: key, cwd }))
       if (!raw) return
       const extra = JSON.parse(raw)?.hookSpecificOutput?.additionalContext
       if (!extra) return
@@ -293,5 +316,56 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
     }
   }
 
+  // A spawned agent gets none of the above: the system prompt was built for the
+  // session that spawned it, and the per-prompt pass fires on what the user
+  // typed, which a subagent never does. Its instructions are the one thing that
+  // reaches it, so recall goes in there.
+  hooks["tool.execute.before"] = async (input, output) => {
+    try {
+      if (input?.tool !== "task") return
+      const args = output?.args
+      if (!args?.prompt) return
+      const payload = {
+        hook_event_name: "PreToolUse",
+        tool_name: "Task",
+        tool_input: { prompt: args.prompt },
+        session_id: input.sessionID || "",
+        cwd,
+      }
+      const raw = await ask(["hook-tool"], JSON.stringify(payload))
+      if (!raw) return
+      const next = JSON.parse(raw)?.hookSpecificOutput?.updatedInput?.prompt
+      if (next) args.prompt = next
+    } catch {
+      // memory is optional: never break a spawn over it
+    }
+  }
+
+  // The moment a command fails is the one an agent never thinks to ask about,
+  // and tool.execute.after is the only seam opencode gives for it. The hook
+  // returns nothing to inject, so the line is folded into the tool output,
+  // which the next request carries as the tool result.
+  hooks["tool.execute.after"] = async (input, output) => {
+    try {
+      if (input?.tool !== "bash") return
+      const text = output?.output
+      if (!text) return
+      const payload = {
+        hook_event_name: "PostToolUse",
+        tool_name: "bash",
+        tool_input: { command: input?.args?.command || "" },
+        tool_response: { output: text },
+        session_id: input.sessionID || "",
+        cwd,
+      }
+      const raw = await ask(["hook-tool-after"], JSON.stringify(payload))
+      if (!raw) return
+      const extra = JSON.parse(raw)?.hookSpecificOutput?.additionalContext
+      if (extra) output.output = text + "\n\n" + extra
+    } catch {
+      // memory is optional: never break a tool call over it
+    }
+  }
+
   return hooks
 }

package/lib.js

@@ -29,11 +29,12 @@ export function lastUserText(messages) {
   const list = Array.isArray(messages) ? messages : []
   for (let i = list.length - 1; i >= 0; i--) {
     if (list[i]?.info?.role !== "user") continue
+    const sessionID = list[i].info?.sessionID || ""
     const parts = (list[i].parts || []).filter((p) => p?.type === "text" && p.text)
-    if (!parts.length) return { parts: [], prompt: "" }
-    return { parts, prompt: parts.map((p) => p.text).join("\n").trim() }
+    if (!parts.length) return { parts: [], prompt: "", sessionID }
+    return { parts, prompt: parts.map((p) => p.text).join("\n").trim(), sessionID }
   }
-  return { parts: [], prompt: "" }
+  return { parts: [], prompt: "", sessionID: "" }
 }
 
 // cliPluginPath is where `deja install opencode-auto` writes its own plugin.
@@ -118,6 +119,22 @@ export function contributions(wiring, config = {}) {
   }
 }
 
+// argv builds the call for a query somebody typed, rather than handing the text
+// to deja as it stands.
+//
+// A query that starts with a dash is read as a flag: `deja search --no-verify`
+// exits on an unknown flag, run() turns a failed call into "", and the model is
+// told the history holds nothing about --no-verify while the sessions that
+// discuss it sit right there. A wrong answer, where an error would at least be
+// visible. `--` ends the flags.
+//
+// Sent only when the query needs it, so a deja too old to know the terminator
+// on this subcommand still answers every ordinary query.
+export function argv(cmd, flags, text) {
+  const arg = String(text)
+  return arg.startsWith("-") ? [cmd, ...flags, "--", arg] : [cmd, ...flags, arg]
+}
+
 // clampLimit keeps a model that asks for a hundred sessions from spending the
 // window on a tail nobody reads.
 export function clampLimit(value, fallback = 5) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-deja",
-  "version": "0.19.2",
-  "description": "Brings the session history of nineteen other coding agents into opencode: recall, session digest and per-file history tools over a local index, plus automatic recall on every request.",
+  "version": "0.19.3",
+  "description": "deja-vu memory for opencode: the session history of twenty-one other coding agents, searchable and recalled on every request — a local index, no LLM.",
   "type": "module",
   "main": "index.js",
   "exports": {
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": ">=1.0.0",
-    "@vshulcz/deja-vu": "^0.19.2"
+    "@vshulcz/deja-vu": "^0.19.3"
   },
   "scripts": {
     "test": "node --test test/*.test.js"