greprag 5.32.0 → 5.34.0

package/dist/opencode-plugin.js

@@ -7,15 +7,35 @@
  *   2. Capture every completed (user, assistant) turn pair to /v1/memory/turn
  *      for episodic compaction.
  *
- * Loaded by OpenCode from ~/.config/opencode/plugins/greprag-memory.js
+ * Loaded by opencode from ~/.config/opencode/plugins/greprag-memory.js
  * (installed by `greprag init --opencode`). All types are declared inline so
- * the file has zero external runtime imports — the package source must remain
- * self-contained because opencode's loader hands the compiled module straight
- * to Bun, with no resolution step against our dependency tree.
+ * the file has zero external runtime imports beyond the helpers module and
+ * Node built-ins — opencode's loader hands the compiled module straight to
+ * Bun with no resolution step against our dependency tree.
+ *
+ * adr: adr/opencode-monitor-relay.md — see entries 2026-06-06 (f) for the
+ * `export = { id, server }` rationale (single V1 plugin module, no
+ * `__esModule` wrapper, no `__test` helper export) and (g) for the recap
+ * renderer alignment with `greprag-hook` (single source of truth for the
+ * recap body pushed at session start), and (h) for the defensive
+ * `output.system` / optional-`sessionID` handling.
+ *
+ * Opencode SessionStart model:
+ *   Opencode has no true SessionStart hook (confirmed against sst/opencode
+ *   docs and corroborated by other plugins — Superpowers, codexfi,
+ *   opencode-rules, context-mode — all of which use
+ *   `experimental.chat.system.transform` as a turn-1 surrogate). The
+ *   experimental hook fires before each LLM call; we push the recap on the
+ *   first fire per session and skip later fires. This is a turn-1 model,
+ *   not a true session-start model, but it's the closest opencode has and
+ *   it's what other working plugins do.
  *
  * Hook surface used (verified against sst/opencode dev branch):
  *   - experimental.chat.system.transform — fires before each LLM call. We
- *     push recap text on the FIRST fire per sessionID and ignore later fires.
+ *     push recap text on the FIRST fire per sessionID and ignore later
+ *     fires. Defensive: sessionID is optional (opencode issue #6142), and
+ *     output.system may arrive as `string | string[]` depending on
+ *     runtime/version — we handle both shapes.
  *   - event — receives every bus event. We listen for "message.updated" with
  *     role="assistant" and info.time.completed set (assistant message
  *     finalized), then fetch the session's full message list via the supplied
@@ -59,17 +79,76 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.__test = exports.GrepRAGMemoryPlugin = void 0;
-// ============================================================================
-// Module-level setup: env + anchor (loaded once per opencode process)
-// ============================================================================
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+// ============================================================================
+// File-based debug log. opencode's plugin loader (Bun) does NOT route plugin
+// stderr into the opencode log file at ~/.local/share/opencode/log/*.log —
+// the `process.stderr.write` calls earlier were silently dropped. The watch
+// process is its own spawned daemon so its stderr reaches the user's shell
+// (which is why it appeared in the test bash output), but the plugin runs
+// in-process and has no such pipe. We write to disk at a known location so
+// the operator can `Get-Content ~/.greprag/opencode-plugin-debug.log -Tail
+// 50` after a session to see exactly what the plugin did.
+// ============================================================================
+const DEBUG_LOG_PATH = path.join(os.homedir(), '.greprag', 'opencode-plugin-debug.log');
+let _debugLogReady = false;
+function dlogInit() {
+    if (_debugLogReady)
+        return;
+    _debugLogReady = true;
+    try {
+        fs.writeFileSync(DEBUG_LOG_PATH, '');
+    }
+    catch { /* disk full / permission denied — best effort */ }
+}
+function dlog(msg) {
+    dlogInit();
+    const line = `[${new Date().toISOString()}] [greprag-memory] ${msg}\n`;
+    try {
+        fs.appendFileSync(DEBUG_LOG_PATH, line);
+    }
+    catch { /* swallow */ }
+}
+dlog(`module top reached: pid=${process.pid} argv0=${process.argv[0]} distPath=${__filename}`);
+// Helpers are deployed at ~/.greprag/opencode-plugin-helpers.js, NOT inside
+// the opencode plugins dir. opencode auto-loads every `.js` file in
+// `~/.config/opencode/plugins/` as a plugin, and the helpers file (a barrel
+// of named function exports with `__esModule: true` tsc marker) would trip
+// the same `getLegacyPlugins` shape check that the main file used to. Using
+// an absolute require via os.homedir() sidesteps the auto-load entirely.
+// The plugin registry config doesn't need a "helpers" entry — only the
+// main file is registered with opencode. See adr/opencode-monitor-relay.md
+// 2026-06-06 (f) for the location rationale.
+const HELPERS_PATH = path.join(os.homedir(), '.greprag', 'opencode-plugin-helpers.js');
+dlog(`requiring helpers from ${HELPERS_PATH}`);
+let HOME;
+let isPidAlive;
+let readAnchor;
+let relayLockPath;
+let tryClaimRelayLock;
+let buildRecapBody;
+try {
+    const helpers = require(HELPERS_PATH);
+    HOME = helpers.HOME;
+    isPidAlive = helpers.isPidAlive;
+    readAnchor = helpers.readAnchor;
+    relayLockPath = helpers.relayLockPath;
+    tryClaimRelayLock = helpers.tryClaimRelayLock;
+    buildRecapBody = helpers.buildRecapBody;
+    dlog(`helpers loaded: HOME=${HOME} keys=${Object.keys(helpers).length}`);
+}
+catch (e) {
+    dlog(`FATAL: helpers require threw: ${e.message}\n${e.stack}`);
+    throw e;
+}
+// ============================================================================
+// Module-level setup: env + anchor (loaded once per opencode process)
+// ============================================================================
 const API_URL = 'https://api.greprag.com';
-const HOME = process.env.HOME || process.env.USERPROFILE || '';
 function loadEnvFile(filePath) {
     try {
         if (!fs.existsSync(filePath))
@@ -97,7 +176,7 @@ function loadEnvFile(filePath) {
     }
 }
 /** Load env vars from ~/.greprag/.env first, then the legacy Claude settings
- *  env block. OpenCode is not Claude-specific, so the shared GrepRAG env file
+ *  env block. opencode is not Claude-specific, so the shared GrepRAG env file
  *  is canonical for new installs while ~/.claude/settings.json remains a
  *  compatibility fallback. */
 function loadGrepragEnv() {
@@ -120,284 +199,286 @@ function loadGrepragEnv() {
     }
 }
 loadGrepragEnv();
-function getEnv(key) {
-    return process.env[key] || '';
-}
-function readAnchorFile(filePath) {
+dlog(`env loaded: MEMORY_HOOK_ENABLED=${process.env.MEMORY_HOOK_ENABLED || '<unset>'} GREPRAG_API_KEY=${process.env.GREPRAG_API_KEY ? 'set' : '<unset>'} GREPRAG_OPENCODE_CAPTURE=${process.env.GREPRAG_OPENCODE_CAPTURE || '<unset>'}`);
+// ============================================================================
+// Capture watcher spawner — "just works" UX
+// ============================================================================
+// The opencode event bus does not reliably fire for the user's active
+// session, so a hook-based capture path is fragile. The on-disk SQLite DB
+// at ~/.local/share/opencode/opencode.db IS reliable — opencode writes
+// every (user, assistant) pair to it the moment a turn completes.
+//
+// This block spawns `greprag opencode watch` as a long-lived child process
+// at module-load time. With this in place, the install flow becomes:
+//   1. `npm install -g @greprag/cli`
+//   2. `greprag init --opencode`   (writes API key, plugin file, opencode.json)
+//   3. Open opencode. Captures flow.
+// No separate `opencode watch` invocation required.
+const WATCHER_LOCK = path.join(HOME || os.homedir(), '.greprag', 'opencode-watch.lock');
+const WATCHER_STALE_MS = 30_000;
+function findGrepragBinary() {
+    const override = process.env.GREPRAG_BIN;
+    if (override && fs.existsSync(override))
+        return override;
+    const binaryName = process.platform === 'win32' ? 'greprag.cmd' : 'greprag';
     try {
-        const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-        if (!raw || typeof raw !== 'object')
-            return null;
-        const notify = raw.inbox_notify;
-        const inboxNotify = notify === 'off' || notify === 'session_start_only' ? notify : 'every_turn';
-        return {
-            projectId: typeof raw.project_id === 'string' ? raw.project_id : undefined,
-            projectName: typeof raw.project_name === 'string' ? raw.project_name : undefined,
-            memoryCapture: raw.memory_capture !== false,
-            sessionStartRecap: raw.session_start_recap !== false,
-            inboxNotify,
-        };
+        const out = (0, child_process_1.execSync)(`where ${binaryName}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        for (const line of out.split(/\r?\n/)) {
+            const candidate = line.trim();
+            if (!candidate)
+                continue;
+            if (!fs.existsSync(candidate))
+                continue;
+            if (process.platform === 'win32') {
+                const ext = path.extname(candidate).toLowerCase();
+                if (ext === '.cmd' || ext === '.exe' || ext === '.bat')
+                    return candidate;
+                const cmdSibling = candidate + '.cmd';
+                if (fs.existsSync(cmdSibling))
+                    return cmdSibling;
+                continue;
+            }
+            return candidate;
+        }
     }
-    catch {
-        return null;
+    catch { /* not in PATH */ }
+    const candidates = process.platform === 'win32'
+        ? [
+            path.join(HOME, 'AppData', 'Roaming', 'npm', 'greprag.cmd'),
+            path.join(HOME, 'AppData', 'Roaming', 'npm', 'greprag'),
+            path.join(HOME, 'AppData', 'Local', 'Yarn', 'bin', 'greprag.cmd'),
+            path.join(HOME, 'AppData', 'Local', 'pnpm', 'bin', 'greprag.cmd'),
+        ]
+        : [
+            '/usr/local/bin/greprag',
+            '/opt/homebrew/bin/greprag',
+            path.join(HOME || '', '.local', 'bin', 'greprag'),
+            path.join(HOME || '', '.yarn', 'bin', 'greprag'),
+        ];
+    for (const c of candidates) {
+        try {
+            if (c && fs.existsSync(c))
+                return c;
+        }
+        catch { /* skip */ }
     }
+    return null;
 }
-/** Walk up from cwd looking for an anchor file. Checks canonical `.greprag/`
- *  first, then legacy `.claude/` and `.opencode/` at each level. Returns the
- *  first hit. Skips home-level globals; those are reserved for the
- *  ephemeral-cwd path of the cascade. */
-function findExistingAnchorFile(startDir) {
-    const globalAnchorPath = path.join(HOME, '.greprag', 'project.json');
-    const legacyGlobalAnchorPath = path.join(HOME, '.claude', 'project.json');
-    let dir = path.resolve(startDir);
-    while (true) {
-        for (const subdir of ['.greprag', '.claude', '.opencode']) {
-            const candidate = path.join(dir, subdir, 'project.json');
-            if (candidate !== globalAnchorPath && candidate !== legacyGlobalAnchorPath && fs.existsSync(candidate)) {
-                return candidate;
+function tryClaimWatcherLock() {
+    try {
+        const fd = fs.openSync(WATCHER_LOCK, 'wx');
+        return { ok: true, fd };
+    }
+    catch (err) {
+        if (err.code !== 'EEXIST') {
+            return { ok: false, reason: 'lock-create-failed' };
+        }
+        // Lockfile exists. Stale if mtime is old OR the recorded PID is dead.
+        try {
+            const stat = fs.statSync(WATCHER_LOCK);
+            const ageMs = Date.now() - stat.mtimeMs;
+            let pidAlive = false;
+            try {
+                const pid = parseInt(fs.readFileSync(WATCHER_LOCK, 'utf-8').trim(), 10);
+                pidAlive = pid > 0 && isPidAlive(pid);
             }
+            catch { /* unreadable — treat as stale */ }
+            if (ageMs < WATCHER_STALE_MS && pidAlive) {
+                return { ok: false, reason: 'busy' };
+            }
+            // Stale — remove and retry once.
+            try {
+                fs.unlinkSync(WATCHER_LOCK);
+            }
+            catch { /* raced */ }
+            const fd = fs.openSync(WATCHER_LOCK, 'wx');
+            return { ok: true, fd };
+        }
+        catch (err2) {
+            return { ok: false, reason: 'lock-stale-replace-failed' };
         }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
     }
 }
-/** Format the SHA-256 of an input string into a deterministic UUID v4-shape
- *  string. Must match the algorithm in packages/cli/src/project-anchor.ts so
- *  the plugin resolves identical IDs to the Claude Code CLI. */
-function formatUuid(hashHex) {
-    return [
-        hashHex.slice(0, 8),
-        hashHex.slice(8, 12),
-        '4' + hashHex.slice(13, 16),
-        '8' + hashHex.slice(17, 20),
-        hashHex.slice(20, 32),
-    ].join('-');
-}
-/** Derive a stable project_id from the repo's root commit SHA. Sorted +
- *  hashed so disjoint-history merges produce one deterministic id everywhere.
- *  Returns null when cwd isn't a git repo or has no commits yet. */
-function computeGitDerivedProjectId(cwd) {
+function startCaptureWatcher() {
+    if (process.env.GREPRAG_OPENCODE_CAPTURE === '0')
+        return;
+    if (process.env.MEMORY_HOOK_ENABLED !== 'true')
+        return;
+    if (!process.env.GREPRAG_API_KEY)
+        return;
+    const grepragBin = findGrepragBinary();
+    if (!grepragBin) {
+        process.stderr.write('[greprag-memory] opencode watch could not start: greprag binary not in PATH. ' +
+            'Run `npm install -g @greprag/cli` or set GREPRAG_BIN.\n');
+        return;
+    }
+    const claim = tryClaimWatcherLock();
+    if (!claim.ok) {
+        if (claim.reason === 'busy') {
+            process.stderr.write('[greprag-memory] opencode watch already running; not spawning\n');
+        }
+        else {
+            process.stderr.write(`[greprag-memory] opencode watch could not claim lock: ${claim.reason}\n`);
+        }
+        return;
+    }
+    // Seed the lockfile with the parent PID; spawn() will rewrite it with the
+    // child PID once the watcher is alive. If spawn itself throws, release.
     try {
-        const out = (0, child_process_1.execSync)('git rev-list --max-parents=0 HEAD', {
-            cwd,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        const roots = out.trim().split(/\s+/).filter(Boolean).sort();
-        if (roots.length === 0)
-            return null;
-        const hash = crypto.createHash('sha256').update(roots.join('\n')).digest('hex');
-        return formatUuid(hash);
+        fs.writeSync(claim.fd, String(process.pid));
+        fs.closeSync(claim.fd);
     }
     catch {
-        return null;
+        try {
+            fs.unlinkSync(WATCHER_LOCK);
+        }
+        catch { /* raced */ }
+        return;
     }
-}
-/** Hash the cwd path into a stable UUID. Last-resort fallback — when no git
- *  history and no anchor file exist, this keeps capture flowing under a
- *  per-path identity that `greprag doctor` can later consolidate. */
-function deterministicProjectId(cwd) {
-    const normalized = path.resolve(cwd).toLowerCase();
-    const hash = crypto.createHash('sha256').update(normalized).digest('hex');
-    return formatUuid(hash);
-}
-/** True when cwd is an ephemeral session path (Cowork, tmp dirs). The
- *  deterministic-hash fallback would mint a fresh id every session in those
- *  paths, so we prefer the global anchor instead. */
-function isEphemeralCwd(cwd) {
-    const norm = path.resolve(cwd).replace(/\\/g, '/').toLowerCase();
-    if (norm.includes('/appdata/roaming/claude/local-agent-mode-sessions/'))
-        return true;
-    if (norm.includes('/appdata/local/claude/local-agent-mode-sessions/'))
-        return true;
-    if (norm.startsWith('/tmp/'))
-        return true;
-    if (norm.startsWith('/var/tmp/'))
-        return true;
-    if (norm.startsWith('/private/tmp/'))
-        return true;
-    return false;
-}
-/** Resolve the project anchor for `worktree` using the same 4-level cascade
- *  the Claude Code CLI uses (packages/cli/src/project-anchor.ts). Settings
- *  always come from the nearest repo-level file when one exists, regardless
- *  of which identity level resolved.
- *
- *    1. Anchor file with explicit `project_id` → file-based identity
- *    2. Git repo with at least one commit → root-commit-derived UUID
- *    3. Ephemeral cwd + ~/.greprag/project.json exists → global anchor
- *    4. Path-hash fallback (never returns null; lets capture flow until
- *       `greprag init` runs and `greprag doctor` consolidates) */
-function readAnchor(worktree) {
-    const filePath = findExistingAnchorFile(worktree);
-    const file = filePath ? readAnchorFile(filePath) : null;
-    const root = path.resolve(worktree);
-    // 1. File with explicit project_id
-    if (file && file.projectId && file.projectName) {
-        return {
-            projectId: file.projectId,
-            projectName: file.projectName,
-            memoryCapture: file.memoryCapture,
-            sessionStartRecap: file.sessionStartRecap,
-            inboxNotify: file.inboxNotify,
-        };
+    let stopped = false;
+    let currentChildPid = null;
+    let currentChild = null;
+    let respawnCount = 0;
+    let childStartTime = 0;
+    const MAX_RESPAWNS = 10;
+    const MAX_BACKOFF_MS = 30_000;
+    function tryReclaimLockForRespawn() {
+        // Re-claim via the same stale-detection path the first claim used. Handles
+        // (a) another opencode instance owning the lock now → yield; (b) a stale
+        // lockfile left by our just-killed child (SIGKILL bypasses the watcher's
+        // own releaseLockFile) → remove and reclaim.
+        const claim = tryClaimWatcherLock();
+        if (claim.ok) {
+            try {
+                fs.writeSync(claim.fd, String(process.pid));
+                fs.closeSync(claim.fd);
+            }
+            catch {
+                try {
+                    fs.unlinkSync(WATCHER_LOCK);
+                }
+                catch { /* raced */ }
+                return false;
+            }
+            return true;
+        }
+        if (claim.reason === 'busy') {
+            process.stderr.write('[greprag-memory] lockfile claimed by another opencode instance; not respawning\n');
+        }
+        else {
+            process.stderr.write(`[greprag-memory] respawn lockfile error: ${claim.reason}\n`);
+        }
+        return false;
     }
-    // 2. Git-derived identity. Settings layer in from the settings-only file
-    // when one exists; otherwise defaults apply.
-    const gitId = computeGitDerivedProjectId(worktree);
-    if (gitId) {
-        return {
-            projectId: gitId,
-            projectName: file?.projectName || path.basename(root).toLowerCase(),
-            memoryCapture: file?.memoryCapture ?? true,
-            sessionStartRecap: file?.sessionStartRecap ?? true,
-            inboxNotify: file?.inboxNotify ?? 'every_turn',
-        };
+    function spawnWatcher() {
+        if (stopped)
+            return;
+        if (!grepragBin)
+            return; // type narrow for closure capture
+        let child;
+        try {
+            child = (0, child_process_1.spawn)(grepragBin, ['opencode', 'watch'], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: process.env,
+                windowsHide: true,
+                shell: process.platform === 'win32',
+            });
+        }
+        catch (err) {
+            process.stderr.write(`[greprag-memory] spawn failed: ${err.message}\n`);
+            scheduleRespawn();
+            return;
+        }
+        currentChild = child;
+        currentChildPid = child.pid ?? null;
+        childStartTime = Date.now();
+        try {
+            fs.writeFileSync(WATCHER_LOCK, String(child.pid));
+        }
+        catch { /* best effort */ }
+        child.stderr?.on('data', (chunk) => {
+            process.stderr.write(`[greprag-watch] ${chunk.toString('utf-8')}`);
+        });
+        child.stdout?.on('data', (chunk) => {
+            process.stderr.write(`[greprag-watch] ${chunk.toString('utf-8')}`);
+        });
+        child.on('exit', (code, signal) => {
+            // Only release the lock if it still names OUR child — never yank
+            // a lockfile that another opencode instance now owns (mtime-vs-pid
+            // race window).
+            try {
+                const current = fs.readFileSync(WATCHER_LOCK, 'utf-8').trim();
+                if (current === String(child.pid))
+                    fs.unlinkSync(WATCHER_LOCK);
+            }
+            catch { /* raced */ }
+            currentChild = null;
+            currentChildPid = null;
+            if (stopped)
+                return;
+            const cleanShutdown = code === 0 || signal === 'SIGTERM' || signal === 'SIGKILL';
+            if (!cleanShutdown) {
+                process.stderr.write(`[greprag-memory] opencode watch exited code=${code} signal=${signal || 'none'}, respawning\n`);
+            }
+            scheduleRespawn();
+        });
     }
-    // 3. Ephemeral cwd + global anchor
-    if (isEphemeralCwd(worktree)) {
-        const canonicalGlobal = path.join(HOME, '.greprag', 'project.json');
-        const legacyGlobal = path.join(HOME, '.claude', 'project.json');
-        const globalPath = fs.existsSync(canonicalGlobal) ? canonicalGlobal : legacyGlobal;
-        const globalFile = fs.existsSync(globalPath) ? readAnchorFile(globalPath) : null;
-        if (globalFile && globalFile.projectId && globalFile.projectName) {
-            return {
-                projectId: globalFile.projectId,
-                projectName: globalFile.projectName,
-                memoryCapture: globalFile.memoryCapture,
-                sessionStartRecap: globalFile.sessionStartRecap,
-                inboxNotify: globalFile.inboxNotify,
-            };
-        }
-    }
-    // 4. Path-hash fallback — keep capture flowing for uninitialized repos.
-    return {
-        projectId: deterministicProjectId(worktree),
-        projectName: file?.projectName || path.basename(root).toLowerCase(),
-        memoryCapture: file?.memoryCapture ?? true,
-        sessionStartRecap: file?.sessionStartRecap ?? true,
-        inboxNotify: file?.inboxNotify ?? 'every_turn',
+    function scheduleRespawn() {
+        if (stopped)
+            return;
+        // Reset the backoff counter if the child ran for a meaningful interval
+        // before dying — that's a healthy watcher, not a tight crash loop.
+        if (Date.now() - childStartTime > 30_000)
+            respawnCount = 0;
+        respawnCount++;
+        if (respawnCount > MAX_RESPAWNS) {
+            process.stderr.write(`[greprag-memory] opencode watch respawned ${respawnCount} times; giving up. ` +
+                'Run `greprag doctor` to investigate.\n');
+            try {
+                fs.unlinkSync(WATCHER_LOCK);
+            }
+            catch { /* raced */ }
+            return;
+        }
+        if (!tryReclaimLockForRespawn())
+            return;
+        const backoff = Math.min(MAX_BACKOFF_MS, 1000 * Math.pow(2, Math.min(respawnCount, 5)));
+        process.stderr.write(`[greprag-memory] respawning opencode watch in ${Math.round(backoff / 1000)}s ` +
+            `(attempt ${respawnCount}/${MAX_RESPAWNS})\n`);
+        setTimeout(spawnWatcher, backoff).unref();
+    }
+    spawnWatcher();
+    // Clean teardown when opencode (the parent) exits. Only kill OUR child
+    // — never a child owned by another opencode instance that may now hold
+    // the lock.
+    const cleanup = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        if (currentChild) {
+            try {
+                currentChild.kill('SIGTERM');
+            }
+            catch { /* already dead */ }
+            setTimeout(() => {
+                try {
+                    currentChild?.kill('SIGKILL');
+                }
+                catch { /* already dead */ }
+            }, 2000).unref();
+        }
+        try {
+            fs.unlinkSync(WATCHER_LOCK);
+        }
+        catch { /* raced */ }
     };
+    process.on('exit', cleanup);
+    process.on('SIGINT', () => { cleanup(); process.exit(0); });
+    process.on('SIGTERM', () => { cleanup(); process.exit(0); });
 }
-// ============================================================================
-// Envelope construction (real opencode Part schema)
-// ============================================================================
-function extractText(parts) {
-    const out = [];
-    for (const p of parts) {
-        if (p.type !== 'text')
-            continue;
-        const tp = p;
-        if (tp.synthetic || tp.ignored)
-            continue;
-        if (tp.text)
-            out.push(tp.text);
-    }
-    return out.join('\n').trim();
-}
-/** Pull a one-line summary out of each tool call: name + a target string + an
- *  optional brief for shell commands. Mirrors the shape the Claude Code hook
- *  posts so server-side compaction sees identical structure regardless of
- *  client origin. */
-function extractToolCalls(parts) {
-    const calls = [];
-    for (const p of parts) {
-        if (p.type !== 'tool')
-            continue;
-        const tp = p;
-        const name = tp.tool || 'unknown';
-        const input = (tp.state && tp.state.input) || {};
-        const call = { name };
-        if (input.command !== undefined) {
-            const desc = input.description;
-            call.target =
-                typeof desc === 'string' && desc
-                    ? desc
-                    : String(input.command).split(/\s+/)[0] || '';
-            const cmd = String(input.command);
-            call.brief = cmd.length > 800 ? cmd.slice(0, 800) + '…' : cmd;
-        }
-        else if (typeof input.file_path === 'string') {
-            call.target = input.file_path;
-        }
-        else if (typeof input.filePath === 'string') {
-            call.target = input.filePath;
-        }
-        else if (typeof input.pattern === 'string') {
-            call.target = input.pattern;
-        }
-        else if (typeof input.url === 'string') {
-            call.target = input.url;
-        }
-        else if (typeof input.query === 'string') {
-            call.target = input.query;
-        }
-        calls.push(call);
-    }
-    return calls;
-}
-function extractFilesTouched(parts) {
-    const files = new Set();
-    for (const p of parts) {
-        if (p.type !== 'tool')
-            continue;
-        const tp = p;
-        const input = (tp.state && tp.state.input) || {};
-        if (typeof input.file_path === 'string')
-            files.add(input.file_path);
-        if (typeof input.filePath === 'string')
-            files.add(input.filePath);
-    }
-    return Array.from(files).sort();
-}
-function classifyUserText(text) {
-    const t = (text || '').trimStart();
-    if (!t)
-        return 'session-turn';
-    if (/^Base directory for this skill:/.test(t))
-        return 'skill-injection';
-    if (/^This session is being continued from a previous conversation/.test(t)) {
-        return 'continuation-summary';
-    }
-    if (/^You are a .{0,60}\bchip\b/.test(t) ||
-        (/\bgit worktree add\b/.test(t) &&
-            /(^|\n)\s*(\*\*Setup\b|Chip:|#\s*Chip\b|report back\b)/m.test(t))) {
-        return 'chip-prompt';
-    }
-    return 'session-turn';
-}
-function provenanceElisionMarker(p, text) {
-    const label = p === 'skill-injection' ? 'skill body' :
-        p === 'continuation-summary' ? 'context-continuation summary' :
-            p === 'chip-prompt' ? 'chip task prompt' : 'injected text';
-    let hint = '';
-    if (p === 'skill-injection') {
-        const m = (text || '').match(/skills[/\\]([A-Za-z0-9._-]+)/) ||
-            (text || '').match(/^#\s+(.+)$/m);
-        if (m)
-            hint = ` (${m[1].trim().slice(0, 40)})`;
-    }
-    return `[greprag: harness-injected ${label}${hint} elided from episodic capture]`;
-}
-function buildEnvelope(userParts, assistantParts, errored) {
-    // Elide harness-injected user text pre-LLM at capture (see the classifier
-    // above). The marker replaces the 1-6k-word block so it never reaches the
-    // server / content_tsv.
-    const rawUser = extractText(userParts);
-    const provenance = classifyUserText(rawUser);
-    const userPrompt = provenance === 'session-turn'
-        ? rawUser
-        : provenanceElisionMarker(provenance, rawUser);
-    return {
-        userPrompt,
-        agentResponse: extractText(assistantParts),
-        toolCalls: extractToolCalls(assistantParts),
-        filesTouched: extractFilesTouched(assistantParts),
-        status: errored ? 'errored' : 'completed',
-        provenance,
-    };
+startCaptureWatcher();
+function getEnv(key) {
+    return process.env[key] || '';
 }
 // ============================================================================
 // API calls (fire-and-forget; never block the LLM)
@@ -439,124 +520,327 @@ async function storeTurn(anchor, sessionID, envelope, workingDir) {
 }
 async function fetchRecapInbox(anchor) {
     const apiKey = getEnv('GREPRAG_API_KEY');
-    if (!apiKey)
+    if (!apiKey) {
+        dlog('fetchRecapInbox: no API key — returning empty');
+        return [];
+    }
+    if (!anchor.sessionStartRecap) {
+        dlog(`sessionStartRecap=false on anchor — skipping memory fetch (per-project opt-out)`);
         return [];
-    const lines = [];
-    const now = new Date();
-    const weekAgo = new Date(now.getTime() - 7 * 86400000).toISOString();
-    const toIso = now.toISOString();
-    if (anchor.sessionStartRecap) {
+    }
+    // Recap body is the SAME renderer hook.ts uses at SessionStart. Single
+    // source of truth lives in opencode-plugin-helpers.buildRecapBody — the
+    // type=hourly / 2d window / 24h cutoff / HOURLY_CAP / "Recent sessions:"
+    // framing all come from there. Opencode has no SessionStart hook, so the
+    // closest equivalent is the system-transform pre-LLM fire; we push the
+    // rendered body straight onto output.system. No parallel implementation.
+    const body = await buildRecapBody(API_URL, apiKey, anchor);
+    dlog(`buildRecapBody returned ${body.length} chars (projectId=${anchor.projectId})`);
+    if (!body)
+        return [];
+    return [body];
+}
+// ============================================================================
+// Per-session state. Plugin function runs once at opencode boot, so this state
+// lives for the lifetime of the opencode process and is shared across every
+// session that process handles.
+// ============================================================================
+const relayArmedBySession = new Set();
+/** Cached recap body per projectId. opencode fires
+ *  `experimental.chat.system.transform` before EVERY LLM call (not just the
+ *  first), and each call has a fresh `output.system` — so the previous
+ *  "first fire per session" dedup meant the recap was in fire 1's system
+ *  prompt only, leaving later turns with no recap. (Dlog would show one
+ *  `pushed 1 recap lines`; assistant would still report "no recap" in
+ *  later turns because the system prompt had been reset.) New behavior:
+ *  push on every fire. The fetch only runs on the first fire per project
+ *  (or when the cache expires / projectId changes); subsequent fires use
+ *  the cached body. Trades a one-time ~150ms fetch for a ~700-char push on
+ *  every LLM call — small enough to be cheap, big enough to be useful. */
+let cachedRecap = null;
+const RECAP_CACHE_TTL_MS = 5 * 60_000;
+// ============================================================================
+// Per-session relay spawner — "anytime opencode is opened and being used"
+// ============================================================================
+// The opencode plugin surface has no explicit "session_start" hook —
+// `experimental.chat.system.transform` fires before every LLM call. We arm
+// the relay on the first fire per session (`relayArmedBySession` Set) so
+// the spawn runs at most once per session per opencode boot.
+//
+// Per-session lockfile at ~/.greprag/relay.<session8hex>.pid — same shape as
+// WATCHER_LOCK, with a 30s mtime + dead-PID sweep. Multiple opencode windows
+// pointing at the same session naturally dedup to one relay.
+//
+// The spawned relay is detached (stdio: 'ignore', windowsHide: true) and
+// wrapped in the same respawn-with-backoff pattern as startCaptureWatcher.
+// On opencode exit, the SIGTERM + SIGKILL cleanup runs the same way. The
+// relay's own `process.exit(1)` after 5 consecutive delivery failures gives
+// the respawner an honest signal to stop trying when opencode is gone for
+// real. Max 10 respawns; the user sees a "run `greprag doctor`" hint at the
+// end.
+function startSessionRelay(sessionId, serverUrl) {
+    if (process.env.GREPRAG_OPENCODE_RELAY === '0')
+        return;
+    if (process.env.MEMORY_HOOK_ENABLED !== 'true')
+        return;
+    if (!process.env.GREPRAG_API_KEY)
+        return;
+    if (relayArmedBySession.has(sessionId))
+        return;
+    relayArmedBySession.add(sessionId);
+    const grepragBin = findGrepragBinary();
+    if (!grepragBin) {
+        process.stderr.write('[greprag-memory] relay could not start: greprag binary not in PATH. ' +
+            'Run `npm install -g @greprag/cli` or set GREPRAG_BIN.\n');
+        return;
+    }
+    const lockPath = relayLockPath(sessionId);
+    const claim = tryClaimRelayLock(lockPath);
+    if (!claim.ok) {
+        if (claim.reason === 'busy') {
+            process.stderr.write(`[greprag-memory] relay for session ${sessionId} already running; not spawning\n`);
+        }
+        else {
+            process.stderr.write(`[greprag-memory] relay lockfile error: ${claim.reason}\n`);
+        }
+        return;
+    }
+    try {
+        fs.writeSync(claim.fd, String(process.pid));
+        fs.closeSync(claim.fd);
+    }
+    catch {
         try {
-            const res = await fetch(`${API_URL}/v1/memory/by-period?projectId=${anchor.projectId}&from=${encodeURIComponent(weekAgo)}&to=${encodeURIComponent(toIso)}&type=daily&limit=7`, { headers: { Authorization: `Bearer ${apiKey}` } });
-            if (res.ok) {
-                const data = (await res.json());
-                if (data.memories && data.memories.length > 0) {
-                    lines.push(`[GrepRAG memory: ${anchor.projectName}]`);
-                    for (const m of data.memories) {
-                        const date = m.windowStart ? m.windowStart.slice(0, 10) : '';
-                        lines.push(`[${date}] ${m.content}`);
-                    }
+            fs.unlinkSync(lockPath);
+        }
+        catch { /* raced */ }
+        return;
+    }
+    let stopped = false;
+    let currentChild = null;
+    let respawnCount = 0;
+    let childStartTime = 0;
+    const MAX_RESPAWNS = 10;
+    const MAX_BACKOFF_MS = 30_000;
+    function tryReclaimLockForRespawn() {
+        const claim = tryClaimRelayLock(lockPath);
+        if (claim.ok) {
+            try {
+                fs.writeSync(claim.fd, String(process.pid));
+                fs.closeSync(claim.fd);
+            }
+            catch {
+                try {
+                    fs.unlinkSync(lockPath);
                 }
+                catch { /* raced */ }
+                return false;
             }
+            return true;
         }
-        catch { }
+        if (claim.reason === 'busy') {
+            process.stderr.write(`[greprag-memory] relay lockfile claimed by another process; not respawning\n`);
+        }
+        return false;
     }
-    if (anchor.inboxNotify !== 'off') {
+    function spawnRelay() {
+        if (stopped)
+            return;
+        let child;
         try {
-            const res = await fetch(`${API_URL}/v1/inbox?count_only=1&projectId=${anchor.projectId}`, { headers: { Authorization: `Bearer ${apiKey}` } });
-            if (res.ok) {
-                const data = (await res.json());
-                if (typeof data.unread_count === 'number' && data.unread_count > 0) {
-                    lines.push(`[${data.unread_count} unread in inbox]`);
-                }
+            child = (0, child_process_1.spawn)(grepragBin, ['opencode', 'relay', '--session', sessionId, '--opencode-url', serverUrl], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: process.env,
+                windowsHide: true,
+                shell: process.platform === 'win32',
+            });
+        }
+        catch (err) {
+            process.stderr.write(`[greprag-relay] spawn failed: ${err.message}\n`);
+            scheduleRespawn();
+            return;
+        }
+        currentChild = child;
+        childStartTime = Date.now();
+        try {
+            fs.writeFileSync(lockPath, String(child.pid));
+        }
+        catch { /* best effort */ }
+        child.stderr?.on('data', (chunk) => {
+            process.stderr.write(`[greprag-relay] ${chunk.toString('utf-8')}`);
+        });
+        child.stdout?.on('data', (chunk) => {
+            process.stderr.write(`[greprag-relay] ${chunk.toString('utf-8')}`);
+        });
+        child.on('exit', (code, signal) => {
+            try {
+                const current = fs.readFileSync(lockPath, 'utf-8').trim();
+                if (current === String(child.pid))
+                    fs.unlinkSync(lockPath);
+            }
+            catch { /* raced */ }
+            currentChild = null;
+            if (stopped)
+                return;
+            if (code !== 0 && signal !== 'SIGTERM' && signal !== 'SIGKILL') {
+                process.stderr.write(`[greprag-memory] relay for ${sessionId} exited code=${code} signal=${signal || 'none'}, respawning\n`);
             }
+            scheduleRespawn();
+        });
+    }
+    function scheduleRespawn() {
+        if (stopped)
+            return;
+        if (Date.now() - childStartTime > 30_000)
+            respawnCount = 0;
+        respawnCount++;
+        if (respawnCount > MAX_RESPAWNS) {
+            process.stderr.write(`[greprag-memory] relay for ${sessionId} respawned ${respawnCount} times; giving up. ` +
+                'Run `greprag doctor` to investigate.\n');
+            try {
+                fs.unlinkSync(lockPath);
+            }
+            catch { /* raced */ }
+            return;
         }
-        catch { }
+        if (!tryReclaimLockForRespawn())
+            return;
+        const backoff = Math.min(MAX_BACKOFF_MS, 1000 * Math.pow(2, Math.min(respawnCount, 5)));
+        process.stderr.write(`[greprag-memory] respawning relay for ${sessionId} in ${Math.round(backoff / 1000)}s ` +
+            `(attempt ${respawnCount}/${MAX_RESPAWNS})\n`);
+        setTimeout(spawnRelay, backoff).unref();
     }
-    return lines;
+    spawnRelay();
+    const cleanup = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        if (currentChild) {
+            try {
+                currentChild.kill('SIGTERM');
+            }
+            catch { /* already dead */ }
+            setTimeout(() => {
+                try {
+                    currentChild?.kill('SIGKILL');
+                }
+                catch { /* already dead */ }
+            }, 2000).unref();
+        }
+        try {
+            fs.unlinkSync(lockPath);
+        }
+        catch { /* raced */ }
+    };
+    process.on('exit', cleanup);
+    process.on('SIGINT', () => { cleanup(); process.exit(0); });
+    process.on('SIGTERM', () => { cleanup(); process.exit(0); });
 }
 // ============================================================================
-// Per-session state. Plugin function runs once at opencode boot, so this state
-// lives for the lifetime of the opencode process and is shared across every
-// session that process handles. Both sets key on opencode's canonical IDs
-// (sessionID and assistant-message id) so they're correct across sessions.
-// ============================================================================
-const recapInjectedBySession = new Set();
-const storedAssistantMessageIds = new Set();
-// ============================================================================
 // Plugin entry point
 // ============================================================================
 const GrepRAGMemoryPlugin = async (ctx) => {
+    dlog(`plugin function INVOKED (this is the entry opencode calls)`);
     const apiKey = getEnv('GREPRAG_API_KEY');
     const enabled = getEnv('MEMORY_HOOK_ENABLED') === 'true';
-    if (!enabled || !apiKey)
+    dlog(`plugin invoked: enabled=${enabled} apiKeySet=${!!apiKey} worktree=${ctx.worktree} directory=${ctx.directory}`);
+    if (!enabled || !apiKey) {
+        dlog(`bailing: env gate closed (enabled=${enabled} apiKeySet=${!!apiKey}). No hooks will register.`);
         return {};
-    const anchor = readAnchor(ctx.worktree);
+    }
     const client = ctx.client;
-    const workingDir = ctx.directory || ctx.worktree;
+    const fallbackAnchor = readAnchor(ctx.worktree);
+    const fallbackWorkingDir = ctx.directory || ctx.worktree;
+    /** Resolve the project anchor + workingDir for a given session. Uses the
+     *  session's `directory` (which is the workspace path, e.g. C:\greprag)
+     *  rather than the sidecar's worktree (which is the home dir when the
+     *  user opens opencode Desktop from ~). Falls back to the boot context
+     *  if the session fetch fails. */
+    async function resolveSessionContext(sessionID) {
+        try {
+            const session = await client.session.get({ path: { id: sessionID } });
+            const dir = session && (session.directory || session.path);
+            if (typeof dir === 'string' && dir) {
+                return { anchor: readAnchor(dir), workingDir: dir };
+            }
+        }
+        catch {
+            // session not reachable — fall through to fallback
+        }
+        return { anchor: fallbackAnchor, workingDir: fallbackWorkingDir };
+    }
     return {
         'experimental.chat.system.transform': async (input, output) => {
             const sid = input && input.sessionID;
-            if (!sid)
-                return;
-            if (recapInjectedBySession.has(sid))
-                return;
-            recapInjectedBySession.add(sid);
-            const recap = await fetchRecapInbox(anchor);
-            if (recap.length > 0) {
-                output.system.push(recap.join('\n'));
+            const sidShort = sid ? (sid.replace(/[^0-9a-f]/gi, '').slice(0, 8) || sid.slice(0, 8)) : '<none>';
+            dlog(`hook fired sid=${sidShort}… model=${input?.model?.modelID || input?.model?.id || '?'}`);
+            // Arm the inbox-to-opencode relay for this session on the first LLM
+            // call. The Set dedup means this runs at most once per session per
+            // opencode boot. Failures (no greprag binary, lock contention) log
+            // to stderr and are non-fatal — the plugin's other responsibilities
+            // continue. Skipped when sessionID is missing (relay lockfile is
+            // keyed on the 8-hex session id).
+            if (sid && !relayArmedBySession.has(sid)) {
+                relayArmedBySession.add(sid);
+                startSessionRelay(sid, ctx.serverUrl.toString());
             }
-        },
-        event: async ({ event }) => {
-            if (!anchor.memoryCapture)
-                return;
-            if (!event || event.type !== 'message.updated')
-                return;
-            const info = event.properties && event.properties.info;
-            if (!info || info.role !== 'assistant')
-                return;
-            const completed = info.time && typeof info.time.completed === 'number';
-            if (!completed)
-                return;
-            if (storedAssistantMessageIds.has(info.id))
-                return;
-            storedAssistantMessageIds.add(info.id);
-            let allMessages;
-            try {
-                allMessages = await client.session.messages({
-                    path: { id: info.sessionID },
-                });
+            // Resolve anchor — the session's directory is canonical,
+            // fallbackAnchor is the closure's boot-time directory (used when sid
+            // is absent)
+            const anchor = sid ? (await resolveSessionContext(sid)).anchor : fallbackAnchor;
+            // Recap body is per-project (not per-session) and changes slowly, so
+            // we cache it. Push on every fire so the LLM sees the recap in ALL
+            // turns, not just the first. See module-level `cachedRecap` comment
+            // for the dedup regression this replaces.
+            let body;
+            if (cachedRecap &&
+                cachedRecap.projectId === anchor.projectId &&
+                Date.now() - cachedRecap.fetchedAt < RECAP_CACHE_TTL_MS) {
+                body = cachedRecap.body;
+                dlog(`recap cache hit for projectId=${anchor.projectId} (${body.length} chars, age=${Math.round((Date.now() - cachedRecap.fetchedAt) / 1000)}s)`);
             }
-            catch {
-                return;
+            else {
+                dlog(`resolving recap: projectId=${anchor.projectId} ` +
+                    `projectName=${anchor.projectName} ` +
+                    `sessionStartRecap=${anchor.sessionStartRecap} ` +
+                    `inboxNotify=${anchor.inboxNotify}`);
+                const recap = await fetchRecapInbox(anchor);
+                body = recap.join('\n');
+                cachedRecap = { projectId: anchor.projectId || '', body, fetchedAt: Date.now() };
+                dlog(`buildRecapBody returned ${body.length} chars (projectId=${anchor.projectId})`);
+                if (body) {
+                    dlog(`recap content (${body.length} chars):\n---\n${body}\n---`);
+                }
             }
-            const assistantWithParts = allMessages.find((m) => m.info.id === info.id);
-            if (!assistantWithParts)
-                return;
-            const userWithParts = allMessages.find((m) => m.info.id === info.parentID);
-            if (!userWithParts)
-                return;
-            const errored = !!info.error;
-            const envelope = buildEnvelope(userWithParts.parts, assistantWithParts.parts, errored);
-            if (!envelope.userPrompt &&
-                !envelope.agentResponse &&
-                envelope.toolCalls.length === 0) {
-                return;
+            if (body) {
+                pushSystemPrompt(output, body);
+                dlog(`pushed recap to system prompt for sid=${sidShort}… (output.system is ${Array.isArray(output.system) ? 'string[]' : typeof output.system}, body=${body.length} chars)`);
+            }
+            else {
+                dlog(`recap empty for sid=${sidShort}… (no memories in window, no unread inbox)`);
             }
-            await storeTurn(anchor, info.sessionID, envelope, workingDir);
         },
     };
 };
-exports.GrepRAGMemoryPlugin = GrepRAGMemoryPlugin;
-// V1 plugin export shape (preferred by opencode's loader). The legacy named
-// export is kept as a fallback for older loader code paths.
-exports.default = { server: GrepRAGMemoryPlugin, id: 'greprag-memory' };
-// Exposed for unit tests — never imported by opencode at runtime.
-exports.__test = {
-    extractText,
-    extractToolCalls,
-    extractFilesTouched,
-    buildEnvelope,
-    readAnchor,
+/** Append `body` to `output.system` defensively. opencode's hook contract
+ *  types `output.system` as `string[]`, but other plugins (opencode-rules)
+ *  report it can also arrive as a `string` depending on runtime/version. We
+ *  handle both shapes — push for arrays, concatenate with `\n\n` separator
+ *  for strings, replace when empty/undefined. Mirrors opencode-rules's
+ *  pattern; see adr/opencode-monitor-relay.md 2026-06-06 (h). */
+function pushSystemPrompt(output, body) {
+    if (Array.isArray(output.system)) {
+        output.system.push(body);
+    }
+    else if (typeof output.system === 'string' && output.system.length > 0) {
+        output.system = `${output.system}\n\n${body}`;
+    }
+    else {
+        output.system = body;
+    }
+}
+module.exports = {
+    id: 'greprag-memory',
+    server: GrepRAGMemoryPlugin,
 };
 //# sourceMappingURL=opencode-plugin.js.map