@remembrance-ai/opencode-plugin 0.1.53 → 0.1.60

package/skills/remembrancer/references/remembrance-setup.md

@@ -329,6 +329,7 @@ enabled_tools = [
   "query_skills",
   "list_skills",
   "invoke_skill",
+  "get_effective_preferences",
   "get_skill",
   "get_resource",
   "get_value_proof",
@@ -338,6 +339,8 @@ enabled_tools = [
   "submit_remembrance",
   "propose_private_skill",
   "submit_suggestion",
+  "record_preference",
+  "link_current_installation",
 ]
 default_tools_approval_mode = "writes"
 ~~~
@@ -351,7 +354,8 @@ The MCP annotation for `propose_private_skill` is non-read-only and
 closed-world: it makes a network request, but can change only the authenticated
 organization's private review queue and cannot change publicly visible internet
 state. Closed-world does not mean zero-network. Only
-`queue_private_skill_import` is the local, zero-network fallback.
+`queue_private_skill_import` is a local, zero-network handoff tool, and it
+should run only when an organization admin explicitly requests that handoff.
 
 Example text to merge into the tenant-specific guardian policy:
 
@@ -386,12 +390,14 @@ over a user's local `[auto_review].policy`. See the official Codex
 [managed configuration](https://learn.chatgpt.com/docs/enterprise/managed-configuration#configure-automatic-review-policy)
 documentation for the current schema and deployment options.
 
-If the organization does not approve direct egress, keep the host denial. Use
-`queue_private_skill_import` locally, or run the bundled
-`scripts/queue-private-skill-import.mjs` helper, then have an organization
-admin upload the mode-0600 JSON at **Dashboard > Skills > Import**. The handoff
-never contains an API key or organization id, never contacts Remembrance, and
-does not count as submitted until the dashboard returns an import batch receipt.
+If the organization does not approve direct egress, keep the host denial. The
+plugin reports one content-free local alert, does not retry, and does not create
+a handoff automatically. Only when an organization admin explicitly requests a
+handoff, use `queue_private_skill_import` locally or run the bundled
+`scripts/queue-private-skill-import.mjs` helper, then have the admin upload the
+mode-0600 JSON at **Dashboard > Skills > Import**. The handoff never contains an
+API key or organization id, never contacts Remembrance, and does not count as
+submitted until the dashboard returns an import batch receipt.
 
 If Codex still sees `<your org key>` after restart, remove stale
 `REMEMBRANCE_API_KEY` exports from shell profiles such as `~/.zshrc` and
@@ -427,6 +433,7 @@ run_connection_doctor
 query_skills
 list_skills
 invoke_skill
+get_effective_preferences
 get_skill
 get_resource
 get_value_proof
@@ -436,6 +443,8 @@ report_task_outcome
 submit_remembrance
 propose_private_skill
 submit_suggestion
+record_preference
+link_current_installation
 ~~~
 
 It intentionally omits `propose_skill_idea`, `submit_resource`,
@@ -493,6 +502,7 @@ Merge this into managed settings:
       "mcp__remembrance__query_skills",
       "mcp__remembrance__list_skills",
       "mcp__remembrance__invoke_skill",
+      "mcp__remembrance__get_effective_preferences",
       "mcp__remembrance__get_skill",
       "mcp__remembrance__get_resource",
       "mcp__remembrance__get_value_proof",
@@ -502,6 +512,8 @@ Merge this into managed settings:
       "mcp__remembrance__submit_remembrance",
       "mcp__remembrance__propose_private_skill",
       "mcp__remembrance__submit_suggestion",
+      "mcp__remembrance__record_preference",
+      "mcp__remembrance__link_current_installation",
     ]
   },
   "sandbox": {
@@ -548,6 +560,7 @@ narrow server/tool set:
       "query_skills",
       "list_skills",
       "invoke_skill",
+      "get_effective_preferences",
       "get_skill",
       "get_resource",
       "get_value_proof",
@@ -557,6 +570,8 @@ narrow server/tool set:
       "submit_remembrance",
       "propose_private_skill",
       "submit_suggestion",
+      "record_preference",
+      "link_current_installation",
       ],
       "trust": false
     }
@@ -601,6 +616,7 @@ tool profile hides MCP tools, and `tools.deny: ["bundle-mcp"]` disables them:
       "query_skills",
       "list_skills",
       "invoke_skill",
+      "get_effective_preferences",
       "get_skill",
       "get_resource",
       "get_value_proof",
@@ -610,6 +626,8 @@ tool profile hides MCP tools, and `tools.deny: ["bundle-mcp"]` disables them:
       "submit_remembrance",
       "propose_private_skill",
       "submit_suggestion",
+      "record_preference",
+      "link_current_installation",
           ]
         }
       }
@@ -780,6 +798,17 @@ npx skills add dreamarkinc/remembrance-skills --skill remembrancer
 The entry skill is REST-only and self-contained. The same skill directory can
 be copied to ".agents/skills/remembrancer/SKILL.md" for compatible providers.
 
+## Verified client updates
+
+Native plugins and local MCP check the credential-free public release manifest
+at startup and through `run_connection_doctor`. The check sends no API key,
+fails open when the registry is unavailable, and never runs a command returned
+by the network. When a newer verified release exists, the agent must ask before
+running the update command bundled with its installed client, then tell the user
+which Codex, Claude Code, Cursor, OpenClaw, VS Code, OpenCode, or MCP host must
+be reloaded, reopened, or fully restarted. Set
+`REMEMBRANCE_CLIENT_UPDATE_CHECK=0` to disable only this advisory check.
+
 ## Validate after setup
 
 1. Start a fresh agent session.
@@ -834,10 +863,12 @@ be copied to ".agents/skills/remembrancer/SKILL.md" for compatible providers.
    that should not appear anonymously.
 13. With an organization submission key, submit one disposable redacted skill
    through propose_private_skill and verify it appears only in that
-   organization's review queue. If host policy denies the export, run
-   queue_private_skill_import instead, upload its JSON in the dashboard, and
-   verify the agent reports a local queue receipt separately from the server
-   import receipt.
+   organization's review queue. In a separate negative scenario, simulate a
+   host-policy denial and verify the plugin reports the fixed content-free alert
+   once, persists no blocked content, performs no retry, and creates no handoff.
+   Test queue_private_skill_import only as a separate administrator-requested
+   manual handoff, with its local receipt distinguished from a server import
+   receipt.
 14. If using local MCP, verify local_signing_identity in get_connection_status.
    A missing opaque identity initializes automatically on the first signed
    contribution; bootstrap_agent_identity with no arguments is an optional

package/src/index.mjs

@@ -37,6 +37,8 @@
 import { readFileSync } from "node:fs";
 import process from "node:process";
 import {
+  HOST_POLICY_ALERT_TEXT,
+  checkForClientUpdate,
   clearHighMatchSurfaceForExplicitSelection,
   clearHighMatchSurfaceIfOpened,
   debugLog,
@@ -44,11 +46,13 @@ import {
   directSelectionFromResponse,
   highMatchFromResponse,
   markCurrentEngagementHandled,
+  markHostPolicyAlertDelivered,
   recordDirectiveFollowThroughForTool,
   recordDirectSelectionSurface,
   recordDirectiveSurface,
   recordHighMatchSurface,
   recordPluginLifecycleHealth,
+  recordHostPolicyDenial,
   recordRegistryUse,
   recordTaskEligibility,
   recordValueEpisodeSurface,
@@ -61,6 +65,7 @@ import {
   toolResponseIndicatesFailure,
   valueEpisodeFromResponse,
   writePromptedCount,
+  warmPrincipalSession,
 } from "../scripts/hook-core.mjs";
 
 const SURFACE = "opencode";
@@ -182,6 +187,12 @@ export function toolNameFromEvent(input, output) {
     input?.toolName,
     output?.tool,
     output?.toolName,
+    input?.properties?.tool,
+    input?.properties?.toolName,
+    input?.properties?.permission,
+    output?.properties?.tool,
+    output?.properties?.toolName,
+    output?.properties?.permission,
   ]) {
     if (typeof candidate === "string" && candidate.trim()) {
       return candidate;
@@ -221,11 +232,36 @@ export const Remembrance = async (context = {}) => {
   const queriedMessages = new Set();
   const messageSessions = new Map();
   const pendingGuidance = new Map();
+  const pendingClientUpdates = new Map();
   const userMessages = new Map();
   const pendingTextParts = new Map();
 
+  async function observeHostPolicyDenial({
+    eventType,
+    sessionId,
+    toolName,
+    value,
+  }) {
+    const observation = recordHostPolicyDenial(
+      {
+        surface: SURFACE,
+        sessionId,
+        eventType,
+        toolName,
+        value,
+        pluginVersion: version,
+      },
+      env,
+    );
+    if (!observation) return false;
+    await notify(client, HOST_POLICY_ALERT_TEXT, "error");
+    markHostPolicyAlertDelivered(SURFACE, sessionId, observation.id, env);
+    return true;
+  }
+
   function clearSessionState(sessionId) {
     pendingGuidance.delete(sessionId);
+    pendingClientUpdates.delete(sessionId);
     for (const [messageId, trackedSessionId] of messageSessions) {
       if (trackedSessionId !== sessionId) continue;
       messageSessions.delete(messageId);
@@ -265,10 +301,33 @@ export const Remembrance = async (context = {}) => {
     try {
       const sessionId = sessionIdFromEvent(event, event);
       recordLifecycle("session_start", sessionId);
+      const [, clientUpdate] = await Promise.all([
+        (context.warmSession ?? warmPrincipalSession)(
+          {
+            runtime: SURFACE,
+            hostSurface: "cli",
+            clientVersion: version,
+            hostVersion: "",
+          },
+          env,
+        ).catch(() => null),
+        (context.clientUpdateCheck ?? checkForClientUpdate)(
+          {
+            surface: SURFACE,
+            currentVersion: version,
+          },
+          env,
+        ).catch(() => null),
+      ]);
+      if (clientUpdate?.notice) {
+        pendingClientUpdates.set(sessionId, clientUpdate.notice);
+      }
       await notify(
         client,
-        `Remembrance ${version} is active. Relevant memory is added before eligible turns; ` +
-          "run_connection_doctor verifies the active connection and gives one exact next step without exposing the key.",
+        clientUpdate?.latest_version
+          ? `Remembrance ${version} is active; ${clientUpdate.latest_version} is available. The agent will ask before updating, and the host must be restarted afterward.`
+          : `Remembrance ${version} is active. Relevant memory is added before eligible turns; ` +
+              "run_connection_doctor verifies the active connection and gives one exact next step without exposing the key.",
       );
     } catch (error) {
       debugLog(env, "opencode_session_created_failed", {
@@ -334,7 +393,13 @@ export const Remembrance = async (context = {}) => {
     try {
       const sessionId = sessionIdFromEvent(input, output);
       const guidance = pendingGuidance.get(sessionId);
-      if (!guidance || !Array.isArray(output?.system)) return;
+      const updateNotice = pendingClientUpdates.get(sessionId);
+      if (!Array.isArray(output?.system)) return;
+      if (updateNotice) {
+        output.system.push(updateNotice);
+        pendingClientUpdates.delete(sessionId);
+      }
+      if (!guidance) return;
       output.system.push(guidance.text);
       pendingGuidance.delete(sessionId);
       // Delivery happened: only now is the guidance actually in the model's
@@ -453,6 +518,22 @@ export const Remembrance = async (context = {}) => {
           await handleSessionIdle(event);
           return;
         }
+        if (
+          event.type === "permission.replied" ||
+          event.type === "session.error"
+        ) {
+          const serialized = JSON.stringify(event);
+          const inferredTool = /remembrance/i.test(serialized)
+            ? toolNameFromEvent(event, event) || "remembrance"
+            : toolNameFromEvent(event, event);
+          await observeHostPolicyDenial({
+            eventType: event.type,
+            sessionId: sessionIdFromEvent(event, event),
+            toolName: inferredTool,
+            value: event,
+          });
+          return;
+        }
         if (event.type === "session.deleted") {
           clearSessionState(sessionIdFromEvent(event, event));
         }
@@ -468,11 +549,19 @@ export const Remembrance = async (context = {}) => {
     "tool.execute.after": async (input, output) => {
       try {
         const sessionId = sessionIdFromEvent(input, output);
-        recordLifecycle("tool_observer", sessionId);
         const tool = toolNameFromEvent(input, output);
         if (!tool) return;
         const normalizedTool = tool.toLowerCase();
-        if (toolResponseIndicatesFailure(output)) return;
+        if (toolResponseIndicatesFailure(output)) {
+          await observeHostPolicyDenial({
+            eventType: "tool.execute.after",
+            sessionId,
+            toolName: tool,
+            value: output,
+          });
+          return;
+        }
+        recordLifecycle("tool_observer", sessionId);
         if (normalizedTool.endsWith("query_skills")) {
           if (queryResponseHasMatches(output)) {
             recordRegistryUse(sessionId, env);