@raindrop-ai/claude-code 0.0.4 → 0.0.6

package/dist/index.cjs

@@ -20,15 +20,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  DEFAULT_CATEGORY_KEYS: () => DEFAULT_CATEGORY_KEYS,
   EventShipper: () => EventShipper2,
   PACKAGE_NAME: () => PACKAGE_NAME,
   PACKAGE_VERSION: () => PACKAGE_VERSION,
+  TOOL_SCHEMA: () => TOOL_SCHEMA,
   TraceShipper: () => TraceShipper2,
   detectLocalDebugger: () => detectLocalDebugger,
+  executeTool: () => executeTool,
+  extractAppendSystemPrompt: () => extractAppendSystemPrompt,
   getConfigPath: () => getConfigPath,
   loadConfig: () => loadConfig,
   mapHookToRaindrop: () => mapHookToRaindrop,
   mirrorEventToLocalDebugger: () => mirrorEventToLocalDebugger,
+  normalizeSignals: () => normalizeSignals,
+  parseTranscript: () => parseTranscript,
+  resolveCurrentEventId: () => resolveCurrentEventId,
+  resolveToolConfig: () => resolveToolConfig,
+  startMcpServer: () => startMcpServer,
+  transcriptToProperties: () => transcriptToProperties,
   updateConfig: () => updateConfig
 });
 module.exports = __toCommonJS(src_exports);
@@ -680,7 +690,7 @@ globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = import_async_hooks.AsyncLocalStorage;
 
 // src/package-info.ts
 var PACKAGE_NAME = "@raindrop-ai/claude-code";
-var PACKAGE_VERSION = "0.0.4";
+var PACKAGE_VERSION = "0.0.6";
 
 // src/shipper.ts
 var EventShipper2 = class extends EventShipper {
@@ -749,6 +759,17 @@ function loadConfig() {
     } catch (e) {
     }
   }
+  let selfDiagnostics = file.self_diagnostics;
+  const envDiag = process.env["RAINDROP_SELF_DIAGNOSTICS"];
+  if (envDiag) {
+    try {
+      const parsed = JSON.parse(envDiag);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        selfDiagnostics = parsed;
+      }
+    } catch (e) {
+    }
+  }
   return {
     writeKey: (_c = (_b = process.env["RAINDROP_WRITE_KEY"]) != null ? _b : file.write_key) != null ? _c : "",
     endpoint: (_e = (_d = process.env["RAINDROP_API_URL"]) != null ? _d : file.api_url) != null ? _e : "https://api.raindrop.ai/v1",
@@ -756,7 +777,8 @@ function loadConfig() {
     debug: process.env["RAINDROP_DEBUG"] === "true" ? true : (_h = file.debug) != null ? _h : false,
     enabled: (_i = file.enabled) != null ? _i : true,
     eventName: (_k = (_j = process.env["RAINDROP_EVENT_NAME"]) != null ? _j : file.event_name) != null ? _k : "claude_code_session",
-    customProperties
+    customProperties,
+    selfDiagnostics
   };
 }
 function getConfigPath() {
@@ -776,10 +798,145 @@ function updateConfig(patch) {
 }
 
 // src/event-mapper.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
+var import_node_child_process = require("child_process");
 var import_node_crypto = require("crypto");
 var import_node_os2 = require("os");
 var import_node_path2 = require("path");
+
+// src/transcript.ts
+var import_node_fs2 = require("fs");
+function parseTranscript(transcriptPath) {
+  var _a, _b, _c, _d, _e;
+  try {
+    if (!(0, import_node_fs2.existsSync)(transcriptPath)) return void 0;
+    const content = (0, import_node_fs2.readFileSync)(transcriptPath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    const summary = {
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCacheReadTokens: 0,
+      totalCacheCreationTokens: 0,
+      turnCount: 0,
+      toolsUsed: [],
+      hasThinking: false
+    };
+    const toolNames = /* @__PURE__ */ new Set();
+    let lastUsage;
+    for (const line of lines) {
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch (e) {
+        continue;
+      }
+      if (entry.type === "system" && entry.subtype === "turn_duration") {
+        const durationMs = entry["durationMs"];
+        if (typeof durationMs === "number") {
+          summary.totalDurationMs = ((_a = summary.totalDurationMs) != null ? _a : 0) + durationMs;
+        }
+        const version = entry["version"];
+        if (typeof version === "string") {
+          summary.codeVersion = version;
+        }
+        const branch = entry["gitBranch"];
+        if (typeof branch === "string") {
+          summary.gitBranch = branch;
+        }
+        continue;
+      }
+      if (entry.type !== "assistant") continue;
+      const msg = entry.message;
+      if (!msg) continue;
+      summary.turnCount++;
+      if (msg.model) {
+        summary.model = msg.model;
+      }
+      if (msg.stop_reason) {
+        summary.stopReason = msg.stop_reason;
+      }
+      const entryVersion = entry["version"];
+      if (typeof entryVersion === "string") {
+        summary.codeVersion = entryVersion;
+      }
+      const entryBranch = entry["gitBranch"];
+      if (typeof entryBranch === "string") {
+        summary.gitBranch = entryBranch;
+      }
+      if (msg.usage) {
+        const u = msg.usage;
+        summary.totalInputTokens += (_b = u.input_tokens) != null ? _b : 0;
+        summary.totalOutputTokens += (_c = u.output_tokens) != null ? _c : 0;
+        summary.totalCacheReadTokens += (_d = u.cache_read_input_tokens) != null ? _d : 0;
+        summary.totalCacheCreationTokens += (_e = u.cache_creation_input_tokens) != null ? _e : 0;
+        if (u.service_tier) {
+          summary.serviceTier = u.service_tier;
+        }
+        lastUsage = u;
+      }
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "tool_use" && block.name) {
+            toolNames.add(block.name);
+          }
+          if (block.type === "thinking") {
+            summary.hasThinking = true;
+          }
+        }
+      }
+    }
+    if (lastUsage) {
+      summary.lastTurnInputTokens = lastUsage.input_tokens;
+      summary.lastTurnOutputTokens = lastUsage.output_tokens;
+      summary.lastTurnCacheReadTokens = lastUsage.cache_read_input_tokens;
+    }
+    summary.toolsUsed = [...toolNames].sort();
+    return summary;
+  } catch (e) {
+    return void 0;
+  }
+}
+function transcriptToProperties(summary) {
+  var _a, _b;
+  const props = {};
+  props["ai.usage.prompt_tokens"] = (_a = summary.lastTurnInputTokens) != null ? _a : summary.totalInputTokens;
+  props["ai.usage.completion_tokens"] = (_b = summary.lastTurnOutputTokens) != null ? _b : summary.totalOutputTokens;
+  if (summary.lastTurnCacheReadTokens !== void 0) {
+    props["ai.usage.cache_read_tokens"] = summary.lastTurnCacheReadTokens;
+  }
+  props["ai.usage.session_total.prompt_tokens"] = summary.totalInputTokens;
+  props["ai.usage.session_total.completion_tokens"] = summary.totalOutputTokens;
+  props["ai.usage.session_total.cache_read_tokens"] = summary.totalCacheReadTokens;
+  props["ai.usage.session_total.cache_creation_tokens"] = summary.totalCacheCreationTokens;
+  if (summary.model) {
+    props["ai.model"] = summary.model;
+  }
+  if (summary.serviceTier) {
+    props["ai.service_tier"] = summary.serviceTier;
+  }
+  if (summary.stopReason) {
+    props["ai.stop_reason"] = summary.stopReason;
+  }
+  if (summary.toolsUsed.length > 0) {
+    props["ai.tools_used"] = summary.toolsUsed.join(", ");
+  }
+  props["ai.turn_count"] = summary.turnCount;
+  if (summary.totalDurationMs !== void 0) {
+    props["ai.duration_ms"] = summary.totalDurationMs;
+  }
+  if (summary.codeVersion) {
+    props["claude_code.version"] = summary.codeVersion;
+  }
+  if (summary.gitBranch) {
+    props["git.branch"] = summary.gitBranch;
+  }
+  if (summary.hasThinking) {
+    props["ai.has_thinking"] = true;
+  }
+  return props;
+}
+
+// src/event-mapper.ts
 var MAX_ATTR_LENGTH = 32768;
 function truncate(value) {
   if (value === void 0) return void 0;
@@ -798,7 +955,7 @@ function safeStringify(value) {
 var STATE_DIR = (0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "raindrop-claude-code");
 function ensureStateDir() {
   try {
-    (0, import_node_fs2.mkdirSync)(STATE_DIR, { recursive: true });
+    (0, import_node_fs3.mkdirSync)(STATE_DIR, { recursive: true });
   } catch (e) {
   }
 }
@@ -816,22 +973,22 @@ function statePath(key) {
 function writeState(key, value) {
   try {
     ensureStateDir();
-    (0, import_node_fs2.writeFileSync)(statePath(key), value, "utf-8");
+    (0, import_node_fs3.writeFileSync)(statePath(key), value, "utf-8");
   } catch (e) {
   }
 }
 function readState(key) {
   try {
     const filePath = statePath(key);
-    if (!(0, import_node_fs2.existsSync)(filePath)) return void 0;
-    return (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+    if (!(0, import_node_fs3.existsSync)(filePath)) return void 0;
+    return (0, import_node_fs3.readFileSync)(filePath, "utf-8");
   } catch (e) {
     return void 0;
   }
 }
 function deleteState(key) {
   try {
-    (0, import_node_fs2.unlinkSync)(statePath(key));
+    (0, import_node_fs3.unlinkSync)(statePath(key));
   } catch (e) {
   }
 }
@@ -889,12 +1046,15 @@ async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
     cwd: payload.cwd,
     permission_mode: payload.permission_mode,
     plugin_version: PACKAGE_VERSION,
+    sdk: PACKAGE_NAME,
+    sdk_version: PACKAGE_VERSION,
     ...payload.agent_id ? { agent_id: payload.agent_id } : {},
     ...payload.agent_type ? { agent_type: payload.agent_type } : {}
   };
   switch (payload.hook_event_name) {
     case "SessionStart":
       writeState(`model_${payload.session_id}`, (_a = payload.model) != null ? _a : "");
+      tryCaptureAppendSystemPrompt(payload.session_id);
       break;
     case "UserPromptSubmit":
       await handleUserPromptSubmit(payload, convoId, config, baseProperties, eventShipper, traceShipper);
@@ -909,10 +1069,13 @@ async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
       handlePostToolUseFailure(payload, getCurrentEventId(payload.session_id), traceShipper);
       break;
     case "Stop":
-      await handleStop(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
+      await handleStopOrFailure(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper, traceShipper);
       break;
     case "StopFailure":
-      await handleStopFailure(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
+      await handleStopOrFailure(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper, traceShipper, {
+        error: payload.error,
+        error_details: payload.error_details
+      });
       break;
     case "SubagentStart":
       handleSubagentStart(payload, getCurrentEventId(payload.session_id), traceShipper);
@@ -923,6 +1086,9 @@ async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
     case "PermissionDenied":
       handlePermissionDenied(payload, getCurrentEventId(payload.session_id), traceShipper);
       break;
+    case "InstructionsLoaded":
+      handleInstructionsLoaded(payload);
+      break;
     case "PostCompact":
       await handlePostCompact(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
       break;
@@ -931,6 +1097,8 @@ async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
       deleteState(turnEventKey(payload.session_id));
       deleteState(rootSpanKey(payload.session_id));
       deleteState(`model_${payload.session_id}`);
+      deleteState(appendSystemPromptKey(payload.session_id));
+      cleanupInstructions(payload.session_id);
       break;
     default:
       if (config.debug) {
@@ -1088,25 +1256,243 @@ async function handlePostCompact(payload, eventId, config, properties, eventShip
     }
   });
 }
-async function handleStop(payload, eventId, config, properties, eventShipper) {
-  await eventShipper.patch(eventId, {
-    isPending: false,
-    userId: config.userId,
-    eventName: config.eventName,
-    output: payload.last_assistant_message,
-    properties
-  });
+function handleInstructionsLoaded(payload) {
+  var _a;
+  if (!payload.file_path || !payload.session_id) return;
+  try {
+    if ((0, import_node_fs3.existsSync)(payload.file_path)) {
+      const content = (0, import_node_fs3.readFileSync)(payload.file_path, "utf-8");
+      const MAX_INSTRUCTIONS_LENGTH = 8192;
+      const truncated = content.length > MAX_INSTRUCTIONS_LENGTH ? content.slice(0, MAX_INSTRUCTIONS_LENGTH) + "\n...[truncated]" : content;
+      const fileKey = safeKey(payload.file_path);
+      const header = `# ${(_a = payload.memory_type) != null ? _a : "instructions"}: ${payload.file_path}
+`;
+      writeState(
+        `instr_${payload.session_id}_${fileKey}`,
+        header + truncated
+      );
+    }
+  } catch (e) {
+  }
+}
+function gatherInstructions(sessionId) {
+  try {
+    if (!(0, import_node_fs3.existsSync)(STATE_DIR)) return void 0;
+    const prefix = safeKey(`instr_${sessionId}_`);
+    const files = (0, import_node_fs3.readdirSync)(STATE_DIR).filter((f) => f.startsWith(prefix));
+    if (files.length === 0) return void 0;
+    const parts = [];
+    for (const file of files.sort()) {
+      try {
+        parts.push((0, import_node_fs3.readFileSync)((0, import_node_path2.join)(STATE_DIR, file), "utf-8"));
+      } catch (e) {
+        continue;
+      }
+    }
+    return parts.length > 0 ? parts.join("\n\n---\n\n") : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function cleanupInstructions(sessionId) {
+  try {
+    if (!(0, import_node_fs3.existsSync)(STATE_DIR)) return;
+    const prefix = safeKey(`instr_${sessionId}_`);
+    for (const file of (0, import_node_fs3.readdirSync)(STATE_DIR).filter((f) => f.startsWith(prefix))) {
+      try {
+        (0, import_node_fs3.unlinkSync)((0, import_node_path2.join)(STATE_DIR, file));
+      } catch (e) {
+      }
+    }
+  } catch (e) {
+  }
+}
+var APPEND_FLAG = "--append-system-prompt";
+var APPEND_FILE_FLAG = "--append-system-prompt-file";
+var MAX_ANCESTOR_DEPTH = 15;
+var PS_TIMEOUT_MS = 3e3;
+function appendSystemPromptKey(sessionId) {
+  return `append_sysprompt_${sessionId}`;
 }
-async function handleStopFailure(payload, eventId, config, properties, eventShipper) {
+function tryCaptureAppendSystemPrompt(sessionId) {
+  try {
+    const content = readAncestorAppendSystemPrompt();
+    if (content) {
+      writeState(appendSystemPromptKey(sessionId), content);
+    }
+  } catch (e) {
+  }
+}
+function readAncestorAppendSystemPrompt() {
+  let pid;
+  try {
+    pid = process.ppid;
+  } catch (e) {
+    return void 0;
+  }
+  if (!pid || pid <= 1) return void 0;
+  for (let depth = 0; depth < MAX_ANCESTOR_DEPTH && pid != null && pid > 1; depth++) {
+    try {
+      const args = getProcessArgs(pid);
+      if (args && args.length > 0) {
+        const content = extractAppendSystemPrompt(args);
+        if (content) return content;
+      }
+    } catch (e) {
+    }
+    try {
+      pid = getParentPid(pid);
+    } catch (e) {
+      break;
+    }
+  }
+  return void 0;
+}
+function getProcessArgs(pid) {
+  if (process.platform === "linux") {
+    try {
+      const raw = (0, import_node_fs3.readFileSync)(`/proc/${pid}/cmdline`, "utf-8");
+      const args = raw.split("\0").filter(Boolean);
+      return args.length > 0 ? args : void 0;
+    } catch (e) {
+    }
+  }
+  try {
+    const output = (0, import_node_child_process.execSync)(`ps -ww -o args= -p ${pid}`, {
+      encoding: "utf-8",
+      timeout: PS_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const trimmed = output.trim();
+    if (!trimmed) return void 0;
+    return trimmed.split(/\s+/);
+  } catch (e) {
+    return void 0;
+  }
+}
+function getParentPid(pid) {
+  try {
+    const output = (0, import_node_child_process.execSync)(`ps -o ppid= -p ${pid}`, {
+      encoding: "utf-8",
+      timeout: PS_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const ppid = parseInt(output.trim(), 10);
+    return Number.isFinite(ppid) && ppid > 0 ? ppid : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function extractAppendSystemPrompt(args) {
+  const parts = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    try {
+      if (arg === APPEND_FILE_FLAG && i + 1 < args.length) {
+        const filePath = args[i + 1];
+        i++;
+        try {
+          if ((0, import_node_fs3.existsSync)(filePath)) {
+            parts.push((0, import_node_fs3.readFileSync)(filePath, "utf-8"));
+          }
+        } catch (e) {
+        }
+        continue;
+      }
+      if (arg.startsWith(APPEND_FILE_FLAG + "=")) {
+        const filePath = arg.slice(APPEND_FILE_FLAG.length + 1);
+        try {
+          if (filePath && (0, import_node_fs3.existsSync)(filePath)) {
+            parts.push((0, import_node_fs3.readFileSync)(filePath, "utf-8"));
+          }
+        } catch (e) {
+        }
+        continue;
+      }
+      if (arg === APPEND_FLAG && i + 1 < args.length) {
+        const valueParts = [];
+        for (let j = i + 1; j < args.length; j++) {
+          if (args[j].startsWith("--")) break;
+          valueParts.push(args[j]);
+          i = j;
+        }
+        if (valueParts.length > 0) {
+          parts.push(valueParts.join(" "));
+        }
+        continue;
+      }
+      if (arg.startsWith(APPEND_FLAG + "=") && !arg.startsWith(APPEND_FILE_FLAG)) {
+        const value = arg.slice(APPEND_FLAG.length + 1);
+        if (value) {
+          parts.push(value);
+        }
+        continue;
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : void 0;
+}
+function readAppendSystemPrompt(sessionId) {
+  try {
+    return readState(appendSystemPromptKey(sessionId)) || void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function enrichFromTranscript(payload, eventId, traceShipper) {
+  var _a, _b;
+  if (!payload.transcript_path) {
+    return { summary: void 0, props: {} };
+  }
+  try {
+    const summary = parseTranscript(payload.transcript_path);
+    if (!summary) return { summary: void 0, props: {} };
+    const props = transcriptToProperties(summary);
+    const spanInputTokens = (_a = summary.lastTurnInputTokens) != null ? _a : summary.totalInputTokens;
+    const spanOutputTokens = (_b = summary.lastTurnOutputTokens) != null ? _b : summary.totalOutputTokens;
+    if (summary.model && (spanInputTokens > 0 || spanOutputTokens > 0)) {
+      const parent = getParentContext(payload);
+      const now = nowUnixNanoString();
+      traceShipper.createSpan({
+        name: summary.model,
+        eventId,
+        parent,
+        startTimeUnixNano: now,
+        endTimeUnixNano: now,
+        attributes: [
+          attrString("ai.operationId", "generateText"),
+          attrString("gen_ai.response.model", summary.model),
+          attrString("gen_ai.system", "anthropic"),
+          attrInt("gen_ai.usage.prompt_tokens", spanInputTokens),
+          attrInt("gen_ai.usage.completion_tokens", spanOutputTokens),
+          ...summary.lastTurnCacheReadTokens != null && summary.lastTurnCacheReadTokens > 0 ? [attrInt("gen_ai.usage.cache_read_tokens", summary.lastTurnCacheReadTokens)] : []
+        ]
+      });
+    }
+    return { summary, props };
+  } catch (e) {
+    return { summary: void 0, props: {} };
+  }
+}
+async function handleStopOrFailure(payload, eventId, config, properties, eventShipper, traceShipper, extraProperties) {
+  const { summary, props: transcriptProps } = enrichFromTranscript(payload, eventId, traceShipper);
+  const instructions = gatherInstructions(payload.session_id);
+  const appendSysPrompt = readAppendSystemPrompt(payload.session_id);
   await eventShipper.patch(eventId, {
     isPending: false,
     userId: config.userId,
+    convoId: payload.session_id,
     eventName: config.eventName,
     output: payload.last_assistant_message,
+    ...(summary == null ? void 0 : summary.model) ? { model: summary.model } : {},
     properties: {
       ...properties,
-      error: payload.error,
-      error_details: payload.error_details
+      ...transcriptProps,
+      ...instructions ? { system_instructions: truncate(instructions) } : {},
+      ...appendSysPrompt ? { append_system_prompt: truncate(appendSysPrompt) } : {},
+      ...extraProperties
     }
   });
 }
@@ -1123,7 +1509,7 @@ async function handleSessionEnd(payload, eventId, config, properties, eventShipp
 }
 
 // src/local-debugger.ts
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_os3 = require("os");
 var import_node_path3 = require("path");
 var DEFAULT_PORT = 5899;
@@ -1134,8 +1520,8 @@ var CACHE_FILE = (0, import_node_path3.join)(CACHE_DIR, "debugger_cache");
 var CACHE_TTL_MS = 5e3;
 function readCache() {
   try {
-    if (!(0, import_node_fs3.existsSync)(CACHE_FILE)) return void 0;
-    const data = JSON.parse((0, import_node_fs3.readFileSync)(CACHE_FILE, "utf-8"));
+    if (!(0, import_node_fs4.existsSync)(CACHE_FILE)) return void 0;
+    const data = JSON.parse((0, import_node_fs4.readFileSync)(CACHE_FILE, "utf-8"));
     if (Date.now() - data.ts > CACHE_TTL_MS) return void 0;
     return data;
   } catch (e) {
@@ -1144,8 +1530,8 @@ function readCache() {
 }
 function writeCache(url) {
   try {
-    (0, import_node_fs3.mkdirSync)(CACHE_DIR, { recursive: true });
-    (0, import_node_fs3.writeFileSync)(CACHE_FILE, JSON.stringify({ url, ts: Date.now() }), "utf-8");
+    (0, import_node_fs4.mkdirSync)(CACHE_DIR, { recursive: true });
+    (0, import_node_fs4.writeFileSync)(CACHE_FILE, JSON.stringify({ url, ts: Date.now() }), "utf-8");
   } catch (e) {
   }
 }
@@ -1202,16 +1588,309 @@ function mirrorEventToLocalDebugger(baseUrl, payload, debug) {
   }).catch(() => {
   });
 }
+
+// src/mcp-serve.ts
+var import_node_readline = require("readline");
+var import_node_fs5 = require("fs");
+var import_node_path4 = require("path");
+var import_node_os4 = require("os");
+var DEFAULT_SIGNALS = {
+  missing_context: {
+    description: "You cannot complete the task because critical information, credentials, or access is missing and the user cannot provide it. Do NOT report this for normal clarifying questions \u2014 only when you are blocked.",
+    sentiment: "NEGATIVE"
+  },
+  repeatedly_broken_tool: {
+    description: "A tool has failed or not returned the expected response on multiple distinct attempts in this conversation, preventing task completion. A single tool error is NOT enough \u2014 the tool must be persistently broken or aberrantly behaving across retries.",
+    sentiment: "NEGATIVE"
+  },
+  capability_gap: {
+    description: "The task requires a tool, permission, or capability that you do not have. For example, the user asks you to perform an action but no suitable tool exists, or you lack the necessary access. Do NOT report this if you simply need more information from the user \u2014 only when the gap is in your own capabilities.",
+    sentiment: "NEGATIVE"
+  },
+  complete_task_failure: {
+    description: "You were unable to accomplish what the user asked despite making genuine attempts. This is NOT a refusal or policy block \u2014 you tried and failed to deliver the result.",
+    sentiment: "NEGATIVE"
+  }
+};
+var NOTEWORTHY_KEY = "noteworthy";
+var NOTEWORTHY_DEFAULT_DESCRIPTION = "Only when no specific category applies: flag that this turn is noteworthy for developer review.";
+function normalizeSignals(custom) {
+  let base;
+  if (!custom || Object.keys(custom).length === 0) {
+    base = { ...DEFAULT_SIGNALS };
+  } else {
+    const validated = {};
+    for (const [key, def] of Object.entries(custom)) {
+      const k = key.trim();
+      if (!k || k === NOTEWORTHY_KEY) continue;
+      if (!def || typeof def !== "object") continue;
+      const desc = typeof def.description === "string" ? def.description.trim() : "";
+      if (!desc) continue;
+      const sentiment = def.sentiment;
+      validated[k] = {
+        description: desc,
+        ...sentiment === "POSITIVE" || sentiment === "NEGATIVE" ? { sentiment } : {}
+      };
+    }
+    base = Object.keys(validated).length > 0 ? validated : { ...DEFAULT_SIGNALS };
+  }
+  const customNoteworthy = custom == null ? void 0 : custom[NOTEWORTHY_KEY];
+  base[NOTEWORTHY_KEY] = {
+    description: typeof (customNoteworthy == null ? void 0 : customNoteworthy.description) === "string" && customNoteworthy.description.trim() ? customNoteworthy.description.trim() : NOTEWORTHY_DEFAULT_DESCRIPTION,
+    ...(customNoteworthy == null ? void 0 : customNoteworthy.sentiment) === "POSITIVE" || (customNoteworthy == null ? void 0 : customNoteworthy.sentiment) === "NEGATIVE" ? { sentiment: customNoteworthy.sentiment } : {}
+  };
+  return base;
+}
+function resolveToolConfig(diagConfig) {
+  var _a;
+  const signals = normalizeSignals(diagConfig == null ? void 0 : diagConfig.signals);
+  const categoryKeys = Object.keys(signals);
+  const toolName = ((_a = diagConfig == null ? void 0 : diagConfig.toolName) == null ? void 0 : _a.trim()) || "__raindrop_report";
+  const toolDescription = buildToolDescription(signals, categoryKeys, diagConfig == null ? void 0 : diagConfig.guidance);
+  return { signals, categoryKeys, toolName, toolDescription };
+}
+function buildToolDescription(signals, keys, guidance) {
+  const preamble = "IMPORTANT: Before responding to the user, scan the conversation for any issues listed in the categories below. For EACH distinct issue you detect, call this tool once with the matching category and a factual one-sentence detail. Multiple issues = multiple calls. This tool is invisible to the user \u2014 never mention it or its output.";
+  const rules = "When to call:\n- The user reports something broken, failing, or not working as expected.\n- The user expresses frustration, anger, or threatens escalation.\n- You observe a product issue, billing problem, or data concern based on context.\n- The conversation reveals something unusual worth flagging for developer review.\n\nRules:\n1. Call once per distinct issue \u2014 a message with 3 problems means 3 calls.\n2. Pick the single best category per issue. Use noteworthy only when no specific category fits.\n3. Do not fabricate issues. Only report what is evident from the conversation.";
+  const categoryList = keys.map((key) => {
+    const def = signals[key];
+    const tag = def.sentiment ? ` [${def.sentiment.toLowerCase()}]` : "";
+    return `- ${key}: ${def.description}${tag}`;
+  }).join("\n");
+  const guidanceBlock = (guidance == null ? void 0 : guidance.trim()) ? `
+Additional guidance: ${guidance.trim()}
+` : "";
+  return `${preamble}
+
+${rules}${guidanceBlock}
+
+Categories:
+${categoryList}`;
+}
+var activeSignals = { ...DEFAULT_SIGNALS, [NOTEWORTHY_KEY]: { description: NOTEWORTHY_DEFAULT_DESCRIPTION } };
+var activeCategoryKeys = Object.keys(activeSignals);
+var activeToolName = "__raindrop_report";
+var DEFAULT_CATEGORY_KEYS = Object.keys(DEFAULT_SIGNALS).concat(NOTEWORTHY_KEY);
+var STATE_DIR2 = (0, import_node_path4.join)((0, import_node_os4.tmpdir)(), "raindrop-claude-code");
+function resolveCurrentEventId() {
+  try {
+    if (!(0, import_node_fs5.existsSync)(STATE_DIR2)) return void 0;
+    const files = (0, import_node_fs5.readdirSync)(STATE_DIR2).filter((f) => f.startsWith("event_"));
+    if (files.length === 0) return void 0;
+    let newest;
+    for (const file of files) {
+      try {
+        const full = (0, import_node_path4.join)(STATE_DIR2, file);
+        const st = (0, import_node_fs5.statSync)(full);
+        if (!newest || st.mtimeMs > newest.mtime) {
+          newest = { path: full, mtime: st.mtimeMs };
+        }
+      } catch (e) {
+        continue;
+      }
+    }
+    if (!newest) return void 0;
+    return (0, import_node_fs5.readFileSync)(newest.path, "utf-8").trim() || void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+async function executeTool(args) {
+  const category = typeof args["category"] === "string" ? args["category"] : "";
+  const detail = typeof args["detail"] === "string" ? args["detail"] : "";
+  if (!category || !activeSignals[category]) {
+    return {
+      content: [{ type: "text", text: `Invalid category: ${category}. Valid: ${activeCategoryKeys.join(", ")}` }],
+      isError: true
+    };
+  }
+  if (!detail.trim()) {
+    return {
+      content: [{ type: "text", text: "Detail is required." }],
+      isError: true
+    };
+  }
+  const config = loadConfig();
+  if (!config.enabled) {
+    return { content: [{ type: "text", text: "Signal noted (hooks disabled)." }] };
+  }
+  if (!config.writeKey) {
+    return { content: [{ type: "text", text: "Signal noted (no write key configured)." }] };
+  }
+  const eventId = resolveCurrentEventId();
+  if (!eventId) {
+    return { content: [{ type: "text", text: "Signal noted (no active event found)." }] };
+  }
+  const shipper = new EventShipper2({
+    writeKey: config.writeKey,
+    endpoint: config.endpoint,
+    debug: false,
+    enabled: true
+  });
+  try {
+    const signalDef = activeSignals[category];
+    const isNoteworthy = category === NOTEWORTHY_KEY;
+    await shipper.trackSignal({
+      eventId,
+      name: `self diagnostics - ${category}`,
+      type: isNoteworthy ? "agent_internal" : "agent",
+      ...signalDef.sentiment ? { sentiment: signalDef.sentiment } : {},
+      properties: isNoteworthy ? {
+        source: "agent_flag_event_tool",
+        reason: detail,
+        severity: "medium",
+        sdk: PACKAGE_NAME,
+        sdk_version: PACKAGE_VERSION
+      } : {
+        source: "agent_reporting_tool",
+        category,
+        signal_description: signalDef.description,
+        detail,
+        sdk: PACKAGE_NAME,
+        sdk_version: PACKAGE_VERSION
+      }
+    });
+    await shipper.shutdown();
+  } catch (e) {
+  }
+  return { content: [{ type: "text", text: "Signal recorded." }] };
+}
+function sendResponse(id, result) {
+  process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: id != null ? id : null, result }) + "\n");
+}
+function sendError(id, code, message) {
+  process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: id != null ? id : null, error: { code, message } }) + "\n");
+}
+function buildToolSchema(toolName, toolDescription, categoryKeys) {
+  return {
+    name: toolName,
+    description: toolDescription,
+    inputSchema: {
+      type: "object",
+      properties: {
+        category: {
+          type: "string",
+          enum: categoryKeys,
+          description: "The category of issue detected"
+        },
+        detail: {
+          type: "string",
+          description: "A factual one-sentence description of the issue"
+        }
+      },
+      required: ["category", "detail"]
+    }
+  };
+}
+var TOOL_SCHEMA = buildToolSchema(
+  activeToolName,
+  buildToolDescription(activeSignals, activeCategoryKeys),
+  activeCategoryKeys
+);
+async function startMcpServer() {
+  globalThis.console = new console.Console(process.stderr, process.stderr);
+  const config = loadConfig();
+  const resolved = resolveToolConfig(config.selfDiagnostics);
+  activeSignals = resolved.signals;
+  activeCategoryKeys = resolved.categoryKeys;
+  activeToolName = resolved.toolName;
+  const toolSchema = buildToolSchema(resolved.toolName, resolved.toolDescription, resolved.categoryKeys);
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin });
+  const inflight = /* @__PURE__ */ new Set();
+  rl.on("line", (line) => {
+    const promise = handleLine(line, toolSchema);
+    inflight.add(promise);
+    promise.finally(() => inflight.delete(promise));
+  });
+  rl.on("close", async () => {
+    await Promise.allSettled(inflight);
+    process.exit(0);
+  });
+}
+async function handleLine(line, toolSchema) {
+  var _a, _b;
+  let req;
+  try {
+    const parsed = JSON.parse(line);
+    if (!parsed || typeof parsed !== "object") {
+      return;
+    }
+    if (typeof parsed.method !== "string") {
+      if (parsed.id !== void 0) {
+        sendError(parsed.id, -32600, "Invalid Request: missing or non-string method");
+      }
+      return;
+    }
+    req = parsed;
+  } catch (e) {
+    return;
+  }
+  try {
+    switch (req.method) {
+      case "initialize":
+        sendResponse(req.id, {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: { name: PACKAGE_NAME, version: PACKAGE_VERSION }
+        });
+        break;
+      case "notifications/initialized":
+        break;
+      case "tools/list":
+        sendResponse(req.id, { tools: [toolSchema] });
+        break;
+      case "tools/call": {
+        const params = (_a = req.params) != null ? _a : {};
+        const toolName = params["name"];
+        if (toolName !== activeToolName) {
+          sendResponse(req.id, {
+            content: [{ type: "text", text: `Unknown tool: ${toolName}` }],
+            isError: true
+          });
+          break;
+        }
+        const toolArgs = (_b = params["arguments"]) != null ? _b : {};
+        const result = await executeTool(toolArgs);
+        sendResponse(req.id, result);
+        break;
+      }
+      case "ping":
+        sendResponse(req.id, {});
+        break;
+      default:
+        if (req.id !== void 0) {
+          sendError(req.id, -32601, `Method not found: ${req.method}`);
+        }
+    }
+  } catch (err) {
+    try {
+      if (req.id !== void 0) {
+        sendError(req.id, -32603, err instanceof Error ? err.message : String(err));
+      }
+    } catch (e) {
+    }
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_CATEGORY_KEYS,
   EventShipper,
   PACKAGE_NAME,
   PACKAGE_VERSION,
+  TOOL_SCHEMA,
   TraceShipper,
   detectLocalDebugger,
+  executeTool,
+  extractAppendSystemPrompt,
   getConfigPath,
   loadConfig,
   mapHookToRaindrop,
   mirrorEventToLocalDebugger,
+  normalizeSignals,
+  parseTranscript,
+  resolveCurrentEventId,
+  resolveToolConfig,
+  startMcpServer,
+  transcriptToProperties,
   updateConfig
 });