@agentapprove/opencode 0.1.2 → 0.1.4

package/dist/index.js

@@ -9,7 +9,7 @@ import { homedir as homedir3 } from "os";
 import { execSync } from "child_process";
 
 // src/e2e-crypto.ts
-import { createHash, createHmac, createCipheriv, randomBytes } from "crypto";
+import { createHash, createHmac, createCipheriv, createDecipheriv, randomBytes, timingSafeEqual } from "crypto";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, copyFileSync } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
@@ -62,6 +62,50 @@ function debugLogRawInline(data) {
   } catch {
   }
 }
+function safeStringify(value) {
+  try {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return JSON.stringify(value, (_key, current) => {
+      if (typeof current === "bigint") return `BigInt(${current.toString()})`;
+      if (typeof current === "function") {
+        const fn = current;
+        return `[Function ${fn.name || "anonymous"}]`;
+      }
+      if (typeof current === "symbol") return current.toString();
+      if (current instanceof Error) {
+        return {
+          name: current.name,
+          message: current.message,
+          stack: current.stack
+        };
+      }
+      if (current && typeof current === "object") {
+        const obj = current;
+        if (seen.has(obj)) return "[Circular]";
+        seen.add(obj);
+      }
+      return current;
+    }) ?? "null";
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return `"[Unserializable: ${msg}]"`;
+  }
+}
+function debugLogRaw(data, hookName = "opencode-plugin") {
+  try {
+    ensureLogFile();
+    const ts = localTimestamp();
+    const rawData = typeof data === "string" ? data : safeStringify(data);
+    appendFileSync(
+      DEBUG_LOG_PATH,
+      `[${ts}] [${hookName}] === RAW INPUT ===
+${rawData}
+[${ts}] [${hookName}] === END RAW ===
+`
+    );
+  } catch {
+  }
+}
 
 // src/e2e-crypto.ts
 function keyId(keyHex) {
@@ -91,6 +135,33 @@ function e2eEncrypt(keyHex, plaintext) {
   const hmac = createHmac("sha256", macKey).update(Buffer.concat([iv, ciphertext])).digest("hex");
   return `E2E:v1:${kid}:${ivHex}:${ciphertextBase64}:${hmac}`;
 }
+function isE2EEncrypted(value) {
+  return value.startsWith("E2E:v1:");
+}
+function e2eDecrypt(keyHex, encrypted) {
+  try {
+    if (!isE2EEncrypted(encrypted)) return null;
+    const parts = encrypted.split(":");
+    if (parts.length !== 6) return null;
+    const ivHex = parts[3];
+    const ciphertextBase64 = parts[4];
+    const hmacHex = parts[5];
+    const encKey = deriveEncKey(keyHex);
+    const macKey = deriveMacKey(keyHex);
+    const iv = Buffer.from(ivHex, "hex");
+    const ciphertext = Buffer.from(ciphertextBase64, "base64");
+    const expectedHmac = createHmac("sha256", macKey).update(Buffer.concat([iv, ciphertext])).digest();
+    const actualHmac = Buffer.from(hmacHex, "hex");
+    if (expectedHmac.length !== actualHmac.length || !timingSafeEqual(expectedHmac, actualHmac)) {
+      return null;
+    }
+    const decipher = createDecipheriv("aes-256-ctr", encKey, iv);
+    const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+    return plaintext.toString("utf-8");
+  } catch {
+    return null;
+  }
+}
 function applyApprovalE2E(payload, userKey, serverKey) {
   const sensitiveFields = {};
   for (const field of ["command", "toolInput", "cwd"]) {
@@ -687,6 +758,45 @@ async function sendApprovalRequest(request, config, pluginPath) {
   processConfigSync(parsed, config);
   return parsed;
 }
+async function sendStopRequest(request, config, pluginPath) {
+  if (!config.token) {
+    throw new Error("No Agent Approve token configured");
+  }
+  const payload = applyEventPrivacyFilter(
+    { ...request },
+    config.privacyTier
+  );
+  const bodyStr = JSON.stringify(payload);
+  const pluginHash = getPluginHash(pluginPath, config.debug);
+  const hmacHeaders = buildHMACHeaders(bodyStr, config.token, config.hookVersion, pluginHash);
+  const headers = {
+    "Authorization": `Bearer ${config.token}`,
+    ...hmacHeaders
+  };
+  const url = `${config.apiUrl}/${config.apiVersion}/stop`;
+  const stopTimeoutMs = 3e5;
+  if (config.debug) {
+    debugLog(`Sending stop request to ${url}`);
+    debugLog(`=== SENT TO ${url} ===`);
+    debugLogRawInline(bodyStr);
+    debugLog("=== END SENT ===");
+  }
+  const response = await httpPost(url, bodyStr, headers, stopTimeoutMs);
+  if (config.debug) {
+    debugLog(`Stop response: ${response.body || "<empty>"}`);
+  }
+  if (response.status !== 200) {
+    throw new Error(`Stop API returned status ${response.status}: ${response.body.slice(0, 200)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(response.body);
+  } catch {
+    parsed = {};
+  }
+  processConfigSync(parsed, config);
+  return parsed;
+}
 async function sendEvent(event, config, pluginPath) {
   if (!config.token) return;
   const eventType = event.eventType;
@@ -734,25 +844,37 @@ async function sendEvent(event, config, pluginPath) {
 }
 
 // src/index.ts
+var HOOK_PLUGIN = "opencode-plugin";
+var HOOK_PERMISSION = "opencode-permission";
+var HOOK_TOOL_BEFORE = "opencode-tool-before";
+var HOOK_TOOL_AFTER = "opencode-tool-after";
+var HOOK_CHAT_MSG = "opencode-chat-msg";
+var HOOK_EVENT = "opencode-event";
+var HOOK_COMPACTING = "opencode-compacting";
 var pluginFilePath;
 try {
   pluginFilePath = fileURLToPath(import.meta.url);
 } catch {
   pluginFilePath = __filename;
 }
-var sessionId = randomBytes2(12).toString("hex");
+var fallbackSessionId = randomBytes2(12).toString("hex");
 var COMPACTION_DEDUP_WINDOW_MS = 2e3;
 var openCodeClient = void 0;
 var lastCompactionEventAt = 0;
+var processingIdleSessions = /* @__PURE__ */ new Set();
+var seenUnmappedEventTypes = /* @__PURE__ */ new Set();
+var sentFinalMessageIds = /* @__PURE__ */ new Set();
+var messageParts = /* @__PURE__ */ new Map();
+var NOISY_EVENT_TYPES = /* @__PURE__ */ new Set(["message.part.delta"]);
 function classifyTool(toolName) {
   const lower = toolName.toLowerCase();
   if (lower === "bash") {
     return { toolType: "shell_command", displayName: toolName };
   }
-  if (lower === "write" || lower === "edit" || lower === "patch") {
+  if (lower === "write" || lower === "edit" || lower === "patch" || lower === "apply_patch") {
     return { toolType: "file_write", displayName: toolName };
   }
-  if (lower === "read" || lower === "grep" || lower === "glob" || lower === "list") {
+  if (lower === "read" || lower === "grep" || lower === "glob" || lower === "list" || lower === "ls" || lower === "codesearch") {
     return { toolType: "file_read", displayName: toolName };
   }
   if (lower === "webfetch" || lower === "websearch") {
@@ -772,10 +894,10 @@ function extractCommand(toolName, params) {
     return params.command || void 0;
   }
   if (lower === "write" || lower === "edit" || lower === "patch") {
-    return params.file_path || params.path || void 0;
+    return params.file_path || params.filePath || params.path || void 0;
   }
   if (lower === "read") {
-    return params.file_path || params.path || void 0;
+    return params.file_path || params.filePath || params.path || void 0;
   }
   if (lower === "grep") {
     return params.pattern || void 0;
@@ -794,9 +916,25 @@ function extractCommand(toolName, params) {
   }
   return void 0;
 }
+function resolveIds(preferredSessionId) {
+  const id = preferredSessionId || fallbackSessionId;
+  return { sessionId: id, conversationId: id };
+}
+function getEventSessionId(eventName, properties) {
+  const sessionID = properties.sessionID;
+  if (typeof sessionID === "string") return sessionID;
+  const info = properties.info;
+  if (info) {
+    if (typeof info.sessionID === "string") return info.sessionID;
+    if (eventName === "session.created" && typeof info.id === "string") return info.id;
+  }
+  const part = properties.part;
+  if (part && typeof part.sessionID === "string") return part.sessionID;
+  return void 0;
+}
 function handleFailBehavior(config, error, toolName) {
   if (config.debug) {
-    debugLog(`API error: ${error.message}, failBehavior: ${config.failBehavior}`);
+    debugLog(`API error: ${error.message}, failBehavior: ${config.failBehavior}`, HOOK_PERMISSION);
   }
   switch (config.failBehavior) {
     case "deny":
@@ -809,20 +947,11 @@ function handleFailBehavior(config, error, toolName) {
   }
 }
 function mapEventType(eventName) {
-  switch (eventName) {
-    case "session.created":
-      return "session_start";
-    case "session.idle":
-      return "stop";
-    case "session.compacted":
-      return "context_compact";
-    case "session.error":
-      return "error";
-    case "message.updated":
-      return "response";
-    default:
-      return void 0;
-  }
+  if (eventName.startsWith("session.created")) return "session_start";
+  if (eventName === "session.compacted") return "context_compact";
+  if (eventName === "session.updated") return void 0;
+  if (eventName.startsWith("session.error") || eventName === "session.event.error") return "error";
+  return void 0;
 }
 function shouldSkipCompactionEvent() {
   const now = Date.now();
@@ -832,9 +961,10 @@ function shouldSkipCompactionEvent() {
   lastCompactionEventAt = now;
   return false;
 }
-function plugin(context) {
+async function plugin(input) {
   const config = loadConfig();
-  openCodeClient = context.client;
+  openCodeClient = input.client;
+  const projectPath = input.directory || process.cwd();
   if (!config.token) {
     console.warn(
       "Agent Approve: No token found. Run the Agent Approve installer to pair with your account."
@@ -842,17 +972,39 @@ function plugin(context) {
     return {};
   }
   if (config.debug) {
-    debugLog(`Plugin loaded, API: ${config.apiUrl}, agent: ${config.agentName}`);
+    const e2eStatus = !config.e2eEnabled ? "disabled" : !config.e2eUserKey ? "enabled (key missing)" : "enabled";
+    debugLog(
+      `Plugin loaded: v${config.hookVersion}, api=${config.apiUrl}, privacy=${config.privacyTier}, e2e=${e2eStatus}, debug=${config.debug}`,
+      HOOK_PLUGIN
+    );
+    debugLog(`Full config: agent=${config.agentName}, timeout=${config.timeout}s, fail=${config.failBehavior}`, HOOK_PLUGIN);
   }
   return {
     // -------------------------------------------------------------------
     // permission.ask: Primary approval gate (blocking)
+    //
+    // Source signature (opencode/packages/plugin/src/index.ts L179):
+    //   (input: Permission, output: { status: "ask" | "deny" | "allow" }) => Promise<void>
+    //
+    // Permission = { id, type, pattern?, sessionID, messageID, callID?,
+    //                message, metadata, time: { created } }
+    //
+    // Called from opencode/packages/opencode/src/permission/index.ts L134:
+    //   Plugin.trigger("permission.ask", info, { status: "ask" })
     // -------------------------------------------------------------------
-    "permission.ask": async (input, output) => {
-      const toolName = input.tool.name;
-      const params = input.tool.input || {};
+    "permission.ask": async (input2, output) => {
+      if (config.debug) {
+        debugLogRaw({ input: input2, output }, HOOK_PERMISSION);
+        debugLog("Started permission.ask hook", HOOK_PERMISSION);
+      }
+      const toolName = input2.type;
+      const params = input2.metadata || {};
       const { toolType, displayName } = classifyTool(toolName);
       const command = extractCommand(toolName, params);
+      if (config.debug) {
+        debugLog(`Tool: ${displayName} (${toolType}) [agent: ${config.agentName}]`, HOOK_PERMISSION);
+      }
+      const ids = resolveIds(input2.sessionID);
       const request = {
         toolName: displayName,
         toolType,
@@ -861,27 +1013,28 @@ function plugin(context) {
         agent: config.agentType,
         agentName: config.agentName,
         hookType: "permission_ask",
-        sessionId,
-        conversationId: sessionId,
+        sessionId: ids.sessionId,
+        conversationId: ids.conversationId,
         cwd: params.workdir || params.cwd || void 0,
-        projectPath: process.cwd(),
+        projectPath,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       try {
         const response = await sendApprovalRequest(request, config, pluginFilePath);
+        if (config.debug) {
+          debugLog(`Decision: ${response.decision}, Reason: ${response.reason || ""}`, HOOK_PERMISSION);
+        }
         if (response.decision === "approve" || response.decision === "allow") {
           if (config.debug) {
-            debugLog(`Tool "${toolName}" approved${response.reason ? ": " + response.reason : ""}`);
+            debugLog("Tool approved", HOOK_PERMISSION);
           }
           output.status = "allow";
-          if (response.reason) output.reason = response.reason;
           return;
         }
         if (config.debug) {
-          debugLog(`Tool "${toolName}" denied${response.reason ? ": " + response.reason : ""}`);
+          debugLog("Tool denied", HOOK_PERMISSION);
         }
         output.status = "deny";
-        output.reason = response.reason || "Denied by Agent Approve";
       } catch (error) {
         const result = handleFailBehavior(
           config,
@@ -895,10 +1048,24 @@ function plugin(context) {
     },
     // -------------------------------------------------------------------
     // tool.execute.before: Tool start monitoring (non-blocking)
+    //
+    // Source signature (opencode/packages/plugin/src/index.ts L184-187):
+    //   (input: { tool: string; sessionID: string; callID: string },
+    //    output: { args: any }) => Promise<void>
+    //
+    // Called from opencode/packages/opencode/src/session/prompt.ts L792-802:
+    //   Plugin.trigger("tool.execute.before",
+    //     { tool: item.id, sessionID: ctx.sessionID, callID: ctx.callID },
+    //     { args })
     // -------------------------------------------------------------------
-    "tool.execute.before": async (input) => {
-      const toolName = input.tool.name;
-      const params = input.tool.input || {};
+    "tool.execute.before": async (input2, output) => {
+      if (config.debug) {
+        debugLogRaw({ input: input2, output }, HOOK_TOOL_BEFORE);
+        debugLog(`Tool start: ${input2.tool} [session: ${input2.sessionID}]`, HOOK_TOOL_BEFORE);
+      }
+      const ids = resolveIds(input2.sessionID);
+      const toolName = input2.tool;
+      const params = output.args && typeof output.args === "object" ? output.args : {};
       const { toolType } = classifyTool(toolName);
       void sendEvent({
         toolName,
@@ -907,8 +1074,8 @@ function plugin(context) {
         agent: config.agentType,
         agentName: config.agentName,
         hookType: "tool_execute_before",
-        sessionId,
-        conversationId: sessionId,
+        sessionId: ids.sessionId,
+        conversationId: ids.conversationId,
         command: extractCommand(toolName, params),
         toolInput: params,
         cwd: params.workdir || params.cwd || void 0,
@@ -917,13 +1084,28 @@ function plugin(context) {
     },
     // -------------------------------------------------------------------
     // tool.execute.after: Tool completion logging (non-blocking)
+    //
+    // Source signature (opencode/packages/plugin/src/index.ts L192-199):
+    //   (input: { tool: string; sessionID: string; callID: string; args: any },
+    //    output: { title: string; output: string; metadata: any }) => Promise<void>
+    //
+    // Called from opencode/packages/opencode/src/session/prompt.ts L813-822:
+    //   Plugin.trigger("tool.execute.after",
+    //     { tool: item.id, sessionID: ctx.sessionID, callID: ctx.callID, args },
+    //     output)
     // -------------------------------------------------------------------
-    "tool.execute.after": async (input) => {
-      const toolName = input.tool.name;
-      const params = input.tool.input || {};
+    "tool.execute.after": async (input2, output) => {
+      if (config.debug) {
+        debugLogRaw({ input: input2, output }, HOOK_TOOL_AFTER);
+        const resultLen = typeof output?.output === "string" ? output.output.length : 0;
+        debugLog(`Tool complete: ${input2.tool}, output=${resultLen} chars${output?.metadata?.error ? ", ERROR" : ""}`, HOOK_TOOL_AFTER);
+      }
+      const ids = resolveIds(input2.sessionID);
+      const toolName = input2.tool;
+      const params = input2.args && typeof input2.args === "object" ? input2.args : {};
       const { toolType } = classifyTool(toolName);
-      const resultStr = input.result != null ? typeof input.result === "string" ? input.result : JSON.stringify(input.result) : void 0;
-      const response = input.error || resultStr || void 0;
+      const resultStr = typeof output?.output === "string" ? output.output : void 0;
+      const response = resultStr || void 0;
       const responsePreview = resultStr && resultStr.length > 1e3 ? resultStr.slice(0, 1e3) + "..." : resultStr;
       void sendEvent({
         toolName,
@@ -932,31 +1114,48 @@ function plugin(context) {
         agent: config.agentType,
         agentName: config.agentName,
         hookType: "tool_execute_after",
-        sessionId,
-        conversationId: sessionId,
+        sessionId: ids.sessionId,
+        conversationId: ids.conversationId,
         command: extractCommand(toolName, params),
         toolInput: params,
-        status: input.error ? "error" : "success",
+        status: output?.metadata?.error ? "error" : "success",
         response,
         responsePreview,
-        durationMs: input.durationMs,
         cwd: params.workdir || params.cwd || void 0,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }, config, pluginFilePath);
     },
     // -------------------------------------------------------------------
     // chat.message: User prompt capture (non-blocking)
+    //
+    // Source signature (opencode/packages/plugin/src/index.ts L158-167):
+    //   (input: { sessionID: string; agent?: string; model?: {...};
+    //             messageID?: string; variant?: string },
+    //    output: { message: UserMessage; parts: Part[] }) => Promise<void>
+    //
+    // Called from opencode/packages/opencode/src/session/prompt.ts L1295-1308:
+    //   Plugin.trigger("chat.message",
+    //     { sessionID, agent, model, messageID, variant },
+    //     { message: info, parts })
+    //
+    // Only fires for user messages (inside createUserMessage).
+    // User text is in output.parts where part.type === "text" && !part.synthetic
     // -------------------------------------------------------------------
-    "chat.message": async (input) => {
-      if (input.role && input.role !== "user") return;
-      const text = input.content || "";
+    "chat.message": async (input2, output) => {
+      if (config.debug) {
+        debugLogRaw({ input: input2, output }, HOOK_CHAT_MSG);
+        debugLog(`Chat message: session=${input2.sessionID}, parts=${output.parts?.length ?? 0}, agent=${input2.agent || "default"}`, HOOK_CHAT_MSG);
+      }
+      const ids = resolveIds(input2.sessionID);
+      const textParts = (output.parts || []).filter((p) => p.type === "text" && !p.synthetic && p.text).map((p) => p.text);
+      const text = textParts.join("\n");
       void sendEvent({
         eventType: "user_prompt",
         agent: config.agentType,
         agentName: config.agentName,
         hookType: "chat_message",
-        sessionId,
-        conversationId: sessionId,
+        sessionId: ids.sessionId,
+        conversationId: ids.conversationId,
         prompt: text,
         textLength: text.length,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -964,56 +1163,181 @@ function plugin(context) {
     },
     // -------------------------------------------------------------------
     // event: Catch-all session lifecycle events (blocking for session.idle)
+    //
+    // Source signature (opencode/packages/plugin/src/index.ts L149):
+    //   event?: (input: { event: Event }) => Promise<void>
+    //
+    // Dispatched from opencode/packages/opencode/src/plugin/index.ts L134-141:
+    //   Bus.subscribeAll(async (input) => {
+    //     for (const hook of hooks) { hook["event"]?.({ event: input }) }
+    //   })
+    //
+    // Bus events have shape: { type: string, properties: ... }
     // -------------------------------------------------------------------
-    "event": async (input) => {
-      const eventName = input.type;
-      const agEventType = mapEventType(eventName);
-      if (!agEventType) {
-        if (config.debug) {
-          debugLog(`Ignoring unmapped event: ${eventName}`);
+    "event": async (input2) => {
+      const eventName = input2.event?.type;
+      if (!eventName) return;
+      if (NOISY_EVENT_TYPES.has(eventName)) return;
+      const eventProperties = input2.event.properties || {};
+      const eventSessionId = getEventSessionId(eventName, eventProperties);
+      const ids = resolveIds(eventSessionId);
+      if (config.debug) {
+        debugLog(`Event received: ${eventName}`, HOOK_EVENT);
+      }
+      if (eventName === "message.part.updated") {
+        const part = eventProperties.part;
+        if (!part) return;
+        const messageID = part.messageID;
+        const partID = part.id;
+        const partType = part.type;
+        if (typeof messageID !== "string" || typeof partID !== "string" || typeof partType !== "string") return;
+        const partsByMessage = messageParts.get(messageID) || /* @__PURE__ */ new Map();
+        partsByMessage.set(partID, {
+          type: partType,
+          text: typeof part.text === "string" ? part.text : void 0,
+          synthetic: part.synthetic === true,
+          ignored: part.ignored === true,
+          sessionID: typeof part.sessionID === "string" ? part.sessionID : void 0
+        });
+        messageParts.set(messageID, partsByMessage);
+        return;
+      }
+      if (eventName === "message.part.removed") {
+        const messageID = eventProperties.messageID;
+        const partID = eventProperties.partID;
+        if (typeof messageID === "string" && typeof partID === "string") {
+          messageParts.get(messageID)?.delete(partID);
         }
         return;
       }
-      if (agEventType === "context_compact" && shouldSkipCompactionEvent()) {
-        if (config.debug) {
-          debugLog(`Skipping duplicate context_compact from ${eventName}`);
+      if (eventName === "message.updated") {
+        const info = eventProperties.info;
+        if (!info) return;
+        if (info.role !== "assistant") return;
+        const messageID = info.id;
+        const finish = info.finish;
+        if (typeof messageID !== "string" || typeof finish !== "string") return;
+        if (finish === "tool-calls" || finish === "unknown") return;
+        if (sentFinalMessageIds.has(messageID)) return;
+        sentFinalMessageIds.add(messageID);
+        const partsByMessage = messageParts.get(messageID);
+        const parts = partsByMessage ? Array.from(partsByMessage.values()) : [];
+        const thoughtText = parts.filter((p) => p.type === "reasoning" && typeof p.text === "string" && p.text.length > 0).map((p) => p.text).join("\n");
+        const responseText = parts.filter((p) => p.type === "text" && !p.synthetic && !p.ignored && typeof p.text === "string" && p.text.length > 0).map((p) => p.text).join("\n");
+        if (thoughtText) {
+          void sendEvent({
+            eventType: "thought",
+            agent: config.agentType,
+            agentName: config.agentName,
+            hookType: "event",
+            sessionId: ids.sessionId,
+            conversationId: ids.conversationId,
+            trigger: eventName,
+            text: thoughtText,
+            textPreview: thoughtText.slice(0, 200),
+            textLength: thoughtText.length,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }, config, pluginFilePath);
         }
+        if (responseText) {
+          void sendEvent({
+            eventType: "response",
+            agent: config.agentType,
+            agentName: config.agentName,
+            hookType: "event",
+            sessionId: ids.sessionId,
+            conversationId: ids.conversationId,
+            trigger: eventName,
+            text: responseText,
+            textPreview: responseText.slice(0, 200),
+            textLength: responseText.length,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }, config, pluginFilePath);
+        }
+        messageParts.delete(messageID);
         return;
       }
-      if (eventName === "session.idle") {
+      if (eventName === "session.idle") return;
+      const status = eventProperties.status;
+      if (eventName === "session.status" && status?.type !== "idle") {
+        processingIdleSessions.delete(ids.sessionId);
+        return;
+      }
+      if (eventName === "session.status" && status?.type === "idle") {
+        if (processingIdleSessions.has(ids.sessionId)) {
+          if (config.debug) {
+            debugLog("Skipping duplicate session.status idle (already processing)", HOOK_EVENT);
+          }
+          return;
+        }
+        processingIdleSessions.add(ids.sessionId);
         if (config.debug) {
-          debugLog("Session idle detected, sending blocking stop event");
+          debugLog("Session idle detected via session.status, sending stop request", HOOK_EVENT);
         }
         const stopRequest = {
-          toolName: "session_idle",
-          toolType: "session",
           agent: config.agentType,
           agentName: config.agentName,
-          hookType: "stop",
-          sessionId,
-          conversationId: sessionId,
-          projectPath: process.cwd(),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          eventType: "stop",
+          status: "completed",
+          loopCount: 0,
+          sessionId: ids.sessionId,
+          conversationId: ids.conversationId,
+          timestamp: Date.now(),
+          ...config.e2eEnabled && config.e2eUserKey ? { e2eKeyId: keyId(config.e2eUserKey) } : {}
         };
         try {
-          const response = await sendApprovalRequest(stopRequest, config, pluginFilePath);
-          if ((response.decision === "approve" || response.decision === "allow") && response.reason && openCodeClient) {
+          const response = await sendStopRequest(stopRequest, config, pluginFilePath);
+          if (config.debug) {
+            debugLog(`Stop response: followup=${response.followup_message ? "yes" : "no"}`, HOOK_EVENT);
+          }
+          if (response.followup_message && openCodeClient) {
+            let followupText = response.followup_message;
+            if (config.e2eEnabled && config.e2eUserKey && isE2EEncrypted(followupText)) {
+              const decrypted = e2eDecrypt(config.e2eUserKey, followupText);
+              if (decrypted) {
+                if (config.debug) {
+                  debugLog(`Decrypted follow-up: ${decrypted.slice(0, 50)}...`, HOOK_EVENT);
+                }
+                followupText = decrypted;
+              } else {
+                if (config.debug) {
+                  debugLog("E2E decryption failed for follow-up message, skipping injection", HOOK_EVENT);
+                }
+                return;
+              }
+            }
             if (config.debug) {
-              debugLog(`Stop approved with follow-up input: ${response.reason.slice(0, 100)}`);
+              debugLog(`Injecting user follow-up: ${followupText.slice(0, 100)}`, HOOK_EVENT);
             }
             try {
-              await openCodeClient.tui.appendPrompt({ body: { text: response.reason } });
+              await openCodeClient.tui.appendPrompt({ body: { text: followupText } });
               await openCodeClient.tui.submitPrompt();
             } catch (injectionError) {
               if (config.debug) {
-                debugLog(`Failed to inject follow-up input: ${injectionError instanceof Error ? injectionError.message : String(injectionError)}`);
+                debugLog(`Failed to inject follow-up: ${injectionError instanceof Error ? injectionError.message : String(injectionError)}`, HOOK_EVENT);
               }
             }
           }
         } catch (error) {
           if (config.debug) {
-            debugLog(`Stop event error: ${error instanceof Error ? error.message : String(error)}`);
+            debugLog(`Stop request error: ${error instanceof Error ? error.message : String(error)}`, HOOK_EVENT);
           }
+        } finally {
+          processingIdleSessions.delete(ids.sessionId);
+        }
+        return;
+      }
+      const agEventType = mapEventType(eventName);
+      if (!agEventType) {
+        if (config.debug && !seenUnmappedEventTypes.has(eventName)) {
+          seenUnmappedEventTypes.add(eventName);
+          debugLog(`Ignoring unmapped event type: ${eventName}`, HOOK_EVENT);
+        }
+        return;
+      }
+      if (agEventType === "context_compact" && shouldSkipCompactionEvent()) {
+        if (config.debug) {
+          debugLog(`Skipping duplicate context_compact from ${eventName}`, HOOK_EVENT);
         }
         return;
       }
@@ -1022,34 +1346,47 @@ function plugin(context) {
         agent: config.agentType,
         agentName: config.agentName,
         hookType: "event",
-        sessionId,
-        conversationId: sessionId,
+        sessionId: ids.sessionId,
+        conversationId: ids.conversationId,
         trigger: eventName,
-        text: input.data ? JSON.stringify(input.data).slice(0, 500) : void 0,
+        text: Object.keys(eventProperties).length > 0 ? JSON.stringify(eventProperties).slice(0, 500) : void 0,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }, config, pluginFilePath);
     },
     // -------------------------------------------------------------------
     // experimental.session.compacting: Pre-compaction event (non-blocking)
+    //
+    // Source signature (opencode/packages/plugin/src/index.ts L222-225):
+    //   (input: { sessionID: string },
+    //    output: { context: string[]; prompt?: string }) => Promise<void>
+    //
+    // Called from opencode/packages/opencode/src/session/compaction.ts L146-150:
+    //   Plugin.trigger("experimental.session.compacting",
+    //     { sessionID: input.sessionID },
+    //     { context: [], prompt: undefined })
     // -------------------------------------------------------------------
-    "experimental.session.compacting": async (input) => {
+    "experimental.session.compacting": async (input2, _output) => {
+      if (config.debug) {
+        debugLogRaw({ input: input2 }, HOOK_COMPACTING);
+      }
+      const ids = resolveIds(input2.sessionID);
       if (shouldSkipCompactionEvent()) {
         if (config.debug) {
-          debugLog("Skipping duplicate context_compact from experimental.session.compacting");
+          debugLog("Skipping duplicate context_compact from experimental.session.compacting", HOOK_COMPACTING);
         }
         return;
       }
       if (config.debug) {
-        debugLog(`Context compaction: ${input.messageCount ?? "?"} messages${input.tokenCount ? `, ${input.tokenCount} tokens` : ""}`);
+        debugLog(`Context compaction starting for session ${input2.sessionID}`, HOOK_COMPACTING);
       }
       void sendEvent({
         eventType: "context_compact",
         agent: config.agentType,
         agentName: config.agentName,
         hookType: "session_compacting",
-        sessionId,
-        conversationId: sessionId,
-        trigger: `${input.messageCount ?? "?"} messages${input.tokenCount ? `, ${input.tokenCount} tokens` : ""}`,
+        sessionId: ids.sessionId,
+        conversationId: ids.conversationId,
+        trigger: "experimental.session.compacting",
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }, config, pluginFilePath);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentapprove/opencode",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Agent Approve plugin for OpenCode - approve or deny AI agent tool calls from your iPhone and Apple Watch",
   "main": "dist/index.js",
   "scripts": {