claude-hook-notify 1.4.2 → 1.5.0

package/README.md

@@ -14,13 +14,20 @@ npx claude-hook-notify setup
 
 ## 效果
 
-当 Claude Code 完成任务时，你会收到系统原生桌面通知：
+当 Claude Code 完成任务时，你会收到系统原生桌面通知，并显示**本次任务的 token 消耗**：
 
 ```
-┌──────────────────────────────────────┐
-│  🔔 Claude Code 完成 (my-project)   │
-│  已完成代码重构和测试                  │
-└──────────────────────────────────────┘
+┌─────────────────────────────────────────────────────┐
+│  Claude Code · 本次任务消耗 1.2k tokens            │  ← 顶部栏（Windows）
+│  🔔 Claude Code 完成 (my-project)                  │
+│  已完成代码重构和测试                                │
+└─────────────────────────────────────────────────────┘
+```
+
+含子代理调用的任务会额外显示子代理次数：
+
+```
+Claude Code · 本次任务消耗 42k tokens · 子代理 7
 ```
 
 API 错误中断时：
@@ -89,12 +96,52 @@ npx claude-hook-notify setup --events Stop,TaskCompleted,Notification,PostToolUs
 | macOS   | `osascript`          | 无（系统自带）                                |
 | macOS   | `terminal-notifier`  | 可选: `brew install terminal-notifier`（更好） |
 | Linux   | `notify-send`        | `sudo apt-get install libnotify-bin`          |
-| Windows | 桌面通知 (内置工具)     | 无（Windows 10+ 系统自带，点击通知跳转终端） |
+| Windows | Toast 通知 (PowerShell) | 无（Windows 10+ 系统自带）                 |
 
 ## 原理
 
 安装时会在 `~/.claude/settings.json` 中添加 hooks 配置。当对应事件触发时，Claude Code 会自动执行 `npx claude-hook-notify notify --event <事件名>`，脚本会读取 hook 传入的上下文信息（任务名称、最后的 assistant 消息等），然后通过系统原生 API 发送桌面通知。
 
+## Token 消耗统计
+
+在 `Stop` / `SubagentStop` / `StopFailure` 事件触发时，通知会显示**本次任务新增到对话上下文的 token 量**（而不是整个 session 的累计，也不是 API 账单总额）。
+
+### 计算口径：context-delta
+
+```
+本次任务消耗 = (回合结束时上下文大小) − (回合开始前上下文大小) + sum(本回合 output_tokens)
+```
+
+- **"上下文大小"** = 单次 API 调用的 `input_tokens + cache_creation_input_tokens + cache_read_input_tokens`
+- **"回合"** = 从最后一条真实用户消息到 Stop 事件之间
+- **子代理**：通过主 transcript 的 `progress` 条目镜像统计，按 `message.id` 去重（progress 会重复触发同一 id 5~8 次）
+
+### 为什么不直接累加 `cache_creation_input_tokens`
+
+缓存失效（默认 5 分钟 TTL）时 Claude 会把整段对话历史重新写入缓存槽位，导致单次调用的 `cache_creation_input_tokens` 飙升到历史总量规模。直接累加会把这些"本来就在对话里"的 tokens 误算作新增消耗，出现数倍虚高（开发过程中曾经见过 146k 的虚高值）。
+
+用 context-delta 算法规避了这个陷阱：`input + cache_creation + cache_read` 的总和表示"当前 prompt 的总上下文大小"，这个值随对话进展单调递增，不受缓存重建影响。
+
+### 准确率：~92–96%
+
+| 场景 | 准确率 | 说明 |
+|------|--------|------|
+| 纯主代理的普通回合（读文件、编辑、Bash 等） | **~96%** | 主要误差为缓存边界的 ±100 tokens 级测量波动 |
+| 含子代理的回合 | **~85–92%** | 子代理最终结果文本会被同时计入子代理 output 与主 context delta，造成轻微双重计数 |
+| 新 session 第一次交互 | **~70%** | `prevContext=0`，system prompt（约 5k）会被算作本次新增 |
+| 触发了 `/compact` 或 auto-compact 的长回合 | 不确定 | 上下文被压缩，`currentContext < prevContext` 时归零，可能严重低估 |
+| 包含 API 重试的回合 | **~96%** | 按 `message.id` 去重已足够 |
+
+### 对比其他口径
+
+| 问题 | 我们的算法 | ccusage session 口径 | Claude Code 原生 `/context` |
+|------|-----------|---------------------|---------------------------|
+| "这次任务新增了多少对话内容？" | ✅ | ❌ 是累计总和 | ❌ 是当前快照 |
+| "整个 session 总 API 账单？" | ❌ 量级对但精度低 | ✅ | ❌ |
+| "当前上下文窗口占用？" | ❌ | 部分支持 | ✅ |
+
+如果你想要账单精度的成本统计，推荐使用 [ccusage](https://github.com/ryoppippi/ccusage)，它集成了 LiteLLM 价格表并正确按 API 账单口径累加。本工具的 token 显示定位是**让你感知单次任务的数量级**，不是账单。
+
 ## 编程接口
 
 也可以作为库使用：
@@ -114,6 +161,8 @@ await sendNotification({
 - **Ctrl+C 用户中断**: 用户手动按 Ctrl+C 取消时不会触发任何 hook 事件，因此无法发送通知。
 - **网络完全断开**: 如果网络完全断开导致 Claude Code 进程本身退出，hook 可能无法执行。
 - **StopFailure 事件**: `StopFailure` 不是 Claude Code 官方支持的 hook 事件名，默认不再注册。如通过 `--events` 手动指定，会导致 settings.json 校验报错，整个配置文件被跳过。
+- **Token 消耗精度**: 桌面通知显示的"本次任务消耗"是 context-delta 估算值，准确率 ~92-96%（详见上文 [Token 消耗统计](#token-消耗统计) 章节）。不适合作为账单依据。
+- **Windows 动态 appID**: Windows 上 token 信息通过动态 `-appID` 显示在 Toast 顶部栏，每次数值变化会在系统"通知与操作"设置里登记一条新记录，属 SnoreToast 的已知副作用。
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-hook-notify",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "🔔 Claude Code 任务完成桌面通知 — 一键安装，跨平台支持",
   "main": "src/index.js",
   "bin": {
@@ -18,8 +18,16 @@
     "notify-send",
     "cli"
   ],
-  "author": "",
+  "author": "Mr-zj388",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Mr-zj388/claude-code-notify.git"
+  },
+  "homepage": "https://github.com/Mr-zj388/claude-code-notify#readme",
+  "bugs": {
+    "url": "https://github.com/Mr-zj388/claude-code-notify/issues"
+  },
   "engines": {
     "node": ">=16.0.0"
   },

package/src/activate-watcher.js

@@ -22,7 +22,7 @@
  *   }
  */
 
-const { spawn } = require("child_process");
+const { spawn, execFileSync } = require("child_process");
 
 // 120 秒超时自动退出，防僵尸进程
 const config = parseConfig();

package/src/cli.js

@@ -24,7 +24,6 @@ const HELP = `
     --title <标题>           自定义通知标题
     --message <消息>         自定义通知消息
     --sound <音效>           macOS 音效名称 (默认: Glass)
-    --no-activate            禁用点击通知后激活终端窗口
     --dry-run                仅打印通知内容，不实际发送
 
   示例:
@@ -40,7 +39,6 @@ function parseArgs(args) {
       const key = args[i].slice(2);
       if (
         key === "dry-run" ||
-        key === "no-activate" ||
         key === "global" ||
         key === "local" ||
         key === "help"
@@ -103,7 +101,6 @@ async function main() {
       title: args.title,
       message: args.message,
       sound: args.sound,
-      activate: !args["no-activate"],
       dryRun: !!args["dry-run"],
       hookInput: input,
     });

package/src/index.js

@@ -1,5 +1,4 @@
 const { sendNotification, EVENT_CONFIG } = require("./notify");
 const { setup, uninstall } = require("./setup");
-const { detectTerminal } = require("./activate");
 
-module.exports = { sendNotification, EVENT_CONFIG, setup, uninstall, detectTerminal };
+module.exports = { sendNotification, EVENT_CONFIG, setup, uninstall };

package/src/notify.js

@@ -1,8 +1,14 @@
-const { execSync, spawn } = require("child_process");
+const { execSync, execFileSync } = require("child_process");
 const os = require("os");
 const fs = require("fs");
 const path = require("path");
-const { detectTerminal, getActivateCommand } = require("./activate");
+
+const TOKEN_EVENTS = new Set(["Stop", "SubagentStop", "StopFailure"]);
+
+const contextSize = (u) =>
+  (u.input_tokens || 0) +
+  (u.cache_creation_input_tokens || 0) +
+  (u.cache_read_input_tokens || 0);
 
 const EVENT_CONFIG = {
   Stop: {
@@ -47,6 +53,117 @@ const ERROR_TYPE_LABELS = {
   unknown: "未知错误",
 };
 
+/**
+ * 提取本轮任务的 token 消耗
+ *
+ * 采用 context-delta 口径：
+ *   newInput = 回合结束时上下文大小 - 回合开始前上下文大小
+ *   output   = 回合内所有 assistant 消息的 output_tokens 累加
+ *   total    = newInput + output
+ *
+ * "上下文大小" 指单次 API 调用的 input + cache_creation + cache_read。
+ * 不直接累加 cache_creation，否则缓存失效重建时会把整段历史误算作新增。
+ *
+ * 子代理通过 progress 条目转发，按 message.id 去重（progress 会重复触发同一 id 5~8 次）。
+ */
+function extractTokenUsage(lines) {
+  // 单次反向扫描：先找最后一条真实 user 消息，再继续往前找它之前最近的主代理 assistant
+  let startIdx = 0;
+  let prevContext = 0;
+  let foundUser = false;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let entry;
+    try {
+      entry = JSON.parse(lines[i]);
+    } catch {
+      continue;
+    }
+    if (!entry) continue;
+
+    if (!foundUser) {
+      if (
+        entry.type === "user" &&
+        !entry.data &&
+        !entry.isSidechain
+      ) {
+        const content = entry.message?.content;
+        const isRealUser =
+          typeof content === "string" ||
+          (Array.isArray(content) &&
+            content.some((b) => b?.type !== "tool_result"));
+        if (isRealUser) {
+          startIdx = i + 1;
+          foundUser = true;
+        }
+      }
+      continue;
+    }
+
+    if (entry.type === "assistant" && entry.message?.usage) {
+      prevContext = contextSize(entry.message.usage);
+      break;
+    }
+  }
+
+  // 前向扫描：累加回合内 output、计数子代理、记录最后一条主代理 usage
+  const seen = new Set();
+  let lastMainUsage = null;
+  let output = 0;
+  let subCount = 0;
+
+  for (let i = startIdx; i < lines.length; i++) {
+    let entry;
+    try {
+      entry = JSON.parse(lines[i]);
+    } catch {
+      continue;
+    }
+    if (!entry) continue;
+
+    let msgId = null;
+    let usage = null;
+    let isSub = false;
+
+    if (entry.type === "assistant" && entry.message?.usage) {
+      msgId = entry.message.id;
+      usage = entry.message.usage;
+    } else if (entry.type === "progress") {
+      const inner = entry.data?.message;
+      if (inner?.type === "assistant" && inner.message?.usage) {
+        msgId = inner.message.id;
+        usage = inner.message.usage;
+        isSub = true;
+      }
+    }
+
+    if (!usage || !msgId || seen.has(msgId)) continue;
+    seen.add(msgId);
+
+    output += usage.output_tokens || 0;
+    if (isSub) subCount++;
+    else lastMainUsage = usage;
+  }
+
+  if (seen.size === 0) return null;
+
+  const currentContext = lastMainUsage ? contextSize(lastMainUsage) : prevContext;
+  const newInput = Math.max(0, currentContext - prevContext);
+  return {
+    output,
+    total: newInput + output,
+    subCount,
+  };
+}
+
+/**
+ * 将 token 数字格式化为紧凑字符串（>=1000 显示为 k）
+ */
+function formatTokens(n) {
+  if (n < 1000) return String(n);
+  if (n < 10000) return (n / 1000).toFixed(1) + "k";
+  return Math.round(n / 1000) + "k";
+}
+
 /**
  * 从 hook 输入中提取有用信息
  */
@@ -81,36 +198,42 @@ function extractContext(hookInput) {
     ctx.stopReason = hookInput.stop_reason;
   }
 
-  // 尝试从 transcript 提取最后的 assistant 消息
-  if (hookInput.transcript_path && fs.existsSync(hookInput.transcript_path)) {
+  // 读取 transcript 一次，供 lastMessage + tokenUsage 共享
+  let lines = null;
+  if (hookInput.transcript_path) {
     try {
-      const lines = fs
+      lines = fs
         .readFileSync(hookInput.transcript_path, "utf-8")
         .split("\n")
-        .filter(Boolean)
-        .slice(-20);
-
-      for (let i = lines.length - 1; i >= 0; i--) {
-        try {
-          const entry = JSON.parse(lines[i]);
-          if (
-            entry?.message?.role === "assistant" &&
-            entry?.message?.content?.[0]?.text
-          ) {
-            ctx.lastMessage = entry.message.content[0].text
-              .replace(/\n/g, " ")
-              .slice(0, 100);
-            break;
-          }
-        } catch {
-          continue;
-        }
-      }
+        .filter(Boolean);
     } catch {
       // 读取失败，忽略
     }
   }
 
+  if (lines) {
+    // 末尾若干行内找最后一条 assistant 文本消息
+    const tailStart = Math.max(0, lines.length - 20);
+    for (let i = lines.length - 1; i >= tailStart; i--) {
+      try {
+        const entry = JSON.parse(lines[i]);
+        if (
+          entry?.message?.role === "assistant" &&
+          entry?.message?.content?.[0]?.text
+        ) {
+          ctx.lastMessage = entry.message.content[0].text
+            .replace(/\n/g, " ")
+            .slice(0, 100);
+          break;
+        }
+      } catch {
+        continue;
+      }
+    }
+
+    ctx.tokenUsage = extractTokenUsage(lines);
+  }
+
   return ctx;
 }
 
@@ -121,16 +244,16 @@ function buildNotification({ event, title, message, hookInput }) {
   const config = EVENT_CONFIG[event] || EVENT_CONFIG.Stop;
   const ctx = extractContext(hookInput || {});
 
-  let finalTitle = title || config.title;
+  let finalTitle = title || `${config.title} (${ctx.project})`;
   let finalMessage = message;
 
   if (!finalMessage) {
     if (event === "StopFailure" && ctx.errorType) {
       const label = ERROR_TYPE_LABELS[ctx.errorType] || ctx.errorType;
-      finalTitle = `${config.title}: ${label}`;
+      finalTitle = `${config.title}: ${label} (${ctx.project})`;
       finalMessage = ctx.errorMessage || config.message;
     } else if (event === "Stop" && ctx.stopReason === "max_tokens") {
-      finalTitle = "Claude Code 响应截断";
+      finalTitle = `Claude Code 响应截断 (${ctx.project})`;
       finalMessage = "响应达到最大 token 限制被截断";
     } else if (event === "TaskCompleted" && ctx.taskSubject) {
       finalMessage = ctx.taskSubject;
@@ -143,7 +266,17 @@ function buildNotification({ event, title, message, hookInput }) {
     }
   }
 
-  return { title: finalTitle, message: finalMessage, sound: config.sound };
+  // 完成类事件提取 token 消耗字符串（由调用方决定放置位置）
+  let tokenStr = "";
+  if (TOKEN_EVENTS.has(event) && ctx.tokenUsage) {
+    const u = ctx.tokenUsage;
+    tokenStr = `本次任务消耗 ${formatTokens(u.total)} tokens`;
+    if (u.subCount > 0) {
+      tokenStr += ` · 子代理 ${u.subCount}`;
+    }
+  }
+
+  return { title: finalTitle, message: finalMessage, sound: config.sound, tokenStr };
 }
 
 /**
@@ -172,13 +305,13 @@ async function sendNotification(options = {}) {
     sound: customSound,
     dryRun = false,
     hookInput = {},
-    activate = true,
   } = options;
 
   const {
     title,
     message,
     sound: defaultSound,
+    tokenStr,
   } = buildNotification({
     event,
     title: customTitle,
@@ -188,14 +321,13 @@ async function sendNotification(options = {}) {
   const sound = customSound || defaultSound;
 
   const platform = os.platform();
+  // 非 Windows 平台无顶部栏，把 token 信息追加到消息正文
+  const displayMessage =
+    platform !== "win32" && tokenStr ? `${message} · ${tokenStr}` : message;
   let method = "unknown";
   let command = "";
   let args = [];
-  let useWatcher = false;
-
-  // 检测终端信息（用于点击激活）
-  const terminalInfo = activate ? detectTerminal() : null;
-  const activateCmd = terminalInfo ? getActivateCommand(terminalInfo) : null;
+  let tmpFile = null;
 
   if (platform === "darwin") {
     // macOS
@@ -206,31 +338,26 @@ async function sendNotification(options = {}) {
         "-title",
         title,
         "-message",
-        message,
+        displayMessage,
         "-sound",
         sound,
         "-group",
-        `claude-code-${extractContext(hookInput).project}`,
+        `claude-code-${path.basename(process.cwd())}`,
       ];
-      // terminal-notifier 内置点击激活：添加 -activate bundleId
-      if (activate && terminalInfo && terminalInfo.bundleId) {
-        args.push("-activate", terminalInfo.bundleId);
-      }
     } else {
       method = "osascript";
       command = "osascript";
-      const escaped = message.replace(/"/g, '\\"');
+      const escaped = displayMessage.replace(/"/g, '\\"');
       const escapedTitle = title.replace(/"/g, '\\"');
       args = [
         "-e",
         `display notification "${escaped}" with title "${escapedTitle}" sound name "${sound}"`,
       ];
-      // osascript 不支持点击回调，跳过激活
     }
   } else if (platform === "linux") {
     method = "notify-send";
     command = "notify-send";
-    args = [title, message, "--urgency=normal", "--expire-time=5000"];
+    args = [title, displayMessage, "--urgency=normal", "--expire-time=5000"];
     if (!commandExists("notify-send")) {
       const result = {
         sent: false,
@@ -245,27 +372,22 @@ async function sendNotification(options = {}) {
       }
       return result;
     }
-    // Linux: 使用后台 watcher 处理点击激活
-    if (activate && activateCmd) {
-      useWatcher = true;
-      args.push("--action=default=click");
-    }
   } else if (platform === "win32") {
-    // Windows: notify-helper.exe 通知 + 点击激活终端（无控制台窗口）
-    method = "notify-helper";
-    command = path.join(__dirname, "..", "vendor", "notify-helper", "ClaudeCodeNotify.exe");
-    // 注意：此列表需与 activate.js 的 WIN_TERMINAL_NAMES 保持同步
-    const targetNames = ["WindowsTerminal", "Code", "cursor", "claude", "cmd", "pwsh", "powershell", "mintty"];
-    const pid = (terminalInfo && terminalInfo.pid) ? String(terminalInfo.pid) : "0";
-    args = [title, message, targetNames.join(","), pid];
+    // SnoreToast: 原生 Windows Toast 通知，UTF-16 支持，不抢焦点
+    // token 信息拼到 appID，会显示在顶部应用名栏
+    method = "snoretoast";
+    const arch = os.arch() === "x64" ? "x64" : "x86";
+    command = path.join(__dirname, "..", "vendor", "snoretoast", `snoretoast-${arch}.exe`);
+    const appID = tokenStr ? `Claude Code · ${tokenStr}` : "Claude.Code";
+    args = ["-t", title, "-m", message, "-appID", appID];
   }
 
-  const result = { sent: !dryRun, method, command, args, activate: !!activateCmd };
-  if (terminalInfo) {
-    result.terminal = terminalInfo.name;
-  }
+  const result = { sent: !dryRun, method, command, args };
 
   if (dryRun) {
+    if (tmpFile) {
+      try { fs.unlinkSync(tmpFile); } catch {}
+    }
     result.sent = false;
     console.log(JSON.stringify(result, null, 2));
     return result;
@@ -273,36 +395,15 @@ async function sendNotification(options = {}) {
 
   try {
     if (command) {
-      if (method === "notify-helper") {
-        // Windows: notify-helper.exe 后台运行，等待点击后激活终端
-        const child = spawn(command, args, { detached: true, stdio: "ignore", windowsHide: true });
-        child.unref();
-      } else if (useWatcher && activateCmd) {
-        // Linux: 启动后台 watcher 发送通知 + 等待点击 + 激活终端
-        const watcherConfig = {
-          platform,
-          notifyCommand: command,
-          notifyArgs: args,
-          activateCommand: activateCmd.command,
-          activateArgs: activateCmd.args,
-          activateFallbackCommand: activateCmd.fallbackCommand || null,
-          activateFallbackArgs: activateCmd.fallbackArgs || null,
-          timeout: 120000,
-        };
-        const watcher = spawn(
-          process.execPath,
-          [path.join(__dirname, "activate-watcher.js"), JSON.stringify(watcherConfig)],
-          { detached: true, stdio: "ignore", windowsHide: true }
-        );
-        watcher.unref();
-      } else {
-        const { execFileSync } = require("child_process");
-        execFileSync(command, args, { stdio: "ignore", timeout: 8000 });
-      }
+      execFileSync(command, args, { stdio: "ignore", timeout: 8000 });
     }
   } catch (err) {
     result.sent = false;
     result.error = err.message;
+  } finally {
+    if (tmpFile) {
+      try { fs.unlinkSync(tmpFile); } catch {}
+    }
   }
 
   return result;

package/vendor/snoretoast/LICENSE

@@ -0,0 +1,166 @@
+// Retrieved from https://github.com/KDE/snoretoast/blob/master/COPYING.LGPL-3 version 0.7.0
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.