claude-notification-plugin 1.1.65 → 1.1.75

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-notification-plugin",
-  "version": "1.1.65",
+  "version": "1.1.75",
   "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/bin/constants.js

@@ -1,3 +1,4 @@
+import fs from 'fs';
 import os from 'os';
 import path from 'path';
 
@@ -39,6 +40,31 @@ export const SHORTCUT_DIR = path.join(
 export const SHORTCUT_PATH = path.join(SHORTCUT_DIR, SHORTCUT_NAME);
 export const APP_ID = 'Claude Notify';
 
+/**
+ * Find the alias of the project marked as default (isDefault: true).
+ * Falls back to the first project key if none is marked.
+ */
+export function getDefaultProject (projects) {
+  if (!projects || typeof projects !== 'object') {
+    return null;
+  }
+  for (const [alias, proj] of Object.entries(projects)) {
+    if (typeof proj === 'object' && proj.isDefault) {
+      return alias;
+    }
+  }
+  // Fallback: first project
+  const keys = Object.keys(projects);
+  return keys.length > 0 ? keys[0] : null;
+}
+
+/**
+ * Save config object back to CONFIG_PATH.
+ */
+export function saveConfig (config) {
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
 // Plugin identity
 export const HOOK_COMMAND = 'claude-notify';
 export const MARKETPLACE_KEY = 'bazilio-plugins';

package/bin/listener-cli.js

@@ -6,7 +6,7 @@ import readline from 'readline';
 import { spawn, execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import {
-  HOME, CLAUDE_DIR, CONFIG_PATH, PID_PATH, LISTENER_LOG_FILENAME,
+  HOME, CLAUDE_DIR, CONFIG_PATH, PID_PATH, LISTENER_LOG_FILENAME, getDefaultProject,
 } from './constants.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -116,7 +116,7 @@ async function startDaemon () {
     console.error(JSON.stringify({
       listener: {
         projects: {
-          default: { path: '/path/to/your/project' },
+          myproject: { path: '/path/to/your/project', isDefault: true },
         },
       },
     }, null, 2));
@@ -453,7 +453,10 @@ async function setupListener () {
     maxTotalTasks: L.maxTotalTasks ?? 50,
     logDir: L.logDir || path.join(HOME, '.claude'),
     taskLogDir: L.taskLogDir || path.join(HOME, '.claude'),
-    projectPath: L.projects?.default?.path || '',
+    projectPath: (() => {
+      const defAlias = getDefaultProject(L.projects);
+      return defAlias ? (L.projects[defAlias]?.path || '') : '';
+    })(),
   };
 
   const rl = readline.createInterface({
@@ -520,30 +523,41 @@ Permission mode for claude -p (tools access):
 
   // --- Default project ---
   console.log('');
-  const projectInput = await ask(rl, `Default project path [${defaults.projectPath || '(none)'}]: `);
-  const rawProjectPath = projectInput || defaults.projectPath;
-
   L.projects = L.projects || {};
+  const currentDefaultAlias = getDefaultProject(L.projects);
+  const currentDefaultPath = currentDefaultAlias ? (L.projects[currentDefaultAlias]?.path || '') : '';
+
+  const projectInput = await ask(rl, `Default project path [${currentDefaultPath || '(none)'}]: `);
+  const rawProjectPath = projectInput || currentDefaultPath;
   let hasValidProject = false;
 
   if (rawProjectPath) {
     const validatedPath = await validateProjectPath(rl, rawProjectPath);
     if (validatedPath) {
-      L.projects.default = L.projects.default || {};
-      L.projects.default.path = validatedPath;
+      let aliasForDefault = currentDefaultAlias;
+      if (!aliasForDefault) {
+        const aliasInput = await ask(rl, 'Alias for default project: ');
+        aliasForDefault = aliasInput && isValidAlias(aliasInput) ? aliasInput : 'main';
+      }
+      L.projects[aliasForDefault] = L.projects[aliasForDefault] || {};
+      L.projects[aliasForDefault].path = validatedPath;
+      // Set isDefault on this project, clear from others
+      for (const proj of Object.values(L.projects)) {
+        if (typeof proj === 'object') {
+          delete proj.isDefault;
+        }
+      }
+      L.projects[aliasForDefault].isDefault = true;
       hasValidProject = true;
     } else {
-      delete L.projects.default;
       console.log('  \u26a0 Default project will not be set. Listener will not start without at least one project.');
     }
   } else {
-    delete L.projects.default;
     console.log('  \u26a0 No default project configured. Listener will not start without at least one project.');
   }
 
   // --- Additional projects loop ---
-  // Count existing non-default projects
-  const existingAliases = Object.keys(L.projects).filter(a => a !== 'default');
+  const existingAliases = Object.keys(L.projects);
   if (existingAliases.length > 0) {
     console.log(`\nExisting projects: ${existingAliases.join(', ')}`);
   }
@@ -563,10 +577,6 @@ Permission mode for claude -p (tools access):
         console.log('  \u26a0 Alias cannot be empty.');
         continue;
       }
-      if (alias === 'default') {
-        console.log('  \u26a0 "default" is reserved. Choose a different name.');
-        continue;
-      }
       if (!isValidAlias(alias)) {
         console.log('  \u26a0 Invalid alias. Allowed characters: a-z, A-Z, 0-9, -, _');
         continue;

package/commit-sha

@@ -1 +1 @@
-ca17dbcec65a2871b105feed158245a48fdd5d78
+09e7c656d459f08696ec5408b01cb3ca67045d52

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,388 @@
+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

@@ -11,7 +11,8 @@ import { WorkQueue } from './work-queue.js';
 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 { CLAUDE_DIR, CONFIG_PATH, LISTENER_LOG_FILENAME, getDefaultProject, saveConfig } 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) {
@@ -473,6 +514,8 @@ async function handleCommand (cmd, args) {
       return handleNewSession(args);
     case '/projects':
       return handleProjects();
+    case '/setdefault':
+      return handleSetDefault(args);
     case '/worktrees':
       return handleWorktrees(args);
     case '/worktree':
@@ -611,7 +654,7 @@ function handleQueue () {
 
 async function handleCancel (args) {
   const target = parseTarget(args);
-  const projectAlias = target?.project || 'default';
+  const projectAlias = target?.project || getDefaultProject(listenerConfig.projects);
   const branch = target?.branch || null;
 
   let workDir;
@@ -662,7 +705,7 @@ function handleDrop (args) {
 
 function handleClear (args) {
   const target = parseTarget(args);
-  const projectAlias = target?.project || 'default';
+  const projectAlias = target?.project || getDefaultProject(listenerConfig.projects);
   const branch = target?.branch || null;
 
   let workDir;
@@ -685,7 +728,7 @@ function handleClear (args) {
 
 function handleNewSession (args) {
   const target = parseTarget(args);
-  const projectAlias = target?.project || 'default';
+  const projectAlias = target?.project || getDefaultProject(listenerConfig.projects);
   const branch = target?.branch || null;
 
   let workDir;
@@ -710,10 +753,12 @@ function handleNewSession (args) {
 
 function handleProjects () {
   const projects = listenerConfig.projects;
+  const defaultAlias = getDefaultProject(projects);
   let text = '📂 <b>Projects:</b>\n';
   for (const [alias, proj] of Object.entries(projects)) {
     const projPath = typeof proj === 'string' ? proj : proj.path;
-    text += `\n<b>&${escapeHtml(alias)}</b> → <code>${escapeHtml(projPath)}</code>`;
+    const icon = alias === defaultAlias ? '🏠 ' : '';
+    text += `\n${icon}<b>&${escapeHtml(alias)}</b> → <code>${escapeHtml(projPath)}</code>`;
     const worktrees = typeof proj === 'object' ? proj.worktrees : null;
     if (worktrees && Object.keys(worktrees).length > 0) {
       for (const [branch, wtPath] of Object.entries(worktrees)) {
@@ -721,7 +766,63 @@ function handleProjects () {
       }
     }
   }
-  return text;
+
+  const buttons = [];
+  // "Set Default" button
+  buttons.push([{ text: '🏠 Set Default', callback_data: '/setdefault' }]);
+
+  return { text, replyMarkup: { inline_keyboard: buttons } };
+}
+
+function handleSetDefault (args) {
+  const projects = listenerConfig.projects;
+
+  // No args — show inline keyboard with project list
+  if (!args || !args.trim()) {
+    const defaultAlias = getDefaultProject(projects);
+    const buttons = [];
+    for (const [alias, proj] of Object.entries(projects)) {
+      const projPath = typeof proj === 'string' ? proj : proj.path;
+      const icon = alias === defaultAlias ? '🏠 ' : '';
+      buttons.push([{
+        text: `${icon}${alias} — ${projPath}`,
+        callback_data: `/setdefault ${alias}`,
+      }]);
+    }
+    return {
+      text: '🏠 <b>Select default project:</b>',
+      replyMarkup: { inline_keyboard: buttons },
+    };
+  }
+
+  // Args provided — set the default
+  const alias = args.trim();
+  if (!projects[alias]) {
+    return `❌ Project "<b>${escapeHtml(alias)}</b>" not found. Use /projects to list.`;
+  }
+
+  // Clear isDefault from all projects, set on chosen
+  for (const proj of Object.values(projects)) {
+    if (typeof proj === 'object') {
+      delete proj.isDefault;
+    }
+  }
+  const proj = projects[alias];
+  if (typeof proj === 'object') {
+    proj.isDefault = true;
+  }
+
+  // Persist to config file
+  try {
+    saveConfig(config);
+    logger.info(`Default project changed to "${alias}"`);
+  } catch (err) {
+    logger.error(`Failed to save config: ${err.message}`);
+    return `❌ Failed to save config: ${escapeHtml(err.message)}`;
+  }
+
+  const projPath = typeof proj === 'string' ? proj : proj.path;
+  return `✅ Default project: <b>&${escapeHtml(alias)}</b> → <code>${escapeHtml(projPath)}</code>`;
 }
 
 function handleWorktrees (args) {
@@ -830,17 +931,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>`;
@@ -880,6 +991,9 @@ const MENU_KEYBOARD = {
     [
       { text: '📜 History', callback_data: '/history' },
       { text: '🖥 PTY', callback_data: '/pty' },
+      { text: '🏠 Default', callback_data: '/setdefault' },
+    ],
+    [
       { text: '📖 Help', callback_data: '/help' },
     ],
   ],
@@ -897,6 +1011,7 @@ function handleHelp () {
 /clear &project[/branch] — clear queue + reset session
 /newsession [&project[/branch]] — reset session (keep queue)
 /projects — list projects
+/setdefault — change default project
 /worktrees &project — project worktrees
 /worktree &project/branch — create worktree
 /rmworktree &project/branch — remove worktree
@@ -1014,7 +1129,7 @@ async function mainLoop () {
           await poller.answerCallbackQuery(msg.callbackQueryId);
         }
 
-        const parsed = parseMessage(msg.text);
+        const parsed = parseMessage(msg.text, getDefaultProject(listenerConfig.projects));
         if (!parsed) {
           continue;
         }
@@ -1048,6 +1163,7 @@ async function mainLoop () {
     { command: 'status', description: 'Status of all projects' },
     { command: 'queue', description: 'Show all queues' },
     { command: 'projects', description: 'List projects' },
+    { command: 'setdefault', description: 'Change default project' },
     { command: 'history', description: 'Recent task history' },
     { command: 'pty', description: 'PTY session diagnostics' },
     { command: 'help', description: 'Show all commands' },

package/listener/message-parser.js

@@ -7,12 +7,15 @@
  *   /command args           → { type: 'command', cmd, args }
  *   &project/branch text    → { type: 'task', project, branch, text }
  *   &project text           → { type: 'task', project, branch: null, text }
- *   text                    → { type: 'task', project: 'default', branch: null, text }
+ *   text                    → { type: 'task', project: <defaultProject>, branch: null, text }
  *
  * Any /word is treated as a command (known or unknown).
  * Project designation uses & prefix: &project or &project/branch.
+ *
+ * @param {string} text - The message text.
+ * @param {string} [defaultProject] - Alias of the default project (used for plain text tasks).
  */
-export function parseMessage (text) {
+export function parseMessage (text, defaultProject) {
   if (!text || typeof text !== 'string') {
     return null;
   }
@@ -61,7 +64,7 @@ export function parseMessage (text) {
   // Plain text → default project
   return {
     type: 'task',
-    project: 'default',
+    project: defaultProject || 'default',
     branch: null,
     text: trimmed,
   };

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.75",
   "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
   "type": "module",
   "engines": {