claude-notification-plugin 1.1.65 → 1.1.74

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-notification-plugin",
-  "version": "1.1.65",
+  "version": "1.1.74",
   "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
   "author": {
     "name": "Viacheslav Makarov",

package/README.md

@@ -134,6 +134,9 @@ ENV: `CLAUDE_NOTIFY_VOICE`
 **notifyOnWaiting** — Notify when Claude is waiting for input. Default: **false**
 ENV: `CLAUDE_NOTIFY_WAITING`
 
+**notifyOnPermission** — Notify when Claude asks for tool permission (e.g. file edit confirmation). Default: **true**
+ENV: `CLAUDE_NOTIFY_ON_PERMISSION`
+
 **webhookUrl** — POST notification JSON to this URL. When set, all events (including user prompts) are sent. Set env to empty string (`""`) to disable per-project.
 ENV: `CLAUDE_NOTIFY_WEBHOOK_URL`
 

package/commit-sha

@@ -1 +1 @@
-ca17dbcec65a2871b105feed158245a48fdd5d78
+40748d991517178165dc7d6f9c3a71b8b1ee7669

package/listener/LISTENER-DETAILED.md

@@ -204,6 +204,7 @@ Running two listeners is impossible — the PID file prevents it. And this is im
 | **WorktreeManager** | `worktree-manager.js` | Creates and removes git worktrees. Auto-discovery via `git worktree list`. Maps `&project/branch` to a path on disk |
 | **Logger** | `logger.js` | Writes operational log to `~/.claude/.cc-n-listener.log`. Rotation when exceeding 5 MB (old file → `.log.old`) |
 | **TaskLogger** | `task-logger.js` | Writes task Q&A logs (questions to Claude and answers). Separate file per project/branch. Rotation at 5 MB |
+| **JsonlReader** | `jsonl-reader.js` | Reads Claude Code's structured JSONL session files incrementally. Provides clean, semantic live console content (text responses, tool calls) instead of raw PTY output |
 
 ---
 
@@ -762,14 +763,91 @@ Shows a brief reference for all commands.
 
 ### Live console
 
-When **`liveConsole`** is enabled (default: `true`), the "⏳ Running..." message in Telegram is periodically updated with the cleaned tail of Claude Code's PTY output, so you can see what Claude is doing in real-time.
+When **`liveConsole`** is enabled (default: `true`), the "⏳ Running..." message in Telegram is periodically updated with what Claude is doing in real-time.
 
-The output is cleaned from ANSI escape codes and Claude Code UI chrome (logo, status bar, prompts), leaving only meaningful content.
+#### Data source: JSONL vs PTY
 
-Configuration:
-- `liveConsole` — enable/disable (default: `true`)
-- `liveConsoleIntervalMillis` — update interval in seconds (default: `1`)
-- `liveConsoleMaxOutputChars` — max characters of PTY output to show (default: `300`)
+The live console can read data from two sources:
+
+1. **JSONL session files** (default, preferred) — Claude Code writes structured JSONL files to `~/.claude/projects/{encodedCwd}/{sessionId}.jsonl`. Each line is a full JSON message with role, content (text, tool_use, thinking), model, timestamps, and cost. This gives clean, semantic output: the actual text Claude wrote and which tools it called.
+
+2. **PTY buffer** (fallback) — raw terminal output from the pseudo-terminal, cleaned from ANSI escape codes and Claude Code UI chrome. This is a legacy approach that produces noisier output.
+
+Controlled by the `liveConsoleSource` config parameter:
+- `"auto"` (default) — try JSONL first, fall back to PTY buffer
+- `"jsonl"` — use only JSONL (no output if file not found)
+- `"pty"` — use only PTY buffer (legacy behavior)
+
+#### How the JSONL path is resolved
+
+The JSONL file path follows the convention:
+```
+~/.claude/projects/{encodedCwd}/{sessionId}.jsonl
+```
+
+**Step 1: Determine `sessionId`**
+
+When Claude Code starts a session, its `SessionStart` hook writes a signal file `rdy_{sessionId}.json` to `~/.claude/pty-signals/`. The listener's PTY runner already polls this directory. On receiving a `ready` signal, the runner extracts `sessionId` from the filename and stores it in the session state.
+
+**Step 2: Encode `cwd` into a project directory name**
+
+Claude Code encodes the working directory path into a folder name by replacing special characters with dashes:
+
+| Character | Replacement |
+|---|---|
+| `:` | `-` |
+| `\` | `-` |
+| `/` | `-` |
+| `.` | `-` |
+| `_` | `-` |
+
+All other characters (letters, digits, existing `-`) are preserved as-is.
+
+Examples:
+
+| Working directory | Encoded project dir |
+|---|---|
+| `D:\DEV\FA\_pub\claude-notification-plugin` | `D--DEV-FA--pub-claude-notification-plugin` |
+| `D:\DEV\FA\_cur\work-fast--testing` | `D--DEV-FA--cur-work-fast--testing` |
+| `/home/user/projects/api-server` | `-home-user-projects-api-server` |
+
+The double dashes (`--`) arise naturally from consecutive special characters, e.g. `\_` → `-` + `-` = `--`.
+
+**Step 3: Construct the full path and open a reader**
+
+```
+sessionId = "08b1fa75-91fe-4c1e-a47e-db9b99af7fb5"
+cwd = "D:\DEV\FA\_pub\claude-notification-plugin"
+  ↓ encode
+encodedCwd = "D--DEV-FA--pub-claude-notification-plugin"
+  ↓ join
+path = ~/.claude/projects/D--DEV-FA--pub-claude-notification-plugin/08b1fa75-91fe-4c1e-a47e-db9b99af7fb5.jsonl
+```
+
+If `sessionId` is not yet known (session hasn't started), the fallback picks the most recently modified `.jsonl` file in the project directory (within the last 2 minutes).
+
+#### What is displayed
+
+From the JSONL data, the live console extracts:
+- **Text responses** — the actual text Claude wrote (from `content[].type === "text"`)
+- **Tool calls** — formatted as `🔧 Read: config.json`, `🔧 $ npm test`, `🔧 Grep: pattern`, etc. (from `content[].type === "tool_use"`)
+- **Thinking blocks** are skipped (not shown)
+
+This is far more informative than raw PTY output: you see the real tool calls and actual responses, not garbled terminal fragments.
+
+#### Incremental reading
+
+The JSONL reader tracks its byte offset in the file and only reads new data on each poll. Since JSONL files are append-only, this is safe and efficient — no re-reading of the entire file.
+
+#### Configuration
+
+| Parameter | Default | Description |
+|---|---|---|
+| `liveConsole` | `true` | Enable/disable live console |
+| `liveConsoleIntervalMillis` | `1000` | Update interval in milliseconds |
+| `liveConsoleMaxOutputChars` | `300` | Max chars of PTY output per update |
+| `liveConsoleSource` | `"auto"` | Data source: `"auto"`, `"jsonl"`, or `"pty"` |
+| `jsonlMaxContentChars` | `500` | Max chars of JSONL content per update |
 
 ### PTY logs
 
@@ -792,8 +870,9 @@ Send `/pty` or `/pty &project` in Telegram to get instant diagnostics:
 - Buffer size in bytes
 - Elapsed time since task start
 - Whether live console interval is active
+- Whether JSONL source is active
 - Whether PTY log stream is writing
-- Last 15 lines of cleaned output
+- Last 15 lines of output (from JSONL if available, otherwise from PTY buffer)
 
 ---
 

package/listener/jsonl-reader.js

@@ -0,0 +1,376 @@
+import fs from 'fs';
+import path from 'path';
+import { CLAUDE_DIR } from '../bin/constants.js';
+
+const PROJECTS_DIR = path.join(CLAUDE_DIR, 'projects');
+
+/**
+ * Encode a cwd path into the Claude Code project directory name.
+ * Replaces : \ / . _ with dashes.
+ *
+ * Examples:
+ *   D:\DEV\FA\_pub\my-project → D--DEV-FA--pub-my-project
+ *   /home/user/projects/api   → -home-user-projects-api
+ */
+export function cwdToProjectDir (cwd) {
+  return cwd.replace(/[:\\/._]/g, '-');
+}
+
+/**
+ * Find the JSONL file path for a given cwd and sessionId.
+ * Returns null if the file does not exist.
+ */
+export function resolveJsonlPath (cwd, sessionId) {
+  if (!sessionId) {
+    return null;
+  }
+  const dirName = cwdToProjectDir(cwd);
+  const filePath = path.join(PROJECTS_DIR, dirName, `${sessionId}.jsonl`);
+  try {
+    fs.accessSync(filePath, fs.constants.R_OK);
+    return filePath;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Find the most recently modified JSONL file for a given cwd.
+ * Used as a fallback when sessionId is not yet known.
+ * Returns null if no fresh file is found within maxAgeMs.
+ */
+export function resolveJsonlByMtime (cwd, maxAgeMs = 120_000) {
+  const dirName = cwdToProjectDir(cwd);
+  const dirPath = path.join(PROJECTS_DIR, dirName);
+  let files;
+  try {
+    files = fs.readdirSync(dirPath);
+  } catch {
+    return null;
+  }
+
+  let best = null;
+  let bestMtime = 0;
+  const now = Date.now();
+
+  for (const f of files) {
+    if (!f.endsWith('.jsonl')) {
+      continue;
+    }
+    try {
+      const stat = fs.statSync(path.join(dirPath, f));
+      if (stat.mtimeMs > bestMtime && now - stat.mtimeMs < maxAgeMs) {
+        bestMtime = stat.mtimeMs;
+        best = path.join(dirPath, f);
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  return best;
+}
+
+/**
+ * Incremental JSONL file reader.
+ * Reads new lines from a JSONL file since the last read.
+ */
+export class JsonlReader {
+  constructor (filePath, logger) {
+    this.filePath = filePath;
+    this.logger = logger || null;
+    this._offset = 0;
+    this._remainder = '';
+    this._lastAssistantText = '';
+    this._lastToolUse = null;
+  }
+
+  /**
+   * Read new lines since last call, parse JSON, update internal state.
+   * Returns array of parsed JSONL objects (only new ones).
+   */
+  readNew () {
+    let fd;
+    try {
+      fd = fs.openSync(this.filePath, 'r');
+    } catch {
+      return [];
+    }
+
+    try {
+      const stat = fs.fstatSync(fd);
+      if (stat.size <= this._offset) {
+        return [];
+      }
+
+      const buf = Buffer.alloc(stat.size - this._offset);
+      const bytesRead = fs.readSync(fd, buf, 0, buf.length, this._offset);
+      if (bytesRead === 0) {
+        return [];
+      }
+      this._offset += bytesRead;
+
+      const chunk = this._remainder + buf.toString('utf-8', 0, bytesRead);
+      const lines = chunk.split('\n');
+      // Last element may be incomplete — save as remainder
+      this._remainder = lines.pop() || '';
+
+      const entries = [];
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+          continue;
+        }
+        try {
+          const obj = JSON.parse(trimmed);
+          entries.push(obj);
+          this._processEntry(obj);
+        } catch {
+          // skip malformed lines
+        }
+      }
+      return entries;
+    } finally {
+      fs.closeSync(fd);
+    }
+  }
+
+  /**
+   * Process a parsed JSONL entry to update last assistant content.
+   */
+  _processEntry (entry) {
+    if (entry.message?.role !== 'assistant') {
+      return;
+    }
+
+    const content = entry.message?.content;
+    if (!Array.isArray(content)) {
+      return;
+    }
+
+    for (const block of content) {
+      if (block.type === 'text' && block.text) {
+        this._lastAssistantText = block.text;
+        this._lastToolUse = null; // text supersedes tool_use display
+      } else if (block.type === 'tool_use') {
+        this._lastToolUse = {
+          name: block.name || 'unknown',
+          input: block.input || {},
+        };
+      }
+      // thinking blocks are ignored for display
+    }
+  }
+
+  /**
+   * Get formatted display text from the last assistant message.
+   * Returns a short summary suitable for Telegram live console.
+   */
+  getDisplayContent (maxChars = 300) {
+    const parts = [];
+
+    if (this._lastToolUse) {
+      parts.push(formatToolUse(this._lastToolUse));
+    }
+
+    if (this._lastAssistantText) {
+      parts.push(this._lastAssistantText);
+    }
+
+    if (parts.length === 0) {
+      return '';
+    }
+
+    let result = parts.join('\n\n');
+    if (result.length > maxChars) {
+      result = result.slice(-maxChars);
+      // Trim to last complete line
+      const nlIdx = result.indexOf('\n');
+      if (nlIdx > 0) {
+        result = result.slice(nlIdx + 1);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Reset reader to re-read from the beginning.
+   */
+  reset () {
+    this._offset = 0;
+    this._remainder = '';
+    this._lastAssistantText = '';
+    this._lastToolUse = null;
+  }
+}
+
+/**
+ * Format a tool_use block into a short display string.
+ */
+function formatToolUse (tool) {
+  const name = tool.name || '';
+  const input = tool.input || {};
+  const trunc = (s, n) => (typeof s === 'string' && s.length > n ? s.slice(0, n - 1) + '…' : s);
+  switch (name) {
+    case 'Read':
+    case 'Write':
+    case 'Edit':
+      return input.file_path
+        ? `🔧 ${name}: ${path.basename(input.file_path)}`
+        : `🔧 ${name}`;
+    case 'Bash':
+      return input.command
+        ? `🔧 $ ${trunc(input.command, 80)}${input.run_in_background ? ' (bg)' : ''}${input.timeout ? ` (timeout ${input.timeout})` : ''}`
+        : '🔧 Bash';
+    case 'Grep':
+      if (input.pattern) {
+        const where = typeof input.path === 'string'
+          ? path.basename(input.path)
+          : (typeof input.glob === 'string' ? input.glob : '');
+
+        const flags = [];
+        if (input['-n']) flags.push('-n');
+        if (input['-C']) flags.push(`-C ${input['-C']}`);
+        if (!input['-C'] && (typeof input.context === 'number' || typeof input.context === 'string')) {
+          flags.push(`-C ${input.context}`);
+        }
+        if (input['-i']) flags.push('-i');
+        if (input['-A']) flags.push(`-A ${input['-A']}`);
+        if (input['-B']) flags.push(`-B ${input['-B']}`);
+        if (input.head_limit) flags.push(`head ${input.head_limit}`);
+        const flagStr = flags.length ? ` ${flags.join(' ')}` : '';
+
+        return where
+          ? `🔧 Grep${flagStr}: ${trunc(input.pattern, 60)} in ${trunc(where, 30)}`
+          : `🔧 Grep${flagStr}: ${trunc(input.pattern, 80)}`;
+      }
+      return '🔧 Grep';
+    case 'Glob':
+      if (input.pattern) {
+        const p = typeof input.path === 'string' ? path.basename(input.path) : '';
+        return p ? `🔧 Glob: ${trunc(input.pattern, 60)} in ${trunc(p, 30)}` : `🔧 Glob: ${trunc(input.pattern, 80)}`;
+      }
+      return '🔧 Glob';
+    case 'Agent':
+      if (input.description) {
+        const bg = input.run_in_background ? ' (bg)' : '';
+        const st = typeof input.subagent_type === 'string' && input.subagent_type.trim()
+          ? ` [${input.subagent_type.trim()}]`
+          : '';
+        return `🔧 Agent${bg}${st}: ${trunc(input.description, 80)}`;
+      }
+      return '🔧 Agent';
+    case 'Skill':
+      return input.skill
+        ? `🔧 Skill: ${input.skill}${input.args ? ` ${trunc(String(input.args), 80)}` : ''}`
+        : '🔧 Skill';
+    case 'WebFetch':
+      if (input.url) {
+        const hasPrompt = typeof input.prompt === 'string' && input.prompt.trim();
+        return `🔧 Fetch${hasPrompt ? '*' : ''}: ${trunc(input.url, 80)}`;
+      }
+      return '🔧 WebFetch';
+    case 'WebSearch':
+      return input.query ? `🔧 Search: ${input.query}` : '🔧 WebSearch';
+    case 'ToolSearch':
+      return input.query ? `🔧 ToolSearch: ${trunc(input.query, 200)}` : '🔧 ToolSearch';
+    case 'TaskCreate':
+      return input.subject
+        ? `🔧 Task+: ${trunc(input.subject, 100)}`
+        : '🔧 TaskCreate';
+    case 'TaskUpdate':
+      return input.taskId && input.status
+        ? `🔧 Task#${input.taskId}: ${input.status}`
+        : (input.taskId ? `🔧 Task#${input.taskId}` : '🔧 TaskUpdate');
+    case 'ExitPlanMode':
+      return input.planFilePath
+        ? `🔧 ExitPlanMode: ${path.basename(input.planFilePath)}`
+        : '🔧 ExitPlanMode';
+    case 'Task':
+      if (input.description) {
+        const st = typeof input.subagent_type === 'string' && input.subagent_type.trim()
+          ? ` [${input.subagent_type.trim()}]`
+          : '';
+        return `🔧 Task${st}: ${trunc(input.description, 80)}`;
+      }
+      return '🔧 Task';
+    case 'TaskOutput':
+      if (input.task_id) {
+        return `🔧 Task#${input.task_id}: output${input.timeout ? ` (timeout ${input.timeout})` : ''}`;
+      }
+      return '🔧 TaskOutput';
+    case 'AskUserQuestion': {
+      const qs = Array.isArray(input.questions) ? input.questions : [];
+      if (qs.length > 0) {
+        const first = qs[0] || {};
+        const head = (typeof first.header === 'string' && first.header.trim())
+          ? first.header.trim()
+          : (typeof first.question === 'string' ? first.question.trim() : '');
+        const suffix = qs.length > 1 ? ` (+${qs.length - 1})` : '';
+        if (head) {
+          return `🔧 Ask: ${trunc(head, 120)}${suffix}`;
+        }
+        return `🔧 AskUserQuestion${suffix}`;
+      }
+      return '🔧 AskUserQuestion';
+    }
+    default:
+      if (name.startsWith('mcp__playwright__browser_')) {
+        const action = name.slice('mcp__playwright__browser_'.length);
+        switch (action) {
+          case 'navigate':
+            return input.url ? `🔧 PW nav: ${trunc(input.url, 80)}` : '🔧 PW nav';
+          case 'click': {
+            const ref = typeof input.ref === 'string' ? input.ref : '';
+            const el = typeof input.element === 'string' ? input.element : '';
+            return `🔧 PW click: ${trunc(ref || el || '', 80)}`.trim();
+          }
+          case 'type': {
+            const ref = typeof input.ref === 'string' ? input.ref : '';
+            const text = typeof input.text === 'string' ? input.text : '';
+            return `🔧 PW type: ${trunc(ref || '', 40)}${text ? ` (${text.length} chars)` : ''}`.trim();
+          }
+          case 'take_screenshot':
+            return input.filename ? `🔧 PW shot: ${trunc(input.filename, 80)}` : '🔧 PW shot';
+          case 'wait_for':
+            return input.time ? `🔧 PW wait: ${input.time}` : '🔧 PW wait';
+          case 'console_messages':
+            return input.level ? `🔧 PW console: ${input.level}` : '🔧 PW console';
+          case 'snapshot':
+            return '🔧 PW snapshot';
+          default:
+            return `🔧 PW: ${action}`;
+        }
+      }
+      if (name === 'mcp__sequential-thinking__sequentialthinking') {
+        const n = input.thoughtNumber;
+        const total = input.totalThoughts;
+        const head = (typeof n === 'number' || typeof n === 'string') && (typeof total === 'number' || typeof total === 'string')
+          ? `${n}/${total} `
+          : '';
+        const thought = typeof input.thought === 'string' ? trunc(input.thought.trim(), 80) : '';
+        return `🔧 Think: ${head}${thought}`.trim();
+      }
+      if (name === 'mcp__serena__list_dir') {
+        return input.relative_path ? `🔧 Serena ls: ${trunc(input.relative_path, 80)}` : '🔧 Serena ls';
+      }
+      if (name === 'mcp__serena__get_symbols_overview') {
+        return input.relative_path ? `🔧 Serena symbols: ${trunc(input.relative_path, 80)}` : '🔧 Serena symbols';
+      }
+      if (name.startsWith('mcp__')) {
+        if (name === 'mcp__context7__resolve-library-id') {
+          return input.libraryName
+            ? `🔧 C7 lib: ${trunc(input.libraryName, 60)}`
+            : '🔧 C7 resolve';
+        }
+        if (name === 'mcp__context7__query-docs') {
+          const lib = typeof input.libraryId === 'string' ? input.libraryId : '';
+          const q = typeof input.query === 'string' ? input.query : '';
+          return `🔧 C7 docs: ${trunc(q || lib || '', 80)}`.trim();
+        }
+        const parts = name.split('__');
+        return parts.length >= 3 ? `🔧 MCP ${parts[1]}: ${parts[2]}` : `🔧 ${name}`;
+      }
+      return `🔧 ${name}`;
+  }
+}

package/listener/listener.js

@@ -12,6 +12,7 @@ import { PtyRunner } from './pty-runner.js';
 import { WorktreeManager } from './worktree-manager.js';
 import { parseMessage, parseTarget } from './message-parser.js';
 import { CLAUDE_DIR, CONFIG_PATH, LISTENER_LOG_FILENAME } from '../bin/constants.js';
+import { JsonlReader, resolveJsonlPath, resolveJsonlByMtime } from './jsonl-reader.js';
 
 // ----------------------
 // CRASH PROTECTION
@@ -138,6 +139,11 @@ const sessions = new Map();
 const freshSessionDirs = new Set();
 // Live console intervals per workDir
 const liveConsoleTimers = new Map();
+// JSONL readers per workDir (for live console from structured session data)
+const jsonlReaders = new Map();
+// Live console source: "jsonl" | "pty" | "auto" (default: "auto")
+const liveConsoleSource = listenerConfig.liveConsoleSource || 'auto';
+const jsonlMaxContentChars = listenerConfig.jsonlMaxContentChars || 500;
 
 logger.info('Listener started');
 logger.info(`Projects: ${JSON.stringify(Object.keys(listenerConfig.projects))}`);
@@ -322,6 +328,49 @@ function shouldContinueSession (workDir) {
   return sessions.has(workDir);
 }
 
+function _initJsonlReader (workDir) {
+  const sessionId = runner.getSessionId(workDir);
+  const jsonlPath = sessionId
+    ? resolveJsonlPath(workDir, sessionId)
+    : resolveJsonlByMtime(workDir);
+  if (jsonlPath) {
+    const reader = new JsonlReader(jsonlPath, logger);
+    jsonlReaders.set(workDir, reader);
+    logger.info(`JSONL reader initialized: ${jsonlPath}`);
+    return reader;
+  }
+  return null;
+}
+
+function _getJsonlContent (workDir) {
+  let reader = jsonlReaders.get(workDir);
+  if (!reader) {
+    reader = _initJsonlReader(workDir);
+  }
+  if (!reader) {
+    return null;
+  }
+  reader.readNew();
+  return reader.getDisplayContent(jsonlMaxContentChars);
+}
+
+function _getPtyContent (workDir) {
+  const raw = runner.getBuffer(workDir);
+  if (!raw) {
+    return null;
+  }
+  const cleaned = cleanPtyOutput(raw);
+  if (!cleaned) {
+    return null;
+  }
+  const tail = cleaned.length > liveConsoleMaxOutputChars
+    ? cleaned.slice(-liveConsoleMaxOutputChars)
+    : cleaned;
+  return cleaned.length > liveConsoleMaxOutputChars
+    ? tail.slice(tail.indexOf('\n') + 1)
+    : tail;
+}
+
 function startLiveConsole (workDir, messageId, header) {
   stopLiveConsole(workDir);
   if (!liveConsoleEnabled || !messageId) {
@@ -330,22 +379,13 @@ function startLiveConsole (workDir, messageId, header) {
   let lastSentText = '';
   const timer = setInterval(async () => {
     try {
-      const raw = runner.getBuffer(workDir);
-      if (!raw) {
-        return;
+      let output = null;
+      if (liveConsoleSource === 'jsonl' || liveConsoleSource === 'auto') {
+        output = _getJsonlContent(workDir);
       }
-      const cleaned = cleanPtyOutput(raw);
-      if (!cleaned) {
-        return;
+      if (!output && (liveConsoleSource === 'pty' || liveConsoleSource === 'auto')) {
+        output = _getPtyContent(workDir);
       }
-      // Take the tail that fits
-      const tail = cleaned.length > liveConsoleMaxOutputChars
-        ? cleaned.slice(-liveConsoleMaxOutputChars)
-        : cleaned;
-      // Trim to last complete line if we sliced mid-line
-      const output = cleaned.length > liveConsoleMaxOutputChars
-        ? tail.slice(tail.indexOf('\n') + 1)
-        : tail;
       if (!output || output === lastSentText) {
         return;
       }
@@ -370,6 +410,7 @@ function stopLiveConsole (workDir) {
     clearInterval(timer);
     liveConsoleTimers.delete(workDir);
   }
+  jsonlReaders.delete(workDir);
 }
 
 async function startTask (workDir, task) {
@@ -830,17 +871,27 @@ function formatPtyInfo (project, branch, workDir, info) {
     ? formatDuration(Date.now() - new Date(info.startedAt).getTime())
     : '-';
   const liveTimer = liveConsoleTimers.has(workDir) ? '✅' : '❌';
-  const raw = runner.getBuffer(workDir);
-  const cleaned = raw ? cleanPtyOutput(raw) : '';
-  const lastLines = cleaned
-    ? cleaned.split('\n').slice(-15).join('\n')
-    : '(empty)';
+  const hasJsonl = jsonlReaders.has(workDir) ? '✅' : '❌';
+
+  // Prefer JSONL content if available, fall back to PTY buffer
+  let lastLines = '(empty)';
+  const jsonlContent = _getJsonlContent(workDir);
+  if (jsonlContent) {
+    lastLines = jsonlContent.split('\n').slice(-15).join('\n');
+  } else {
+    const raw = runner.getBuffer(workDir);
+    const cleaned = raw ? cleanPtyOutput(raw) : '';
+    if (cleaned) {
+      lastLines = cleaned.split('\n').slice(-15).join('\n');
+    }
+  }
 
   return `<b>${escapeHtml(label)}</b>
 State: <code>${info.state}</code>
 Buffer: <code>${info.bufferSize}</code> bytes
 Elapsed: ${elapsed}
 Live console: ${liveTimer}
+JSONL source: ${hasJsonl}
 PTY log: <code>${info.hasLogStream ? 'writing' : 'off'}</code>
 
 <pre>${escapeHtml(lastLines)}</pre>`;

package/listener/pty-runner.js

@@ -135,12 +135,16 @@ export class PtyRunner extends EventEmitter {
           }
         }
       } else if (type === 'ready') {
-        // SessionStart — emit ready event
+        // SessionStart — emit ready event, capture sessionId from filename
         this._unlinkSafe(filePath);
+        const signalSessionId = f.startsWith('rdy_') ? f.slice(4, -5) : null;
         for (const [workDir, session] of this.sessions) {
           if (this._normalizePath(session.workDir) === this._normalizePath(cwd)) {
             session._lastActivityTime = Date.now();
             session._model = marker.model || '';
+            if (signalSessionId && signalSessionId !== 'unknown') {
+              session.sessionId = signalSessionId;
+            }
             this.emit('ready', workDir, marker);
             break;
           }
@@ -613,6 +617,14 @@ export class PtyRunner extends EventEmitter {
     return session?._buffer || '';
   }
 
+  /**
+   * Get Claude session ID for a workDir (captured from SessionStart hook signal).
+   */
+  getSessionId (workDir) {
+    const session = this.sessions.get(workDir);
+    return session?.sessionId || null;
+  }
+
   /**
    * Get last tool activity for a workDir (from PostToolUse hook signals).
    */

package/notifier/notifier.js

@@ -63,6 +63,7 @@ function loadConfig () {
     webhookUrl: '',
     notifyAfterSeconds: 15,
     notifyOnWaiting: false,
+    notifyOnPermission: true,
     debug: false,
   };
 
@@ -88,6 +89,9 @@ function loadConfig () {
       if (typeof user.notifyOnWaiting === 'boolean') {
         config.notifyOnWaiting = user.notifyOnWaiting;
       }
+      if (typeof user.notifyOnPermission === 'boolean') {
+        config.notifyOnPermission = user.notifyOnPermission;
+      }
       if (typeof user.debug === 'boolean') {
         config.debug = user.debug;
       }
@@ -122,6 +126,9 @@ function loadConfig () {
   if (process.env.CLAUDE_NOTIFY_WAITING !== undefined) {
     config.notifyOnWaiting = process.env.CLAUDE_NOTIFY_WAITING === '1';
   }
+  if (process.env.CLAUDE_NOTIFY_ON_PERMISSION !== undefined) {
+    config.notifyOnPermission = process.env.CLAUDE_NOTIFY_ON_PERMISSION === '1';
+  }
   if (process.env.CLAUDE_NOTIFY_DEBUG !== undefined) {
     config.debug = process.env.CLAUDE_NOTIFY_DEBUG === '1';
   }
@@ -641,11 +648,10 @@ function getVoicePhrase (duration, project) {
   return fn(duration, project || 'unknown');
 }
 
-function speakResult (config, duration, project) {
+function speakText (config, text) {
   if (!config.voice.enabled) {
     return;
   }
-  const text = getVoicePhrase(duration, project);
   try {
     switch (PLATFORM) {
       case 'win32': {
@@ -672,10 +678,26 @@ function speakResult (config, duration, project) {
       }
     }
   } catch (err) {
-    debugLog(config, 'speakResult failed:', err.message);
+    debugLog(config, 'speakText failed:', err.message);
   }
 }
 
+function speakResult (config, duration, project) {
+  speakText(config, getVoicePhrase(duration, project));
+}
+
+const permissionVoicePhrases = {
+  en: (p, tool) => `Claude needs your permission on ${p} for ${tool}`,
+  ru: (p, tool) => `Клод ожидает разрешение в проекте ${p} на ${tool}`,
+};
+
+function getPermissionVoicePhrase (project, toolName) {
+  const locale = Intl.DateTimeFormat().resolvedOptions().locale || 'en';
+  const lang = locale.split('-')[0].toLowerCase();
+  const fn = permissionVoicePhrases[lang] || permissionVoicePhrases.en;
+  return fn(project || 'unknown', toolName || 'unknown');
+}
+
 // ----------------------
 // READ HOOK INPUT
 // ----------------------
@@ -760,7 +782,7 @@ process.stdin.on('end', async () => {
   // STOP / NOTIFICATION EVENT
   // ----------------------
 
-  if (eventType !== 'Stop' && eventType !== 'Notification' && eventType !== 'StopFailure') {
+  if (eventType !== 'Stop' && eventType !== 'Notification' && eventType !== 'StopFailure' && eventType !== 'PermissionRequest') {
     process.exit(0);
   }
 
@@ -768,6 +790,10 @@ process.stdin.on('end', async () => {
     process.exit(0);
   }
 
+  if (eventType === 'PermissionRequest' && !config.notifyOnPermission) {
+    process.exit(0);
+  }
+
   let duration = 0;
   const session = state.sessions[sessionId];
   if (session?.start) {
@@ -778,8 +804,21 @@ process.stdin.on('end', async () => {
     process.exit(0);
   }
 
-  const statusEmoji = eventType === 'Notification' ? '⏸' : eventType === 'StopFailure' ? '❌' : '✅';
-  const desktopStatus = eventType === 'Notification' ? 'Waiting' : eventType === 'StopFailure' ? `Error: ${event.error || 'unknown'}` : 'Finished';
+  const permToolName = event.tool_name || 'unknown';
+  const permDetail = event.tool_input?.file_path || event.tool_input?.command?.slice(0, 80) || '';
+
+  const statusEmoji = eventType === 'PermissionRequest' ? '🔐' : eventType === 'Notification' ? '⏸' : eventType === 'StopFailure' ? '❌' : '✅';
+
+  let desktopStatus;
+  if (eventType === 'PermissionRequest') {
+    desktopStatus = `Permission: ${permToolName}${permDetail ? ` — ${path.basename(permDetail)}` : ''}`;
+  } else if (eventType === 'Notification') {
+    desktopStatus = 'Waiting';
+  } else if (eventType === 'StopFailure') {
+    desktopStatus = `Error: ${event.error || 'unknown'}`;
+  } else {
+    desktopStatus = 'Finished';
+  }
 
   const branch = getBranch(cwd);
   let label = `/${project}`;
@@ -794,8 +833,16 @@ process.stdin.on('end', async () => {
   const desktopTitle = label;
   const desktopMessage = desktopStatus;
 
-  let telegramMessage =
-    `${statusEmoji}  ${labelHtml}\n(duration: ${duration}s)${triggerLine}`;
+  let telegramMessage;
+  if (eventType === 'PermissionRequest') {
+    telegramMessage = `${statusEmoji}  ${labelHtml}\nPermission: <b>${escapeHtml(permToolName)}</b>`;
+    if (permDetail) {
+      telegramMessage += `\n<code>${escapeHtml(permDetail)}</code>`;
+    }
+    telegramMessage += `\n(duration: ${duration}s)${triggerLine}`;
+  } else {
+    telegramMessage = `${statusEmoji}  ${labelHtml}\n(duration: ${duration}s)${triggerLine}`;
+  }
 
   if (config.telegram.includeLastCcMessageInTelegram && event.last_assistant_message) {
     const maxLen = 3500;
@@ -813,15 +860,24 @@ process.stdin.on('end', async () => {
     telegramMessage += debugBlockHtml;
   }
 
-  await sendWebhook(config, {
+  const webhookPayload = {
     title: `${desktopStatus}: ${label}`,
     project,
     branch: branch || undefined,
     duration,
     trigger: eventType,
-    voicePhrase: config.voice.enabled ? getVoicePhrase(duration, project) : null,
     hookEvent: event,
-  });
+  };
+  if (eventType === 'PermissionRequest') {
+    webhookPayload.toolName = permToolName;
+    webhookPayload.toolInput = event.tool_input || {};
+  }
+  if (config.voice.enabled) {
+    webhookPayload.voicePhrase = eventType === 'PermissionRequest'
+      ? getPermissionVoicePhrase(project, permToolName)
+      : getVoicePhrase(duration, project);
+  }
+  await sendWebhook(config, webhookPayload);
 
   state._telegramText = telegramMessage;
   await sendTelegram(config, state);
@@ -833,5 +889,9 @@ process.stdin.on('end', async () => {
 
   await sendDesktopNotification(config, desktopTitle, desktopMessage);
   playSound(config);
-  speakResult(config, duration, project);
+  if (eventType === 'PermissionRequest') {
+    speakText(config, getPermissionVoicePhrase(project, permToolName));
+  } else {
+    speakResult(config, duration, project);
+  }
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-notification-plugin",
   "productName": "claude-notification-plugin",
-  "version": "1.1.65",
+  "version": "1.1.74",
   "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
   "type": "module",
   "engines": {