@sage-protocol/sage-plugin 0.1.4 → 0.1.5

package/.github/workflows/release-please.yml

@@ -0,0 +1,18 @@
+name: release-please
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: googleapis/release-please-action@v4
+        with:
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json

package/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+	".": "0.1.5"
+}

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## [0.1.5](https://github.com/sage-protocol/sage-plugin/compare/sage-plugin-v0.1.4...sage-plugin-v0.1.5) (2026-02-02)
+
+
+### Features
+
+* adding ci, release please and improvements ([0e303fe](https://github.com/sage-protocol/sage-plugin/commit/0e303fe219a96e83318a3d221b0b403d463e0923))
+* version bump ([9aa7d91](https://github.com/sage-protocol/sage-plugin/commit/9aa7d916f758e9e6be422888b2ad15711e96df19))
+
+
+### Bug Fixes
+
+* bug fixes and improvements ([0b88fc9](https://github.com/sage-protocol/sage-plugin/commit/0b88fc97f6fc71f81e8a2ca843922a98a87692ae))
+* fixing opencode plugin bindings for prompt processing and hook behavior ([289949a](https://github.com/sage-protocol/sage-plugin/commit/289949a0701ea4d5ef0b5630eb9d39d734784401))
+* updates ([6f56a0c](https://github.com/sage-protocol/sage-plugin/commit/6f56a0cdfb91b7cb75695490ac4b899d01017951))
+
+## Changelog
+
+All notable changes to this package are documented here.

package/README.md

@@ -1,37 +1,63 @@
 # Sage Plugin (OpenCode)
 
-Unified OpenCode plugin for Scroll that handles both prompt capture (for RLM feedback) and inline skill/prompt suggestions.
+OpenCode plugin for Sage Protocol. Captures prompt/response pairs for RLM feedback and provides inline skill suggestions during coding sessions.
+
+## What It Does
+
+- **Prompt Capture** - Silently records prompt/response pairs with session metadata (model, tokens, cost)
+- **Inline Suggestions** - Debounced skill and prompt suggestions injected into the OpenCode TUI
+- **RLM Feedback** - Tracks whether suggestions were accepted, steered, or rejected within a 30-second correlation window
+- **Session Tracking** - Maintains session and model context across streaming responses
+
+## Install
+
+```bash
+mkdir -p ~/.config/opencode/plugin/@sage-protocol
+cp -r sage-plugin ~/.config/opencode/plugin/@sage-protocol/
+```
+
+Add the plugin to your `opencode.json`:
+
+```json
+{
+  "plugin": ["@sage-protocol/sage-plugin"],
+  "mcp": {
+    "sage": {
+      "type": "local",
+      "command": ["sage", "mcp", "start"],
+      "enabled": true
+    }
+  }
+}
+```
+
+Or run `sage init --opencode` to configure automatically.
+
+## Configuration
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `SAGE_BIN` | `sage` | Path to the sage binary |
+| `SAGE_SUGGEST_LIMIT` | `3` | Max suggestions per request |
+| `SAGE_SUGGEST_DEBOUNCE_MS` | `800` | Debounce delay for TUI suggestions |
+| `SAGE_SUGGEST_PROVISION` | `1` | Set `0` to skip MCP provisioning |
+| `SAGE_RLM_FEEDBACK` | `1` | Set `0` to disable RLM feedback tracking |
+| `SAGE_PLUGIN_DRY_RUN` | `0` | Set `1` to disable spawning sage (for tests) |
 
 ## 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
+
+- Sage CLI on PATH (or set `SAGE_BIN`)
+- Bun v1.3+
+- OpenCode
+
+## Development
+
 ```bash
 bun install
 bun run lint
 bun test
 ```
+
+## License
+
+MIT

package/bun.lock

@@ -3,7 +3,7 @@
   "configVersion": 1,
   "workspaces": {
     "": {
-      "name": "scroll-plugin",
+      "name": "sage-plugin",
       "devDependencies": {
         "@biomejs/biome": "^1.7.3",
       },

package/index.js

@@ -1,20 +1,20 @@
-// Scroll OpenCode plugin: capture + suggest + RLM feedback combined
+// Sage OpenCode plugin: capture + suggest + RLM feedback combined
 //
 // Uses the documented OpenCode plugin event handler pattern.
-// Spawns scroll commands via the `$` shell helper for portability.
+// Spawns sage commands via the `$` shell helper for portability.
 // Now includes RLM feedback appending when steering is detected.
 
-export const ScrollPlugin = async ({ client, $, directory }) => {
+export const SagePlugin = async ({ client, $, directory }) => {
 	const CONFIG = {
-		scrollBin: process.env.SCROLL_BIN || "scroll",
-		suggestLimit: Number.parseInt(process.env.SCROLL_SUGGEST_LIMIT || "3", 10),
+		sageBin: process.env.SAGE_BIN || "sage",
+		suggestLimit: Number.parseInt(process.env.SAGE_SUGGEST_LIMIT || "3", 10),
 		debounceMs: Number.parseInt(
-			process.env.SCROLL_SUGGEST_DEBOUNCE_MS || "800",
+			process.env.SAGE_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",
+		provision: (process.env.SAGE_SUGGEST_PROVISION || "1") === "1",
+		dryRun: (process.env.SAGE_PLUGIN_DRY_RUN || "0") === "1",
+		enableRlmFeedback: (process.env.SAGE_RLM_FEEDBACK || "1") === "1",
 	};
 
 	let promptCaptured = false;
@@ -31,9 +31,83 @@ export const ScrollPlugin = async ({ client, $, directory }) => {
 	// RLM Feedback tracking
 	let lastSuggestion = null;
 	let lastSuggestionTimestamp = null;
-	let lastSuggestionPromptKey = null;
+	let lastSuggestionPromptKey = null; // qualified: library/key
+	let lastSuggestionId = null;
+	let lastShownPromptKeys = [];
+	let lastAcceptedFeedbackSent = false;
+	let lastImplicitFeedbackSent = false;
 	const SUGGESTION_CORRELATION_WINDOW_MS = 30000; // 30 second window
 
+	const parsePromptKeyMarkers = (text) => {
+		// Explicit markers only; no fuzzy matching.
+		// Marker format: [[sage:prompt_key=library/key]]
+		const re = /\[\[sage:prompt_key=([^\]]+)\]\]/g;
+		const keys = new Set();
+		for (;;) {
+			const m = re.exec(text);
+			if (!m) break;
+			const key = (m[1] || "").trim();
+			if (key) keys.add(key);
+		}
+		return Array.from(keys);
+	};
+
+	const recordPromptSuggestion = async ({
+		suggestionId,
+		prompt,
+		shownPromptKeys,
+		source,
+		attributesJson,
+	}) => {
+		try {
+			await execSage([
+				"suggest",
+				"prompt",
+				"capture",
+				suggestionId,
+				prompt,
+				"--source",
+				source,
+				"--shown",
+				...shownPromptKeys,
+				...(attributesJson ? ["--attributes-json", attributesJson] : []),
+			]);
+			return true;
+		} catch (e) {
+			await log(
+				"debug",
+				"prompt suggestion capture failed (daemon may be down)",
+				{
+					error: String(e),
+				},
+			);
+			return false;
+		}
+	};
+
+	const recordPromptSuggestionFeedback = async ({ suggestionId, events }) => {
+		try {
+			await execSage([
+				"suggest",
+				"prompt",
+				"feedback",
+				suggestionId,
+				"--events-json",
+				JSON.stringify(events),
+			]);
+			return true;
+		} catch (e) {
+			await log(
+				"debug",
+				"prompt suggestion feedback failed (daemon may be down)",
+				{
+					error: String(e),
+				},
+			);
+			return false;
+		}
+	};
+
 	const log = async (level, message, extra = {}) => {
 		try {
 			if (client?.app?.log) {
@@ -51,24 +125,24 @@ export const ScrollPlugin = async ({ client, $, directory }) => {
 		}
 	};
 
-	const execScroll = async (args, env = {}) => {
+	const execSage = async (args, env = {}) => {
 		if (CONFIG.dryRun) return "";
 
-		const scrollEnv = { ...env, SCROLL_SOURCE: "opencode" };
+		const sageEnv = { ...env, SAGE_SOURCE: "opencode" };
 
 		try {
 			if ($) {
 				// Use OpenCode's $ shell helper for portability
-				const cmd = [CONFIG.scrollBin, ...args]
+				const cmd = [CONFIG.sageBin, ...args]
 					.map((a) => `'${a.replace(/'/g, "'\\''")}'`)
 					.join(" ");
-				const result = await $({ env: scrollEnv })`${cmd}`;
+				const result = await $({ env: sageEnv })`${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 },
+				const proc = Bun.spawn([CONFIG.sageBin, ...args], {
+					env: { ...process.env, ...sageEnv },
 					stdout: "pipe",
 					stderr: "pipe",
 				});
@@ -77,7 +151,7 @@ export const ScrollPlugin = async ({ client, $, directory }) => {
 			}
 			return "";
 		} catch (e) {
-			throw new Error(`scroll command failed: ${e.message || e}`);
+			throw new Error(`sage command failed: ${e.message || e}`);
 		}
 	};
 
@@ -115,7 +189,7 @@ export const ScrollPlugin = async ({ client, $, directory }) => {
 				feedback: feedbackEntry,
 			});
 
-			const result = await execScroll([
+			const result = await execSage([
 				"suggest",
 				"feedback",
 				promptKey,
@@ -208,7 +282,7 @@ export const ScrollPlugin = async ({ client, $, directory }) => {
 				if (current !== runId) return;
 				if (prompt === lastInjected) return;
 
-				await log("debug", "running scroll suggest", {
+				await log("debug", "running sage suggest", {
 					cwd: directory,
 					prompt_len: prompt.length,
 				});
@@ -218,19 +292,94 @@ export const ScrollPlugin = async ({ client, $, directory }) => {
 						"suggest",
 						"skill",
 						prompt,
+						"--format",
+						"json",
 						"--limit",
 						CONFIG.suggestLimit.toString(),
 					];
 					if (CONFIG.provision) args.push("--provision");
 
-					const suggestions = await execScroll(args);
-					if (!suggestions) return;
+					const output = await execSage(args);
+					if (!output) return;
 					if (current !== runId) return;
 
+					let renderedOutput = "";
+					let correlationText = "";
+					let primaryKey = null;
+					let shownKeys = [];
+
+					try {
+						const json = JSON.parse(output);
+						if (
+							json.results &&
+							Array.isArray(json.results) &&
+							json.results.length > 0
+						) {
+							// Extract qualified keys for capture/correlation
+							shownKeys = json.results
+								.map((r) => (r.library ? `${r.library}/${r.key}` : r.key))
+								.filter(Boolean);
+							primaryKey = shownKeys[0] || null;
+
+							// Build correlation text from all results (titles/descriptions/keys)
+							// We exclude full content to keep overlap ratio meaningful
+							correlationText = json.results
+								.map((r) => `${r.name} ${r.description || ""} ${r.key}`)
+								.join(" ");
+
+							// Render output
+							renderedOutput = json.results
+								.map((r) => {
+									const qualifiedKey = r.library
+										? `${r.library}/${r.key}`
+										: r.key;
+									let block = `### ${r.name} (key: ${qualifiedKey})\n`;
+									if (r.library) block += `*Library: ${r.library}*\n`;
+									if (r.description) block += `${r.description}\n`;
+									if (r.content) block += `\n\`\`\`\n${r.content}\n\`\`\`\n`;
+									block += `\n<!-- If you use this suggestion, include marker: [[sage:prompt_key=${qualifiedKey}]] -->\n`;
+									return block;
+								})
+								.join("\n---\n\n");
+						}
+					} catch (e) {
+						// Fallback: If JSON parse fails, assume it might be plain text or broken JSON.
+						// We treat the raw output as the suggestion.
+						renderedOutput = output;
+						primaryKey = parseSuggestionKey(output);
+						correlationText = output;
+					}
+
+					if (!renderedOutput) return;
+
+					const suggestionId =
+						typeof crypto !== "undefined" && crypto.randomUUID
+							? crypto.randomUUID()
+							: `sage-suggest-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+
 					// Store suggestion for correlation tracking
-					lastSuggestion = prompt;
+					lastSuggestion = correlationText;
 					lastSuggestionTimestamp = Date.now();
-					lastSuggestionPromptKey = parseSuggestionKey(suggestions);
+					lastSuggestionPromptKey = primaryKey;
+					lastSuggestionId = suggestionId;
+					lastShownPromptKeys = shownKeys;
+					lastAcceptedFeedbackSent = false;
+					lastImplicitFeedbackSent = false;
+
+					// Capture the suggestion to daemon (best-effort)
+					await recordPromptSuggestion({
+						suggestionId,
+						prompt,
+						shownPromptKeys: shownKeys,
+						source: "opencode",
+						attributesJson: JSON.stringify({
+							opencode: {
+								sessionId: currentSessionId,
+								model: currentModel,
+								workspace: directory,
+							},
+						}),
+					});
 
 					await log("debug", "suggestion stored for correlation", {
 						key: lastSuggestionPromptKey,
@@ -239,10 +388,10 @@ export const ScrollPlugin = async ({ client, $, directory }) => {
 
 					lastInjected = prompt;
 					await client.tui.appendPrompt({
-						body: { text: `\n\n${suggestions}\n` },
+						body: { text: `\n\n${renderedOutput}\n` },
 					});
 				} catch (e) {
-					await log("warn", "scroll suggest failed", { error: String(e) });
+					await log("warn", "sage suggest failed", { error: String(e) });
 				}
 			})();
 		}, CONFIG.debounceMs);
@@ -291,17 +440,30 @@ export const ScrollPlugin = async ({ client, $, directory }) => {
 					await appendRlmFeedback(correlation.key, feedbackEntry);
 				}
 
-				lastSuggestion = null;
-				lastSuggestionTimestamp = null;
-				lastSuggestionPromptKey = null;
+				// Also record prompt-suggestion feedback to daemon (best-effort)
+				if (lastSuggestionId && !lastAcceptedFeedbackSent) {
+					await recordPromptSuggestionFeedback({
+						suggestionId: lastSuggestionId,
+						events: [
+							{
+								kind: correlation.type,
+								prompt_key: correlation.key,
+								confidence: correlation.overlap,
+								features_json: JSON.stringify({ overlap: correlation.overlap }),
+							},
+						],
+					});
+					lastAcceptedFeedbackSent = true;
+				}
+
+				// Keep suggestion state for implicit marker detection on assistant completion.
 			}
 
 			try {
-				await execScroll(["capture", "hook", "prompt"], {
-					PROMPT: content,
-					SCROLL_SESSION_ID: currentSessionId ?? "",
-					SCROLL_MODEL: currentModel ?? "",
-					SCROLL_WORKSPACE: directory ?? "",
+				await execSage(["capture", "hook", "prompt"], {
+					SAGE_SESSION_ID: currentSessionId ?? "",
+					SAGE_MODEL: currentModel ?? "",
+					SAGE_WORKSPACE: directory ?? "",
 				});
 			} catch (e) {
 				await log("warn", "capture prompt failed", { error: String(e) });
@@ -329,11 +491,37 @@ export const ScrollPlugin = async ({ client, $, directory }) => {
 					if (info?.role === "assistant" && promptCaptured) {
 						const responseText = assistantParts.join("");
 						if (responseText.trim()) {
+							// If assistant explicitly marks one suggested prompt key as used, record implicitly_helpful.
+							if (
+								lastSuggestionId &&
+								lastSuggestionTimestamp &&
+								!lastImplicitFeedbackSent &&
+								Date.now() - lastSuggestionTimestamp <=
+									SUGGESTION_CORRELATION_WINDOW_MS
+							) {
+								const marked = parsePromptKeyMarkers(responseText);
+								const allowed = new Set(lastShownPromptKeys || []);
+								const matched = marked.filter((k) => allowed.has(k));
+								if (matched.length === 1) {
+									await recordPromptSuggestionFeedback({
+										suggestionId: lastSuggestionId,
+										events: [
+											{
+												kind: "implicitly_helpful",
+												prompt_key: matched[0],
+												confidence: 1.0,
+												features_json: JSON.stringify({ marker: true }),
+											},
+										],
+									});
+									lastImplicitFeedbackSent = true;
+								}
+							}
+
 							try {
-								await execScroll(["capture", "hook", "response"], {
-									CLAUDE_RESPONSE: responseText,
-									SCROLL_SESSION_ID: info.sessionID ?? currentSessionId ?? "",
-									SCROLL_MODEL: info.modelID ?? currentModel ?? "",
+								await execSage(["capture", "hook", "response"], {
+									SAGE_SESSION_ID: info.sessionID ?? currentSessionId ?? "",
+									SAGE_MODEL: info.modelID ?? currentModel ?? "",
 									TOKENS_INPUT: String(info.tokens?.input ?? ""),
 									TOKENS_OUTPUT: String(info.tokens?.output ?? ""),
 								});
@@ -345,6 +533,21 @@ export const ScrollPlugin = async ({ client, $, directory }) => {
 						}
 						promptCaptured = false;
 						assistantParts = [];
+
+						// Clear suggestion tracking once we've had a full assistant completion after it.
+						if (
+							lastSuggestionTimestamp &&
+							Date.now() - lastSuggestionTimestamp >
+								SUGGESTION_CORRELATION_WINDOW_MS
+						) {
+							lastSuggestion = null;
+							lastSuggestionTimestamp = null;
+							lastSuggestionPromptKey = null;
+							lastSuggestionId = null;
+							lastShownPromptKeys = [];
+							lastAcceptedFeedbackSent = false;
+							lastImplicitFeedbackSent = false;
+						}
 					}
 					break;
 				}
@@ -375,4 +578,4 @@ export const ScrollPlugin = async ({ client, $, directory }) => {
 	};
 };
 
-export default ScrollPlugin;
+export default SagePlugin;

package/index.test.js

@@ -1,9 +1,9 @@
 import { beforeEach, describe, expect, it } from "bun:test";
-import ScrollPlugin from "./index.js";
+import SagePlugin from "./index.js";
 
-describe("ScrollPlugin", () => {
+describe("SagePlugin", () => {
 	beforeEach(() => {
-		process.env.SCROLL_PLUGIN_DRY_RUN = "1";
+		process.env.SAGE_PLUGIN_DRY_RUN = "1";
 	});
 
 	const makeClient = () => {
@@ -42,7 +42,7 @@ describe("ScrollPlugin", () => {
 
 	it("returns event handler and chat.message hook", async () => {
 		const { client } = makeClient();
-		const plugin = await ScrollPlugin({
+		const plugin = await SagePlugin({
 			client,
 			$: make$(),
 			directory: "/tmp",
@@ -55,7 +55,7 @@ describe("ScrollPlugin", () => {
 	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" });
+		const plugin = await SagePlugin({ client, $: $mock, directory: "/tmp" });
 
 		await plugin["chat.message"](
 			{
@@ -71,7 +71,7 @@ describe("ScrollPlugin", () => {
 
 	it("chat.message hook ignores empty parts", async () => {
 		const { client } = makeClient();
-		const plugin = await ScrollPlugin({
+		const plugin = await SagePlugin({
 			client,
 			$: make$(),
 			directory: "/tmp",
@@ -94,7 +94,7 @@ describe("ScrollPlugin", () => {
 
 	it("message.part.updated accumulates assistant text parts", async () => {
 		const { client } = makeClient();
-		const plugin = await ScrollPlugin({
+		const plugin = await SagePlugin({
 			client,
 			$: make$(),
 			directory: "/tmp",
@@ -154,7 +154,7 @@ describe("ScrollPlugin", () => {
 
 	it("message.updated ignores non-assistant roles", async () => {
 		const { client } = makeClient();
-		const plugin = await ScrollPlugin({
+		const plugin = await SagePlugin({
 			client,
 			$: make$(),
 			directory: "/tmp",
@@ -193,7 +193,7 @@ describe("ScrollPlugin", () => {
 
 	it("session.created resets state and tracks session ID", async () => {
 		const { client, appLogCalls } = makeClient();
-		const plugin = await ScrollPlugin({
+		const plugin = await SagePlugin({
 			client,
 			$: make$(),
 			directory: "/tmp",
@@ -227,7 +227,7 @@ describe("ScrollPlugin", () => {
 
 	it("session.created detects subagent via parentID", async () => {
 		const { client, appLogCalls } = makeClient();
-		const plugin = await ScrollPlugin({
+		const plugin = await SagePlugin({
 			client,
 			$: make$(),
 			directory: "/tmp",
@@ -246,7 +246,7 @@ describe("ScrollPlugin", () => {
 
 	it("multiple prompt-response cycles work correctly", async () => {
 		const { client } = makeClient();
-		const plugin = await ScrollPlugin({
+		const plugin = await SagePlugin({
 			client,
 			$: make$(),
 			directory: "/tmp",
@@ -297,7 +297,7 @@ describe("ScrollPlugin", () => {
 
 	it("handles missing/null properties gracefully", async () => {
 		const { client } = makeClient();
-		const plugin = await ScrollPlugin({
+		const plugin = await SagePlugin({
 			client,
 			$: make$(),
 			directory: "/tmp",
@@ -319,7 +319,7 @@ describe("ScrollPlugin", () => {
 
 	it("schedules suggest on tui.prompt.append", async () => {
 		const { client } = makeClient();
-		const plugin = await ScrollPlugin({
+		const plugin = await SagePlugin({
 			client,
 			$: make$(),
 			directory: "/tmp",
@@ -336,13 +336,13 @@ describe("ScrollPlugin", () => {
 	});
 
 	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";
+		// Disable dry-run so exec sage actually invokes $
+		process.env.SAGE_PLUGIN_DRY_RUN = "";
+		process.env.SAGE_RLM_FEEDBACK = "1";
 
 		const { client } = makeClient();
 		const $mock = make$();
-		const plugin = await ScrollPlugin({ client, $: $mock, directory: "/tmp" });
+		const plugin = await SagePlugin({ client, $: $mock, directory: "/tmp" });
 
 		// 1. Capture a prompt
 		await plugin["chat.message"](
@@ -383,12 +383,12 @@ describe("ScrollPlugin", () => {
 		}
 
 		// Restore dry-run for other tests
-		process.env.SCROLL_PLUGIN_DRY_RUN = "1";
+		process.env.SAGE_PLUGIN_DRY_RUN = "1";
 	});
 
 	it("non-text parts in message.part.updated are ignored", async () => {
 		const { client } = makeClient();
-		const plugin = await ScrollPlugin({
+		const plugin = await SagePlugin({
 			client,
 			$: make$(),
 			directory: "/tmp",

package/mcp.integration.test.js

@@ -0,0 +1,129 @@
+import { describe, expect, it } from "bun:test";
+
+function createMcpClient(proc) {
+	const decoder = new TextDecoder();
+	const encoder = new TextEncoder();
+	const pending = new Map();
+
+	let closed = false;
+	let closeErr;
+	let buf = "";
+
+	(async () => {
+		try {
+			for await (const chunk of proc.stdout) {
+				buf += decoder.decode(chunk);
+				const lines = buf.split("\n");
+				buf = lines.pop() ?? "";
+
+				for (const line of lines) {
+					if (!line.trim()) continue;
+
+					let msg;
+					try {
+						msg = JSON.parse(line);
+					} catch {
+						// Ignore malformed lines (stdout should be JSON-RPC, but be resilient).
+						continue;
+					}
+
+					if (msg && msg.id != null) {
+						const key = String(msg.id);
+						const waiter = pending.get(key);
+						if (waiter) {
+							pending.delete(key);
+							if (msg.error)
+								waiter.reject(new Error(msg.error.message || "MCP error"));
+							else waiter.resolve(msg.result);
+						}
+					}
+				}
+			}
+			closed = true;
+		} catch (e) {
+			closed = true;
+			closeErr = e;
+		} finally {
+			// Fail any outstanding requests.
+			const stderr = await new Response(proc.stderr).text().catch(() => "");
+			for (const { reject } of pending.values()) {
+				reject(
+					new Error(
+						`MCP process ended before response. stderr:\n${stderr || "<empty>"}${closeErr ? `\nstdout reader error: ${closeErr}` : ""}`,
+					),
+				);
+			}
+			pending.clear();
+		}
+	})();
+
+	return {
+		request(method, params) {
+			if (closed) {
+				throw new Error("MCP client is closed");
+			}
+			const id = `${Date.now()}-${Math.random()}`;
+			proc.stdin.write(
+				encoder.encode(
+					`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`,
+				),
+			);
+			return new Promise((resolve, reject) => {
+				pending.set(String(id), { resolve, reject });
+			});
+		},
+		notify(method, params) {
+			if (closed) return;
+			proc.stdin.write(
+				encoder.encode(
+					`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`,
+				),
+			);
+		},
+	};
+}
+
+describe("sage-plugin integration: CLI <-> MCP", () => {
+	it("sage mcp start initializes and exposes native tools", async () => {
+		const sageBin =
+			process.env.SAGE_BIN ||
+			new URL("../target/debug/sage", import.meta.url).pathname;
+		const proc = Bun.spawn([sageBin, "mcp", "start"], {
+			stdin: "pipe",
+			stdout: "pipe",
+			stderr: "pipe",
+			env: { ...process.env },
+		});
+		const client = createMcpClient(proc);
+
+		try {
+			const init = await client.request("initialize", {
+				protocolVersion: "2024-11-05",
+				capabilities: {},
+				clientInfo: { name: "sage-plugin-test", version: "0.0.0" },
+			});
+			expect(init).toBeTruthy();
+
+			// MCP handshake
+			client.notify("notifications/initialized", {});
+
+			const toolsList = await client.request("tools/list", {});
+			expect(Array.isArray(toolsList?.tools)).toBe(true);
+			expect(toolsList.tools.length).toBeGreaterThan(0);
+
+			const hasProjectContext = toolsList.tools.some(
+				(t) => t.name === "get_project_context",
+			);
+			expect(hasProjectContext).toBe(true);
+
+			const callRes = await client.request("tools/call", {
+				name: "get_project_context",
+				arguments: {},
+			});
+			expect(callRes).toBeTruthy();
+			expect(callRes.isError || false).toBe(false);
+		} finally {
+			proc.kill("SIGTERM");
+		}
+	});
+});

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@sage-protocol/sage-plugin",
-	"version": "0.1.4",
-	"description": "OpenCode plugin for Scroll: capture + suggest in one module",
+	"version": "0.1.5",
+	"description": "OpenCode plugin for Sage: capture + suggest in one module",
 	"main": "index.js",
 	"type": "module",
 	"license": "MIT",

package/release-please-config.json

@@ -0,0 +1,13 @@
+{
+	"$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
+	"release-type": "node",
+	"include-v-in-tag": true,
+	"bump-minor-pre-major": true,
+	"bump-patch-for-minor-pre-major": true,
+	"packages": {
+		".": {
+			"package-name": "@sage-protocol/sage-plugin",
+			"changelog-path": "CHANGELOG.md"
+		}
+	}
+}