@sage-protocol/sage-plugin 0.1.4

package/README.md

@@ -0,0 +1,37 @@
+# Sage Plugin (OpenCode)
+
+Unified OpenCode plugin for Scroll that handles both prompt capture (for RLM feedback) and inline skill/prompt suggestions.
+
+## Requirements
+- Bun runtime (tested with 1.3+)
+- `scroll` CLI available in PATH (or set `SCROLL_BIN`)
+
+## Setup
+1. Copy the plugin into OpenCode plugins (scoped name retained):
+   ```bash
+   mkdir -p ~/.config/opencode/plugin
+   mkdir -p ~/.config/opencode/plugin/@sage-protocol
+   cp -r sage-plugin ~/.config/opencode/plugin/@sage-protocol/
+   ```
+2. Ensure `opencode.json` includes the plugin:
+   ```json
+   {
+     "plugin": ["@sage-protocol/sage-plugin"],
+     "mcp": { "scroll": { "type": "local", "command": ["scroll", "mcp", "start"], "enabled": true } }
+   }
+   ```
+   (running `scroll init --opencode` will add this automatically.)
+
+## Environment
+- `SCROLL_BIN`: override scroll binary path
+- `SCROLL_SUGGEST_LIMIT`: suggestions per request (default 3)
+- `SCROLL_SUGGEST_DEBOUNCE_MS`: debounce for TUI suggestions (default 800ms)
+- `SCROLL_SUGGEST_PROVISION`: set `0` to skip MCP provisioning
+- `SCROLL_PLUGIN_DRY_RUN`: set `1` to disable spawning scroll (useful for tests)
+
+## Dev
+```bash
+bun install
+bun run lint
+bun test
+```

package/biome.json

@@ -0,0 +1,9 @@
+{
+	"$schema": "https://biomejs.dev/schemas/1.7.3/schema.json",
+	"formatter": {
+		"enabled": true
+	},
+	"linter": {
+		"enabled": true
+	}
+}

package/bun.lock

@@ -0,0 +1,31 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "scroll-plugin",
+      "devDependencies": {
+        "@biomejs/biome": "^1.7.3",
+      },
+    },
+  },
+  "packages": {
+    "@biomejs/biome": ["@biomejs/biome@1.9.4", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "1.9.4", "@biomejs/cli-darwin-x64": "1.9.4", "@biomejs/cli-linux-arm64": "1.9.4", "@biomejs/cli-linux-arm64-musl": "1.9.4", "@biomejs/cli-linux-x64": "1.9.4", "@biomejs/cli-linux-x64-musl": "1.9.4", "@biomejs/cli-win32-arm64": "1.9.4", "@biomejs/cli-win32-x64": "1.9.4" }, "bin": { "biome": "bin/biome" } }, "sha512-1rkd7G70+o9KkTn5KLmDYXihGoTaIGO9PIIN2ZB7UJxFrWw04CZHPYiMRjYsaDvVV7hP1dYNRLxSANLaBFGpog=="],
+
+    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@1.9.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-bFBsPWrNvkdKrNCYeAp+xo2HecOGPAy9WyNyB/jKnnedgzl4W4Hb9ZMzYNbf8dMCGmUdSavlYHiR01QaYR58cw=="],
+
+    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@1.9.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-ngYBh/+bEedqkSevPVhLP4QfVPCpb+4BBe2p7Xs32dBgs7rh9nY2AIYUL6BgLw1JVXV8GlpKmb/hNiuIxfPfZg=="],
+
+    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@1.9.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-fJIW0+LYujdjUgJJuwesP4EjIBl/N/TcOX3IvIHJQNsAqvV2CHIogsmA94BPG6jZATS4Hi+xv4SkBBQSt1N4/g=="],
+
+    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@1.9.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-v665Ct9WCRjGa8+kTr0CzApU0+XXtRgwmzIf1SeKSGAv+2scAlW6JR5PMFo6FzqqZ64Po79cKODKf3/AAmECqA=="],
+
+    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@1.9.4", "", { "os": "linux", "cpu": "x64" }, "sha512-lRCJv/Vi3Vlwmbd6K+oQ0KhLHMAysN8lXoCI7XeHlxaajk06u7G+UsFSO01NAs5iYuWKmVZjmiOzJ0OJmGsMwg=="],
+
+    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@1.9.4", "", { "os": "linux", "cpu": "x64" }, "sha512-gEhi/jSBhZ2m6wjV530Yy8+fNqG8PAinM3oV7CyO+6c3CEh16Eizm21uHVsyVBEB6RIM8JHIl6AGYCv6Q6Q9Tg=="],
+
+    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@1.9.4", "", { "os": "win32", "cpu": "arm64" }, "sha512-tlbhLk+WXZmgwoIKwHIHEBZUwxml7bRJgk0X2sPyNR3S93cdRq6XulAZRQJ17FYGGzWne0fgrXBKpl7l4M87Hg=="],
+
+    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@1.9.4", "", { "os": "win32", "cpu": "x64" }, "sha512-8Y5wMhVIPaWe6jw2H+KlEm4wP/f7EW3810ZLmDlrEEy5KvBsb9ECEfu/kMWD484ijfQ8+nIi0giMgu9g1UAuuA=="],
+  }
+}

package/index.js

@@ -0,0 +1,378 @@
+// Scroll OpenCode plugin: capture + suggest + RLM feedback combined
+//
+// Uses the documented OpenCode plugin event handler pattern.
+// Spawns scroll commands via the `$` shell helper for portability.
+// Now includes RLM feedback appending when steering is detected.
+
+export const ScrollPlugin = async ({ client, $, directory }) => {
+	const CONFIG = {
+		scrollBin: process.env.SCROLL_BIN || "scroll",
+		suggestLimit: Number.parseInt(process.env.SCROLL_SUGGEST_LIMIT || "3", 10),
+		debounceMs: Number.parseInt(
+			process.env.SCROLL_SUGGEST_DEBOUNCE_MS || "800",
+			10,
+		),
+		provision: (process.env.SCROLL_SUGGEST_PROVISION || "1") === "1",
+		dryRun: (process.env.SCROLL_PLUGIN_DRY_RUN || "0") === "1",
+		enableRlmFeedback: (process.env.SCROLL_RLM_FEEDBACK || "1") === "1",
+	};
+
+	let promptCaptured = false;
+	let lastInput = "";
+	let lastInjected = "";
+	let timer = null;
+	let runId = 0;
+
+	// Session/model tracking (populated by chat.message hook or session.created event)
+	let currentSessionId = null;
+	let currentModel = null;
+	let assistantParts = []; // accumulate streaming text parts
+
+	// RLM Feedback tracking
+	let lastSuggestion = null;
+	let lastSuggestionTimestamp = null;
+	let lastSuggestionPromptKey = null;
+	const SUGGESTION_CORRELATION_WINDOW_MS = 30000; // 30 second window
+
+	const log = async (level, message, extra = {}) => {
+		try {
+			if (client?.app?.log) {
+				await client.app.log({
+					service: "sage-plugin",
+					level,
+					message,
+					extra,
+				});
+			} else {
+				console.log(`[sage-plugin:${level}]`, message, extra);
+			}
+		} catch {
+			/* logging should never break the plugin */
+		}
+	};
+
+	const execScroll = async (args, env = {}) => {
+		if (CONFIG.dryRun) return "";
+
+		const scrollEnv = { ...env, SCROLL_SOURCE: "opencode" };
+
+		try {
+			if ($) {
+				// Use OpenCode's $ shell helper for portability
+				const cmd = [CONFIG.scrollBin, ...args]
+					.map((a) => `'${a.replace(/'/g, "'\\''")}'`)
+					.join(" ");
+				const result = await $({ env: scrollEnv })`${cmd}`;
+				return (result?.stdout ?? result ?? "").toString().trim();
+			}
+			// Fallback to Bun.spawn if $ not available
+			if (typeof Bun !== "undefined") {
+				const proc = Bun.spawn([CONFIG.scrollBin, ...args], {
+					env: { ...process.env, ...scrollEnv },
+					stdout: "pipe",
+					stderr: "pipe",
+				});
+				const stdout = await new Response(proc.stdout).text();
+				return stdout.trim();
+			}
+			return "";
+		} catch (e) {
+			throw new Error(`scroll command failed: ${e.message || e}`);
+		}
+	};
+
+	// Parse suggestion output to extract prompt key
+	const parseSuggestionKey = (suggestionText) => {
+		// Look for patterns like "ultrawork-parallel-orchestration" or similar keys
+		// Format is typically: prompt_name (key: actual-key)
+		const keyMatch = suggestionText.match(/\(key:\s*([^)]+)\)/);
+		if (keyMatch) {
+			return keyMatch[1].trim();
+		}
+
+		// Try to match standalone keys in the text
+		const lines = suggestionText.split("\n");
+		for (const line of lines) {
+			// Look for common prompt key patterns
+			const match = line.match(/^\s*[-•*]?\s*([a-z0-9-]+)(?:\s*[-:]\s*|\s*$)/);
+			if (match?.[1]?.includes("-")) {
+				return match[1];
+			}
+		}
+
+		return null;
+	};
+
+	// Append RLM feedback to a prompt
+	const appendRlmFeedback = async (promptKey, feedbackEntry) => {
+		if (!CONFIG.enableRlmFeedback || !promptKey) {
+			return false;
+		}
+
+		try {
+			await log("debug", "appending RLM feedback", {
+				promptKey,
+				feedback: feedbackEntry,
+			});
+
+			const result = await execScroll([
+				"suggest",
+				"feedback",
+				promptKey,
+				feedbackEntry,
+				"--source",
+				"opencode-plugin",
+			]);
+
+			if (result) {
+				await log("info", "RLM feedback appended", { promptKey });
+				return true;
+			}
+		} catch (e) {
+			await log("warn", "failed to append RLM feedback", {
+				promptKey,
+				error: String(e),
+			});
+		}
+
+		return false;
+	};
+
+	// Analyze prompt correlation with suggestion
+	const analyzePromptCorrelation = async (userPrompt) => {
+		if (!lastSuggestion || !lastSuggestionTimestamp) {
+			return null;
+		}
+
+		const now = Date.now();
+		const timeDiff = now - lastSuggestionTimestamp;
+
+		// Outside correlation window
+		if (timeDiff > SUGGESTION_CORRELATION_WINDOW_MS) {
+			return null;
+		}
+
+		const suggestionKey = lastSuggestionPromptKey;
+		if (!suggestionKey) {
+			return null;
+		}
+
+		// Check if user prompt matches or differs from suggestion
+		const userPromptLower = userPrompt.toLowerCase().trim();
+		const suggestionLower = lastSuggestion.toLowerCase().trim();
+
+		// Extract keywords from both
+		const userKeywords = userPromptLower.split(/\s+/);
+		const suggestionKeywords = suggestionLower.split(/\s+/);
+
+		// Check for significant overlap
+		const overlap = userKeywords.filter((k) => suggestionKeywords.includes(k));
+		const overlapRatio =
+			overlap.length / Math.max(userKeywords.length, suggestionKeywords.length);
+
+		// Determine correlation type
+		if (overlapRatio > 0.7) {
+			return { type: "accepted", key: suggestionKey, overlap: overlapRatio };
+		}
+		if (overlapRatio > 0.3) {
+			// Steering - user modified the suggestion
+			const addedKeywords = userKeywords.filter(
+				(k) => !suggestionKeywords.includes(k),
+			);
+			const removedKeywords = suggestionKeywords.filter(
+				(k) => !userKeywords.includes(k),
+			);
+
+			return {
+				type: "steered",
+				key: suggestionKey,
+				overlap: overlapRatio,
+				added: addedKeywords,
+				removed: removedKeywords,
+			};
+		}
+		return { type: "rejected", key: suggestionKey, overlap: overlapRatio };
+	};
+
+	const scheduleSuggest = (text) => {
+		lastInput = text;
+		runId += 1;
+		const current = runId;
+
+		if (timer) clearTimeout(timer);
+
+		timer = setTimeout(() => {
+			void (async () => {
+				const prompt = lastInput.trim();
+				if (!prompt) return;
+				if (current !== runId) return;
+				if (prompt === lastInjected) return;
+
+				await log("debug", "running scroll suggest", {
+					cwd: directory,
+					prompt_len: prompt.length,
+				});
+
+				try {
+					const args = [
+						"suggest",
+						"skill",
+						prompt,
+						"--limit",
+						CONFIG.suggestLimit.toString(),
+					];
+					if (CONFIG.provision) args.push("--provision");
+
+					const suggestions = await execScroll(args);
+					if (!suggestions) return;
+					if (current !== runId) return;
+
+					// Store suggestion for correlation tracking
+					lastSuggestion = prompt;
+					lastSuggestionTimestamp = Date.now();
+					lastSuggestionPromptKey = parseSuggestionKey(suggestions);
+
+					await log("debug", "suggestion stored for correlation", {
+						key: lastSuggestionPromptKey,
+						timestamp: lastSuggestionTimestamp,
+					});
+
+					lastInjected = prompt;
+					await client.tui.appendPrompt({
+						body: { text: `\n\n${suggestions}\n` },
+					});
+				} catch (e) {
+					await log("warn", "scroll suggest failed", { error: String(e) });
+				}
+			})();
+		}, CONFIG.debounceMs);
+	};
+
+	return {
+		// Structured hook: reliable way to capture user prompts with model/session info
+		"chat.message": async (input, output) => {
+			// input: { sessionID, agent, model: {providerID, modelID}, messageID }
+			// output: { message: UserMessage, parts: Part[] }
+			currentSessionId = input?.sessionID ?? currentSessionId;
+			currentModel = input?.model?.modelID ?? currentModel;
+
+			const textParts = (output?.parts ?? []).filter((p) => p.type === "text");
+			const content = textParts.map((p) => p.text ?? "").join("\n");
+			if (!content.trim()) return;
+
+			promptCaptured = true;
+			assistantParts = [];
+
+			// Analyze correlation with previous suggestion
+			const correlation = await analyzePromptCorrelation(content);
+			if (correlation) {
+				await log("debug", "prompt correlation detected", correlation);
+
+				let feedbackEntry = "";
+				const date = new Date().toISOString().split("T")[0];
+
+				switch (correlation.type) {
+					case "accepted":
+						feedbackEntry = `[${date}] Prompt suggestion accepted (overlap: ${(correlation.overlap * 100).toFixed(0)}%)`;
+						break;
+					case "steered": {
+						const added = correlation.added?.slice(0, 3).join(", ") || "none";
+						const removed =
+							correlation.removed?.slice(0, 3).join(", ") || "none";
+						feedbackEntry = `[${date}] User steered from suggestion - Added keywords: "${added}" - Removed: "${removed}"`;
+						break;
+					}
+					case "rejected":
+						feedbackEntry = `[${date}] Prompt suggestion rejected (low overlap: ${(correlation.overlap * 100).toFixed(0)}%)`;
+						break;
+				}
+
+				if (feedbackEntry) {
+					await appendRlmFeedback(correlation.key, feedbackEntry);
+				}
+
+				lastSuggestion = null;
+				lastSuggestionTimestamp = null;
+				lastSuggestionPromptKey = null;
+			}
+
+			try {
+				await execScroll(["capture", "hook", "prompt"], {
+					PROMPT: content,
+					SCROLL_SESSION_ID: currentSessionId ?? "",
+					SCROLL_MODEL: currentModel ?? "",
+					SCROLL_WORKSPACE: directory ?? "",
+				});
+			} catch (e) {
+				await log("warn", "capture prompt failed", { error: String(e) });
+				promptCaptured = false;
+			}
+		},
+
+		event: async ({ event }) => {
+			const { type: eventType, properties } = event;
+
+			switch (eventType) {
+				case "message.part.updated": {
+					// OpenCode schema: { part: { id, sessionID, messageID, type, text }, delta? }
+					const part = properties?.part;
+					if (part?.type === "text" && promptCaptured) {
+						// Accumulate assistant text parts during streaming
+						assistantParts.push(part.text ?? "");
+					}
+					break;
+				}
+
+				case "message.updated": {
+					// OpenCode schema: { info: { id, sessionID, role, modelID, providerID, cost, tokens: {input, output, reasoning, cache} } }
+					const info = properties?.info;
+					if (info?.role === "assistant" && promptCaptured) {
+						const responseText = assistantParts.join("");
+						if (responseText.trim()) {
+							try {
+								await execScroll(["capture", "hook", "response"], {
+									CLAUDE_RESPONSE: responseText,
+									SCROLL_SESSION_ID: info.sessionID ?? currentSessionId ?? "",
+									SCROLL_MODEL: info.modelID ?? currentModel ?? "",
+									TOKENS_INPUT: String(info.tokens?.input ?? ""),
+									TOKENS_OUTPUT: String(info.tokens?.output ?? ""),
+								});
+							} catch (e) {
+								await log("warn", "capture response failed", {
+									error: String(e),
+								});
+							}
+						}
+						promptCaptured = false;
+						assistantParts = [];
+					}
+					break;
+				}
+
+				case "session.created": {
+					// OpenCode schema: { info: { id, parentID, directory, title, ... } }
+					const info = properties?.info;
+					currentSessionId = info?.id ?? null;
+					promptCaptured = false;
+					assistantParts = [];
+					await log("info", "session created", {
+						sessionId: currentSessionId ?? "unknown",
+						isSubagent: info?.parentID != null,
+						cwd: directory,
+					});
+					break;
+				}
+
+				case "tui.prompt.append": {
+					const text = properties?.text ?? "";
+					if (text.trim()) {
+						scheduleSuggest(text);
+					}
+					break;
+				}
+			}
+		},
+	};
+};
+
+export default ScrollPlugin;

package/index.test.js

@@ -0,0 +1,427 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import ScrollPlugin from "./index.js";
+
+describe("ScrollPlugin", () => {
+	beforeEach(() => {
+		process.env.SCROLL_PLUGIN_DRY_RUN = "1";
+	});
+
+	const makeClient = () => {
+		const appLogCalls = [];
+		const promptAppends = [];
+		return {
+			client: {
+				app: {
+					log: ({ level, message, extra }) =>
+						appLogCalls.push({ level, message, extra }),
+				},
+				tui: {
+					appendPrompt: ({ body }) => promptAppends.push(body?.text ?? ""),
+				},
+			},
+			appLogCalls,
+			promptAppends,
+		};
+	};
+
+	const make$ = () => {
+		const calls = [];
+		const shell = (opts) => {
+			return (strings, ...values) => {
+				const cmd = strings.reduce(
+					(acc, str, i) => acc + str + (values[i] ?? ""),
+					"",
+				);
+				calls.push({ cmd, env: opts?.env });
+				return { stdout: "" };
+			};
+		};
+		shell.calls = calls;
+		return shell;
+	};
+
+	it("returns event handler and chat.message hook", async () => {
+		const { client } = makeClient();
+		const plugin = await ScrollPlugin({
+			client,
+			$: make$(),
+			directory: "/tmp",
+		});
+
+		expect(typeof plugin.event).toBe("function");
+		expect(typeof plugin["chat.message"]).toBe("function");
+	});
+
+	it("chat.message hook captures prompt with session/model env vars", async () => {
+		const { client } = makeClient();
+		const $mock = make$();
+		const plugin = await ScrollPlugin({ client, $: $mock, directory: "/tmp" });
+
+		await plugin["chat.message"](
+			{
+				sessionID: "sess-abc",
+				model: { providerID: "anthropic", modelID: "claude-3" },
+			},
+			{ message: {}, parts: [{ type: "text", text: "hello world" }] },
+		);
+
+		// In dry-run mode no command is executed, but state should be set
+		// No error means it worked
+	});
+
+	it("chat.message hook ignores empty parts", async () => {
+		const { client } = makeClient();
+		const plugin = await ScrollPlugin({
+			client,
+			$: make$(),
+			directory: "/tmp",
+		});
+
+		// Should not throw or set promptCaptured
+		await plugin["chat.message"](
+			{ sessionID: "s1" },
+			{ parts: [{ type: "text", text: "   " }] },
+		);
+
+		// Subsequent assistant message.updated should be ignored (no prompt captured)
+		await plugin.event({
+			event: {
+				type: "message.updated",
+				properties: { info: { role: "assistant", modelID: "x", tokens: {} } },
+			},
+		});
+	});
+
+	it("message.part.updated accumulates assistant text parts", async () => {
+		const { client } = makeClient();
+		const plugin = await ScrollPlugin({
+			client,
+			$: make$(),
+			directory: "/tmp",
+		});
+
+		// First capture a prompt via chat.message hook
+		await plugin["chat.message"](
+			{ sessionID: "s1", model: { modelID: "claude-3" } },
+			{ parts: [{ type: "text", text: "explain rust" }] },
+		);
+
+		// Simulate streaming assistant parts
+		await plugin.event({
+			event: {
+				type: "message.part.updated",
+				properties: {
+					part: {
+						type: "text",
+						text: "Rust is ",
+						sessionID: "s1",
+						messageID: "m1",
+					},
+				},
+			},
+		});
+		await plugin.event({
+			event: {
+				type: "message.part.updated",
+				properties: {
+					part: {
+						type: "text",
+						text: "a systems language.",
+						sessionID: "s1",
+						messageID: "m1",
+					},
+				},
+			},
+		});
+
+		// Finalize with message.updated
+		await plugin.event({
+			event: {
+				type: "message.updated",
+				properties: {
+					info: {
+						role: "assistant",
+						sessionID: "s1",
+						modelID: "claude-3",
+						tokens: { input: 10, output: 20 },
+					},
+				},
+			},
+		});
+
+		// No error means parts were accumulated and flushed correctly
+	});
+
+	it("message.updated ignores non-assistant roles", async () => {
+		const { client } = makeClient();
+		const plugin = await ScrollPlugin({
+			client,
+			$: make$(),
+			directory: "/tmp",
+		});
+
+		await plugin["chat.message"](
+			{ sessionID: "s1" },
+			{ parts: [{ type: "text", text: "hi" }] },
+		);
+
+		// user role message.updated should not flush
+		await plugin.event({
+			event: {
+				type: "message.updated",
+				properties: { info: { role: "user", sessionID: "s1" } },
+			},
+		});
+
+		// promptCaptured should still be true — assistant parts can still arrive
+		// Verify by sending an actual assistant completion
+		await plugin.event({
+			event: {
+				type: "message.part.updated",
+				properties: { part: { type: "text", text: "response" } },
+			},
+		});
+		await plugin.event({
+			event: {
+				type: "message.updated",
+				properties: {
+					info: { role: "assistant", tokens: { input: 1, output: 2 } },
+				},
+			},
+		});
+	});
+
+	it("session.created resets state and tracks session ID", async () => {
+		const { client, appLogCalls } = makeClient();
+		const plugin = await ScrollPlugin({
+			client,
+			$: make$(),
+			directory: "/tmp",
+		});
+
+		// Capture a prompt first
+		await plugin["chat.message"](
+			{ sessionID: "old-session" },
+			{ parts: [{ type: "text", text: "hello" }] },
+		);
+
+		// New session resets everything
+		await plugin.event({
+			event: {
+				type: "session.created",
+				properties: {
+					info: {
+						id: "new-session-123",
+						parentID: null,
+						directory: "/project",
+					},
+				},
+			},
+		});
+
+		const sessionLog = appLogCalls.find((c) => c.message === "session created");
+		expect(sessionLog).toBeDefined();
+		expect(sessionLog.extra.sessionId).toBe("new-session-123");
+		expect(sessionLog.extra.isSubagent).toBe(false);
+	});
+
+	it("session.created detects subagent via parentID", async () => {
+		const { client, appLogCalls } = makeClient();
+		const plugin = await ScrollPlugin({
+			client,
+			$: make$(),
+			directory: "/tmp",
+		});
+
+		await plugin.event({
+			event: {
+				type: "session.created",
+				properties: { info: { id: "child-1", parentID: "parent-1" } },
+			},
+		});
+
+		const sessionLog = appLogCalls.find((c) => c.message === "session created");
+		expect(sessionLog.extra.isSubagent).toBe(true);
+	});
+
+	it("multiple prompt-response cycles work correctly", async () => {
+		const { client } = makeClient();
+		const plugin = await ScrollPlugin({
+			client,
+			$: make$(),
+			directory: "/tmp",
+		});
+
+		// Cycle 1
+		await plugin["chat.message"](
+			{ sessionID: "s1", model: { modelID: "claude-3" } },
+			{ parts: [{ type: "text", text: "first question" }] },
+		);
+		await plugin.event({
+			event: {
+				type: "message.part.updated",
+				properties: { part: { type: "text", text: "first answer" } },
+			},
+		});
+		await plugin.event({
+			event: {
+				type: "message.updated",
+				properties: {
+					info: { role: "assistant", tokens: { input: 5, output: 10 } },
+				},
+			},
+		});
+
+		// Cycle 2
+		await plugin["chat.message"](
+			{ sessionID: "s1", model: { modelID: "claude-3" } },
+			{ parts: [{ type: "text", text: "second question" }] },
+		);
+		await plugin.event({
+			event: {
+				type: "message.part.updated",
+				properties: { part: { type: "text", text: "second answer" } },
+			},
+		});
+		await plugin.event({
+			event: {
+				type: "message.updated",
+				properties: {
+					info: { role: "assistant", tokens: { input: 8, output: 15 } },
+				},
+			},
+		});
+
+		// No errors means state properly resets between cycles
+	});
+
+	it("handles missing/null properties gracefully", async () => {
+		const { client } = makeClient();
+		const plugin = await ScrollPlugin({
+			client,
+			$: make$(),
+			directory: "/tmp",
+		});
+
+		// chat.message with null parts
+		await plugin["chat.message"](null, null);
+		await plugin["chat.message"]({}, { parts: null });
+		await plugin["chat.message"]({}, { parts: [] });
+
+		// Events with missing properties
+		await plugin.event({
+			event: { type: "message.part.updated", properties: {} },
+		});
+		await plugin.event({ event: { type: "message.updated", properties: {} } });
+		await plugin.event({ event: { type: "session.created", properties: {} } });
+		await plugin.event({ event: { type: "unknown.event", properties: {} } });
+	});
+
+	it("schedules suggest on tui.prompt.append", async () => {
+		const { client } = makeClient();
+		const plugin = await ScrollPlugin({
+			client,
+			$: make$(),
+			directory: "/tmp",
+		});
+
+		await plugin.event({
+			event: {
+				type: "tui.prompt.append",
+				properties: { text: "build an MCP server" },
+			},
+		});
+
+		// Suggest is debounced, so no immediate effect to assert
+	});
+
+	it("RLM feedback calls 'suggest feedback' (not 'prompts append-feedback')", async () => {
+		// Disable dry-run so execScroll actually invokes $
+		process.env.SCROLL_PLUGIN_DRY_RUN = "";
+		process.env.SCROLL_RLM_FEEDBACK = "1";
+
+		const { client } = makeClient();
+		const $mock = make$();
+		const plugin = await ScrollPlugin({ client, $: $mock, directory: "/tmp" });
+
+		// 1. Capture a prompt
+		await plugin["chat.message"](
+			{ sessionID: "s1", model: { modelID: "claude-3" } },
+			{ parts: [{ type: "text", text: "explain rust" }] },
+		);
+
+		// 2. Simulate a suggestion being injected (tui.prompt.append triggers suggest)
+		//    We need to trigger the internal suggest flow which sets lastSuggestionPromptKey.
+		//    The simplest path: simulate the full prompt→suggest→response→feedback cycle.
+		//    Since suggest is debounced and async, instead we directly drive message.updated
+		//    which triggers the RLM feedback path when a suggestion was correlated.
+
+		// 3. Simulate assistant response with tool-use of suggest command
+		await plugin.event({
+			event: {
+				type: "message.part.updated",
+				properties: {
+					part: { type: "text", text: "Rust is a systems language." },
+				},
+			},
+		});
+		await plugin.event({
+			event: {
+				type: "message.updated",
+				properties: {
+					info: { role: "assistant", tokens: { input: 10, output: 20 } },
+				},
+			},
+		});
+
+		// Check that any calls to $ containing "feedback" use "suggest feedback", not "prompts append-feedback"
+		const feedbackCalls = $mock.calls.filter((c) => c.cmd.includes("feedback"));
+		for (const call of feedbackCalls) {
+			expect(call.cmd).toContain("suggest");
+			expect(call.cmd).not.toContain("append-feedback");
+			expect(call.cmd).not.toContain("prompts");
+		}
+
+		// Restore dry-run for other tests
+		process.env.SCROLL_PLUGIN_DRY_RUN = "1";
+	});
+
+	it("non-text parts in message.part.updated are ignored", async () => {
+		const { client } = makeClient();
+		const plugin = await ScrollPlugin({
+			client,
+			$: make$(),
+			directory: "/tmp",
+		});
+
+		await plugin["chat.message"](
+			{ sessionID: "s1" },
+			{ parts: [{ type: "text", text: "question" }] },
+		);
+
+		// Tool-use part should be ignored
+		await plugin.event({
+			event: {
+				type: "message.part.updated",
+				properties: { part: { type: "tool-use", name: "bash", input: {} } },
+			},
+		});
+
+		// Only text parts should be accumulated — tool-use ignored
+		await plugin.event({
+			event: {
+				type: "message.part.updated",
+				properties: { part: { type: "text", text: "actual response" } },
+			},
+		});
+
+		await plugin.event({
+			event: {
+				type: "message.updated",
+				properties: {
+					info: { role: "assistant", tokens: { input: 1, output: 1 } },
+				},
+			},
+		});
+	});
+});

package/package.json

@@ -0,0 +1,18 @@
+{
+	"name": "@sage-protocol/sage-plugin",
+	"version": "0.1.4",
+	"description": "OpenCode plugin for Scroll: capture + suggest in one module",
+	"main": "index.js",
+	"type": "module",
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"lint": "bunx biome check .",
+		"test": "bun test --no-bail"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^1.7.3"
+	}
+}