@raindrop-ai/claude-code 0.0.4 → 0.0.6

package/dist/cli.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
 // src/event-mapper.ts
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, readdirSync, unlinkSync, writeFileSync } from "fs";
+import { execSync } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { tmpdir } from "os";
 import { join } from "path";
@@ -653,7 +654,7 @@ globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = 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 {
@@ -690,6 +691,138 @@ var TraceShipper2 = class extends TraceShipper {
   }
 };
 
+// src/transcript.ts
+import { existsSync, readFileSync } from "fs";
+function parseTranscript(transcriptPath) {
+  var _a, _b, _c, _d, _e;
+  try {
+    if (!existsSync(transcriptPath)) return void 0;
+    const content = 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) {
@@ -734,8 +867,8 @@ function writeState(key, value) {
 function readState(key) {
   try {
     const filePath = statePath(key);
-    if (!existsSync(filePath)) return void 0;
-    return readFileSync(filePath, "utf-8");
+    if (!existsSync2(filePath)) return void 0;
+    return readFileSync2(filePath, "utf-8");
   } catch (e) {
     return void 0;
   }
@@ -800,12 +933,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);
@@ -820,10 +956,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);
@@ -834,6 +973,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;
@@ -842,6 +984,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) {
@@ -999,25 +1143,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 (existsSync2(payload.file_path)) {
+      const content = readFileSync2(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 (!existsSync2(STATE_DIR)) return void 0;
+    const prefix = safeKey(`instr_${sessionId}_`);
+    const files = 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(readFileSync2(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 (!existsSync2(STATE_DIR)) return;
+    const prefix = safeKey(`instr_${sessionId}_`);
+    for (const file of readdirSync(STATE_DIR).filter((f) => f.startsWith(prefix))) {
+      try {
+        unlinkSync(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}`;
+}
+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 args2 = getProcessArgs(pid);
+      if (args2 && args2.length > 0) {
+        const content = extractAppendSystemPrompt(args2);
+        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 = readFileSync2(`/proc/${pid}/cmdline`, "utf-8");
+      const args2 = raw.split("\0").filter(Boolean);
+      return args2.length > 0 ? args2 : void 0;
+    } catch (e) {
+    }
+  }
+  try {
+    const output = 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 = 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(args2) {
+  const parts = [];
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    try {
+      if (arg === APPEND_FILE_FLAG && i + 1 < args2.length) {
+        const filePath = args2[i + 1];
+        i++;
+        try {
+          if (existsSync2(filePath)) {
+            parts.push(readFileSync2(filePath, "utf-8"));
+          }
+        } catch (e) {
+        }
+        continue;
+      }
+      if (arg.startsWith(APPEND_FILE_FLAG + "=")) {
+        const filePath = arg.slice(APPEND_FILE_FLAG.length + 1);
+        try {
+          if (filePath && existsSync2(filePath)) {
+            parts.push(readFileSync2(filePath, "utf-8"));
+          }
+        } catch (e) {
+        }
+        continue;
+      }
+      if (arg === APPEND_FLAG && i + 1 < args2.length) {
+        const valueParts = [];
+        for (let j = i + 1; j < args2.length; j++) {
+          if (args2[j].startsWith("--")) break;
+          valueParts.push(args2[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 handleStopFailure(payload, eventId, config, properties, eventShipper) {
+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
     }
   });
 }
@@ -1034,7 +1396,7 @@ async function handleSessionEnd(payload, eventId, config, properties, eventShipp
 }
 
 // src/config.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { homedir, userInfo } from "os";
 import { dirname, join as join2 } from "path";
 var CONFIG_PATH = join2(homedir(), ".config", "raindrop", "config.json");
@@ -1042,8 +1404,8 @@ function loadConfig() {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
   let file = {};
   try {
-    if (existsSync2(CONFIG_PATH)) {
-      file = JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
+    if (existsSync3(CONFIG_PATH)) {
+      file = JSON.parse(readFileSync3(CONFIG_PATH, "utf-8"));
     }
   } catch (e) {
   }
@@ -1065,6 +1427,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",
@@ -1072,7 +1445,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() {
@@ -1083,8 +1457,8 @@ function updateConfig(patch) {
   mkdirSync2(dir, { recursive: true });
   let existing = {};
   try {
-    if (existsSync2(CONFIG_PATH)) {
-      existing = JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
+    if (existsSync3(CONFIG_PATH)) {
+      existing = JSON.parse(readFileSync3(CONFIG_PATH, "utf-8"));
     }
   } catch (e) {
   }
@@ -1092,7 +1466,7 @@ function updateConfig(patch) {
 }
 
 // src/local-debugger.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join3 } from "path";
 var DEFAULT_PORT = 5899;
@@ -1103,8 +1477,8 @@ var CACHE_FILE = join3(CACHE_DIR, "debugger_cache");
 var CACHE_TTL_MS = 5e3;
 function readCache() {
   try {
-    if (!existsSync3(CACHE_FILE)) return void 0;
-    const data = JSON.parse(readFileSync3(CACHE_FILE, "utf-8"));
+    if (!existsSync4(CACHE_FILE)) return void 0;
+    const data = JSON.parse(readFileSync4(CACHE_FILE, "utf-8"));
     if (Date.now() - data.ts > CACHE_TTL_MS) return void 0;
     return data;
   } catch (e) {
@@ -1173,7 +1547,7 @@ function mirrorEventToLocalDebugger(baseUrl, payload, debug) {
 }
 
 // src/hook-handler.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import { join as join4 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 var STDIN_TIMEOUT_MS = 5e3;
@@ -1182,8 +1556,8 @@ function getOtlpTraceId(sessionId) {
   try {
     const key = `rootspan_${sessionId}`.replace(/[^a-zA-Z0-9_\-]/g, "_");
     const filePath = join4(STATE_DIR2, key);
-    if (!existsSync4(filePath)) return void 0;
-    const ctx = JSON.parse(readFileSync4(filePath, "utf-8"));
+    if (!existsSync5(filePath)) return void 0;
+    const ctx = JSON.parse(readFileSync5(filePath, "utf-8"));
     if (!ctx.traceIdB64) return void 0;
     return Buffer.from(ctx.traceIdB64, "base64").toString("hex");
   } catch (e) {
@@ -1302,11 +1676,11 @@ async function handleHook() {
 }
 
 // src/setup.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2, userInfo as userInfo2 } from "os";
 import { dirname as dirname2, join as join5, resolve } from "path";
 import { createInterface } from "readline";
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 function getClaudeSettingsPath(scope, cwd) {
   if (scope === "project") {
     return resolve(cwd, ".claude", "settings.json");
@@ -1325,8 +1699,9 @@ var CORE_HOOK_EVENTS = [
   "SessionEnd"
 ];
 var VERSIONED_HOOK_EVENTS = [
-  { minVersion: "2.1.78", events: ["StopFailure"] },
   { minVersion: "2.1.76", events: ["PostCompact"] },
+  { minVersion: "2.1.78", events: ["StopFailure"] },
+  { minVersion: "2.1.78", events: ["InstructionsLoaded"] },
   { minVersion: "2.1.89", events: ["PermissionDenied"] }
 ];
 function parseVersion(version) {
@@ -1345,7 +1720,7 @@ function isVersionAtLeast(current, required) {
 }
 function detectClaudeCodeVersion() {
   try {
-    const output = execSync("claude --version", {
+    const output = execSync2("claude --version", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -1424,8 +1799,8 @@ async function runSetup(args2) {
     mkdirSync4(configDir, { recursive: true });
     let existingConfig = {};
     try {
-      if (existsSync5(configPath)) {
-        existingConfig = JSON.parse(readFileSync5(configPath, "utf-8"));
+      if (existsSync6(configPath)) {
+        existingConfig = JSON.parse(readFileSync6(configPath, "utf-8"));
       }
     } catch (e) {
     }
@@ -1449,9 +1824,9 @@ async function runSetup(args2) {
   const settingsDir = dirname2(settingsPath);
   mkdirSync4(settingsDir, { recursive: true });
   let settings = {};
-  if (existsSync5(settingsPath)) {
+  if (existsSync6(settingsPath)) {
     try {
-      settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
+      settings = JSON.parse(readFileSync6(settingsPath, "utf-8"));
     } catch (e) {
       console.warn(`  Warning: could not parse ${settingsPath}, creating fresh`);
       settings = {};
@@ -1479,9 +1854,20 @@ async function runSetup(args2) {
   settings["hooks"] = existingHooks;
   writeFileSync4(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   console.log(`  Updated Claude Code hooks in ${settingsPath} (${scopeLabel})`);
+  try {
+    const mcpList = execSync2("claude mcp list", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    if (!mcpList.includes("raindrop-diagnostics")) {
+      execSync2(
+        `claude mcp add --transport stdio --scope ${scope === "project" ? "project" : "user"} raindrop-diagnostics -- raindrop-claude-code mcp-serve`,
+        { stdio: "ignore" }
+      );
+      console.log(`  Registered self-diagnostics MCP server`);
+    }
+  } catch (e) {
+  }
   const whichCmd = process.platform === "win32" ? "where" : "which";
   try {
-    execSync(`${whichCmd} raindrop-claude-code`, { stdio: "ignore" });
+    execSync2(`${whichCmd} raindrop-claude-code`, { stdio: "ignore" });
   } catch (e) {
     console.log(`
   Warning: 'raindrop-claude-code' is not in your PATH.
@@ -1508,6 +1894,289 @@ async function runSetup(args2) {
   }
 }
 
+// src/mcp-serve.ts
+import { createInterface as createInterface2 } from "readline";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync } from "fs";
+import { join as join6 } from "path";
+import { tmpdir as tmpdir4 } from "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_DIR3 = join6(tmpdir4(), "raindrop-claude-code");
+function resolveCurrentEventId() {
+  try {
+    if (!existsSync7(STATE_DIR3)) return void 0;
+    const files = readdirSync2(STATE_DIR3).filter((f) => f.startsWith("event_"));
+    if (files.length === 0) return void 0;
+    let newest;
+    for (const file of files) {
+      try {
+        const full = join6(STATE_DIR3, file);
+        const st = statSync(full);
+        if (!newest || st.mtimeMs > newest.mtime) {
+          newest = { path: full, mtime: st.mtimeMs };
+        }
+      } catch (e) {
+        continue;
+      }
+    }
+    if (!newest) return void 0;
+    return readFileSync7(newest.path, "utf-8").trim() || void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+async function executeTool(args2) {
+  const category = typeof args2["category"] === "string" ? args2["category"] : "";
+  const detail = typeof args2["detail"] === "string" ? args2["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 = createInterface2({ 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) {
+    }
+  }
+}
+
 // src/cli.ts
 var args = process.argv.slice(2);
 var command = args[0];
@@ -1533,6 +2202,10 @@ async function main() {
       await handleHook();
       break;
     }
+    case "mcp-serve": {
+      await startMcpServer();
+      break;
+    }
     case "status": {
       const config = loadConfig();
       const result = await detectLocalDebugger(config.debug);
@@ -1582,6 +2255,7 @@ async function main() {
       --local-only      Install hooks without a write key (local debugger only)
 
     hook                Handle a Claude Code hook event (reads JSON from stdin)
+    mcp-serve           Start the self-diagnostics MCP server (stdio)
     status              Check local debugger connectivity
     enable              Enable Raindrop hooks
     disable             Disable Raindrop hooks
@@ -1609,5 +2283,5 @@ async function main() {
 }
 main().catch((err) => {
   console.error(`[raindrop-ai/claude-code] fatal: ${err instanceof Error ? err.message : String(err)}`);
-  process.exit(command === "hook" ? 0 : 1);
+  process.exit(command === "hook" || command === "mcp-serve" ? 0 : 1);
 });