claude-notification-plugin 1.1.29 → 1.1.32

package/.claude-plugin/plugin.json

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

package/README.md

@@ -171,7 +171,7 @@ Add to `.claude/settings.local.json` in the project root:
 
 ## Telegram Listener
 
-Background daemon that receives tasks from Telegram and executes them via `claude -p`. The result is sent back to Telegram.
+Background daemon that receives tasks from Telegram and executes them via an interactive Claude Code PTY session. The result is sent back to Telegram.
 
 The Listener uses the same bot and `chatId` as notifications.
 
@@ -259,7 +259,7 @@ All commands start with `/` and execute instantly (not queued).
 | Parameter            | Default               | Description                                                                            |
 |----------------------|-----------------------|----------------------------------------------------------------------------------------|
 | `projects`           | (required)            | Map of projects: `alias → { path }`                                                    |
-| `claudeArgs`         | `[]`                  | Extra CLI args for `claude -p` (e.g. `["--permission-mode", "auto"]`)                  |
+| `claudeArgs`         | `[]`                  | Extra CLI args for Claude (e.g. `["--permission-mode", "auto"]`)                       |
 | `continueSession`    | `true`                | Continue previous session context (`--continue` flag). Claude remembers previous tasks |
 | `worktreeBaseDir`    | `~/.claude/worktrees` | Where auto-created worktrees are stored                                                |
 | `autoCreateWorktree` | `true`                | Auto-create worktrees for unknown branches                                             |

package/bin/constants.js

@@ -13,6 +13,9 @@ export const RESOLVER_FILENAME = 'claude-notify-resolve.js';
 export const LISTENER_LOG_FILENAME = '.cc-n-listener.log';
 export const INSTALL_LOG_FILENAME = 'claude-notify-install.log';
 
+// PTY signal directory
+export const PTY_SIGNAL_DIR = path.join(CLAUDE_DIR, 'pty-signals');
+
 // Full paths
 export const CONFIG_PATH = path.join(CLAUDE_DIR, CONFIG_FILENAME);
 export const STATE_PATH = path.join(CLAUDE_DIR, STATE_FILENAME);

package/commit-sha

@@ -1 +1 @@
-f96269c4c26426738161143aed8e1efbf7c86bac
+b65d01cebc9e993e0a3808bcd3715fde0acfa7b4

package/listener/LISTENER-DETAILED.md

@@ -1,7 +1,7 @@
 # Telegram Listener - Detailed Guide
 
 Telegram Listener is a background daemon that receives tasks from a Telegram chat
-and executes them on your machine via `claude -p`. The result is sent back to Telegram.
+and executes them on your machine via an interactive Claude Code PTY session. The result is sent back to Telegram.
 
 **[Quick Start here](../LISTENER.md)**
 
@@ -178,11 +178,11 @@ Running two listeners is impossible — the PID file prevents it. And this is im
 │  └───────┬────────┘            │           │
 │          │                     │           │
 │  ┌───────┴────────┐    ┌───────┴───────┐   │
-│  │ MessageParser  │    │  TaskRunner   │   │
+│  │ MessageParser  │    │  PtyRunner    │   │
 │  │                │    │               │   │
-│  │ /proj/branch   │    │ spawn claude  │   │
+│  │ /proj/branch   │    │ PTY session   │   │
 │  │ /commands      │    │ timeouts      │   │
-│  └────────────────┘    │ kill          │   │
+│  └────────────────┘    │ signal files  │   │
 │                        └───────────────┘   │
 │  ┌────────────────┐    ┌───────────────┐   │
 │  │WorktreeManager │    │    Logger     │   │
@@ -199,7 +199,7 @@ Running two listeners is impossible — the PID file prevents it. And this is im
 | **TelegramPoller** | `telegram-poller.js` | Long polling to the Telegram API. Receives messages, sends replies. Splits long messages into chunks |
 | **MessageParser** | `message-parser.js` | Parses message text: is it a command (`/status`) or a task (`/proj1 fix bug`)? Extracts project, branch, task text |
 | **WorkQueue** | `work-queue.js` | Manages task queues. Each working directory has a separate FIFO queue. Guarantees: one `claude` process per directory. Persists state to disk |
-| **TaskRunner** | `task-runner.js` | Runs `claude -p "task"` as a child process. Monitors timeouts. Can kill the process on cancellation. Emits events: complete, error, timeout |
+| **PtyRunner** | `pty-runner.js` | Runs Claude in an interactive PTY session (via `node-pty`). Reuses sessions across tasks. Receives results via hook signal files. Monitors timeouts. Emits events: complete, error, timeout |
 | **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 |
@@ -255,8 +255,8 @@ WorkQueue.enqueue(workDir, task)
        │
        ├─ workDir is free (active = null)
        │    → active = task
-       │    → TaskRunner.run(workDir, task)
-       │    → claude -p "fix bug" --output-format text
+       │    → PtyRunner.run(workDir, task)
+       │    → sends task to Claude PTY session
        │    → Telegram: "⏳ Running: fix bug"
        │
        └─ workDir is busy (active != null)
@@ -269,7 +269,7 @@ TaskRunner emit 'complete'/'error'/'timeout'
        ├─ Send result to Telegram
        └─ WorkQueue.onTaskComplete(workDir)
             ├─ Queue is empty → active = null
-            └─ More tasks → shift() → TaskRunner.run()
+            └─ More tasks → shift() → PtyRunner.run()
 ```
 
 ---
@@ -340,7 +340,7 @@ Full example of `~/.claude/claude-notify.config.json` with the listener section:
 | Parameter | Default | Description |
 |---|---|---|
 | `projects` | — (required) | Map of projects: `alias → { path, worktrees?, claudeArgs? }` |
-| `claudeArgs` | `[]` | Extra CLI args passed to `claude -p` (e.g. `["--permission-mode", "auto"]`). Can also be set per-project to override |
+| `claudeArgs` | `[]` | Extra CLI args passed to Claude (e.g. `["--permission-mode", "auto"]`). Can also be set per-project to override |
 | `continueSession` | `true` | Continue previous session context per workDir. Claude remembers previous tasks. Use `/newsession` or `/clear` to reset |
 | `worktreeBaseDir` | `~/.claude/worktrees` | Where auto-created worktrees are stored |
 | `autoCreateWorktree` | `true` | Automatically create a worktree if the branch is not found |
@@ -417,9 +417,9 @@ If the worktree doesn't exist, it will be created automatically.
 2. Parses `/project/branch` from the beginning of the message
 3. Determines the working directory (workDir)
 4. Checks: is this workDir busy with another task?
-   - **No** → runs `claude -p "task"` immediately, replies with `⏳ Running...`
+   - **No** → sends task to the PTY session immediately, replies with `⏳ Running...`
    - **Yes** → adds to the queue, replies with `📋 Queued (position N)...`
-5. When Claude finishes → sends the result to Telegram
+5. When Claude finishes (hook signal file received) → sends the result to Telegram
 6. If there's a next task in the queue → starts it
 
 ---
@@ -748,19 +748,20 @@ Shows a brief reference for all commands.
      → Yes: queue.push(task), reply with position
 
 4. EXECUTION
-   claude -p "task" --output-format text
+   Task sent to Claude PTY session
      cwd = workDir
      timeout = 30 min
    Telegram: "⏳ Running: <task>"
 
 5. WAITING
-   The claude process is working...
+   Claude is working in the PTY session...
    (listener continues accepting other messages)
+   Hook "Stop" fires → signal file written
 
 6. COMPLETION
-   claude finished:
-     exit 0 → "✅ Done" + stdout
-     exit N → "❌ Error" + stderr
+   Signal file received:
+     lastAssistantMessage → "✅ Done" + response text
+     PTY error/crash → "❌ Error"
      timeout → "⏰ Timeout"
 
 7. NEXT TASK
@@ -769,24 +770,22 @@ Shows a brief reference for all commands.
      → No: active = null, workDir is free
 ```
 
-### What Claude receives
+### How Claude runs
 
-The command that gets executed:
+The listener spawns an interactive Claude Code session in a pseudo-terminal (PTY) using `node-pty`. This is equivalent to running `claude` in a real terminal — Claude has full access to all its capabilities (hooks, tools, interactive features).
 
-```bash
-claude -p "your message text from Telegram" --output-format text [claudeArgs...]
-```
-
-With the working directory (`cwd`) = project/worktree workDir.
+The working directory (`cwd`) = project/worktree workDir.
 
 Extra CLI arguments can be configured via `claudeArgs` in config (global or per-project).
-Recommended: `["--permission-mode", "auto"]` — allows Claude to use tools (Edit, Bash, Read, etc.) without interactive prompts, matching the quality of a full interactive session.
+Recommended: `["--permission-mode", "auto"]` — allows Claude to use tools (Edit, Bash, Read, etc.) without interactive prompts.
 
 Claude sees the project files, CLAUDE.md, .claude/settings.json, and everything else as if you had launched it manually in that directory.
 
+Task results are received via Claude's `Stop` hook, which writes a signal file containing `last_assistant_message` — the clean final response (not the raw PTY output with spinners and tool calls).
+
 ### Session continuity
 
-When `continueSession` is enabled (default), the listener adds `--continue` to subsequent tasks in the same workDir. This means Claude remembers previous tasks and their context — just like working in an interactive terminal session.
+When `continueSession` is enabled (default), the listener reuses the same PTY session for subsequent tasks in the same workDir. The Claude process stays alive between tasks, preserving full context — exactly like working in an interactive terminal.
 
 Messages show session status:
 - `🆕` = new session (first task or after `/newsession`/`/clear`)
@@ -799,7 +798,7 @@ Use `/newsession` to reset the session when context gets full, or `/clear` to re
 
 ### What is returned to Telegram
 
-The `result` field from Claude's JSON output — the text response to your task.
+The `last_assistant_message` from Claude's Stop hook — the clean final response to your task.
 
 Handling long responses:
 - Up to 4096 characters — a single message
@@ -880,13 +879,13 @@ The Listener processes **only** messages from the `chatId` specified in the conf
 
 ### No shell injection
 
-Task text is passed to claude as an array argument, not through the shell:
+Task text is written to the PTY session's stdin, not passed through a shell command:
 
 ```js
-// Like this (safe):
-spawn('claude', ['-p', userText], { ... })
+// PTY session — text goes to Claude's interactive prompt:
+ptyProcess.write(taskText + '\r')
 
-// NOT like this (dangerous):
+// NOT through shell interpolation:
 exec(`claude -p "${userText}"`)
 ```
 
@@ -942,8 +941,7 @@ The watchdog will automatically clear stale tasks on the next startup.
 
 ### Claude gives low-quality responses (doesn't edit files, just describes what to do)
 
-By default `claude -p` runs without tool permissions — Claude can't use Edit, Bash, Read, etc.
-Add `claudeArgs` to your listener config:
+Add `claudeArgs` to your listener config to grant tool permissions:
 
 ```json
 "listener": {
@@ -1020,8 +1018,8 @@ You (terminal): claude-notify listener start
 You: /api add endpoint GET /users with pagination
 Bot: ⏳ [/api] Running: add endpoint GET /users with pagination
 
-    Behind the scenes: process started
-    claude -p "add endpoint GET /users with pagination" --output-format text
+    Behind the scenes: PTY session created
+    claude (interactive PTY) → task sent
     cwd = /home/user/projects/api
 
 === 10:02 — Task to another project (in parallel!) ===
@@ -1029,7 +1027,7 @@ Bot: ⏳ [/api] Running: add endpoint GET /users with pagination
 You: /web add a /users page that calls GET /users
 Bot: ⏳ [/web] Running: add a /users page that calls GET /users
 
-    Now two claude processes are running in parallel:
+    Now two PTY sessions are running in parallel:
     one in /home/user/projects/api, another in /home/user/projects/web
 
 === 10:03 — Another task for api (queued) ===
@@ -1044,7 +1042,7 @@ You: /api/feature/auth add JWT authorization middleware
 Bot: 🌿 Created worktree feature/auth for project "api"
      ⏳ [/api/feature/auth] Running: add JWT authorization middleware
 
-    Three claude processes running in parallel:
+    Three PTY sessions running in parallel:
     1. api/main     → GET /users
     2. api/auth     → JWT middleware
     3. web/main     → /users page

package/listener/listener.js

@@ -8,7 +8,7 @@ import { createLogger } from './logger.js';
 import { createTaskLogger } from './task-logger.js';
 import { TelegramPoller, escapeHtml } from './telegram-poller.js';
 import { WorkQueue } from './work-queue.js';
-import { TaskRunner } from './task-runner.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';
@@ -99,7 +99,9 @@ const queue = new WorkQueue(
 const taskLogDir = config.listener?.taskLogDir || listenerLogDir;
 fs.mkdirSync(taskLogDir, { recursive: true });
 const taskLogger = createTaskLogger(taskLogDir);
-const runner = new TaskRunner(logger, taskTimeout, taskLogger);
+
+const runner = new PtyRunner(logger, taskTimeout, taskLogger);
+
 const worktreeManager = new WorktreeManager(config, logger);
 
 const startTime = Date.now();
@@ -308,8 +310,8 @@ async function startTask (workDir, task) {
   task.runningMessageId = runningMsgId;
   const claudeArgs = getClaudeArgs(entry?.project);
   try {
-    const started = runner.run(workDir, task, claudeArgs, continueSession);
-    queue.markStarted(workDir, started.pid);
+    runner.run(workDir, task, claudeArgs, continueSession);
+    queue.markStarted(workDir, task.pid || 0);
   } catch (err) {
     logger.error(`Failed to start task: ${err.message}`);
     poller.sendMessage(`❌  <code>${label}</code>\nFailed to start: ${escapeHtml(err.message)}`);

package/listener/pty-runner.js

@@ -0,0 +1,445 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { EventEmitter } from 'events';
+import { PTY_SIGNAL_DIR } from '../bin/constants.js';
+
+const DEFAULT_TIMEOUT = 600_000; // 10 minutes
+
+/**
+ * PTY-based runner for Claude Code.
+ * Uses node-pty to spawn an interactive Claude session and
+ * receives completion signals via marker files written by the notifier hook.
+ */
+export class PtyRunner extends EventEmitter {
+  constructor (logger, timeout, taskLogger) {
+    super();
+    this.logger = logger;
+    this.timeout = timeout || DEFAULT_TIMEOUT;
+    this.taskLogger = taskLogger || null;
+    // workDir -> { pty, state, currentTask, sessionId, workDir, _pendingId, _buffer }
+    this.sessions = new Map();
+    this.pendingMarkers = new Map(); // pendingId -> resolve callback
+    this._pty = null; // lazy-loaded node-pty module
+    this._startMarkerWatcher();
+  }
+
+  /**
+   * Lazily load node-pty module.
+   */
+  async _loadPty () {
+    if (!this._pty) {
+      this._pty = await import('node-pty');
+    }
+    return this._pty;
+  }
+
+  /**
+   * Start watching the signal directory for marker files.
+   */
+  _startMarkerWatcher () {
+    try {
+      fs.mkdirSync(PTY_SIGNAL_DIR, { recursive: true });
+    } catch {
+      // ignore
+    }
+
+    // Clean up stale marker files on startup
+    try {
+      const files = fs.readdirSync(PTY_SIGNAL_DIR);
+      for (const f of files) {
+        if (f.endsWith('.json')) {
+          try {
+            fs.unlinkSync(path.join(PTY_SIGNAL_DIR, f));
+          } catch {
+            // ignore
+          }
+        }
+      }
+    } catch {
+      // ignore
+    }
+
+    // Use polling-based watcher for cross-platform reliability
+    this._pollInterval = setInterval(() => this._checkMarkerFiles(), 500);
+  }
+
+  /**
+   * Check for new marker files in the signal directory.
+   */
+  _checkMarkerFiles () {
+    if (this.pendingMarkers.size === 0) {
+      return;
+    }
+
+    let files;
+    try {
+      files = fs.readdirSync(PTY_SIGNAL_DIR);
+    } catch {
+      return;
+    }
+
+    for (const f of files) {
+      if (!f.endsWith('.json')) {
+        continue;
+      }
+
+      const filePath = path.join(PTY_SIGNAL_DIR, f);
+      let marker;
+      try {
+        marker = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      } catch {
+        continue;
+      }
+
+      // Try to match by cwd (primary matching for PTY runner)
+      const cwd = marker.cwd;
+      if (cwd) {
+        for (const [pid, resolve] of this.pendingMarkers) {
+          const session = this._findSessionByPendingId(pid);
+          if (session && this._normalizePath(session.workDir) === this._normalizePath(cwd)) {
+            this.pendingMarkers.delete(pid);
+            try {
+              fs.unlinkSync(filePath);
+            } catch {
+              // ignore
+            }
+            resolve(marker);
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  _normalizePath (p) {
+    return p.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+  }
+
+  _findSessionByPendingId (pendingId) {
+    for (const [, session] of this.sessions) {
+      if (session._pendingId === pendingId) {
+        return session;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Wait for a marker file for the given pending ID.
+   */
+  _waitForMarker (pendingId, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingMarkers.delete(pendingId);
+        reject(new Error('Marker timeout'));
+      }, timeoutMs);
+
+      this.pendingMarkers.set(pendingId, (marker) => {
+        clearTimeout(timer);
+        resolve(marker);
+      });
+    });
+  }
+
+  /**
+   * Run a task in a specific workDir.
+   * Returns the task object immediately, emits events on completion.
+   * Returns the task object immediately, emits events on completion.
+   */
+  run (workDir, task, claudeArgs = [], continueSession = false) {
+    if (this.sessions.has(workDir) && this.sessions.get(workDir).state === 'busy') {
+      throw new Error(`Already running a task in ${workDir}`);
+    }
+
+    if (this.taskLogger) {
+      this.taskLogger.logQuestion(task.project || 'unknown', task.branch || 'main', workDir, task.text);
+    }
+
+    task.startedAt = new Date().toISOString();
+    task.continueSession = continueSession;
+
+    // Mark as busy immediately with a placeholder session
+    const existingSession = this.sessions.get(workDir);
+    if (existingSession && existingSession.state === 'idle' && continueSession) {
+      // Reuse existing PTY session
+      this._sendTask(workDir, existingSession, task);
+    } else {
+      // Need a new PTY session — create async
+      if (existingSession) {
+        this._destroyPty(workDir);
+      }
+      // Create a placeholder to prevent double-starts
+      this.sessions.set(workDir, { state: 'busy', currentTask: task, workDir });
+      this._createAndSendTask(workDir, task, claudeArgs);
+    }
+
+    return task;
+  }
+
+  /**
+   * Create PTY session and send task (async, fire-and-forget).
+   */
+  _createAndSendTask (workDir, task, claudeArgs) {
+    this._createPtySession(workDir, claudeArgs).then((session) => {
+      this.sessions.set(workDir, session);
+      this._sendTask(workDir, session, task);
+    }).catch((err) => {
+      this.sessions.delete(workDir);
+      const errorMsg = `Failed to create PTY session: ${err.message}`;
+      this.logger.error(errorMsg);
+      if (this.taskLogger) {
+        this.taskLogger.logAnswer(task.project || 'unknown', task.branch || 'main', errorMsg, 1);
+      }
+      this.emit('error', workDir, task, errorMsg);
+    });
+  }
+
+  /**
+   * Send a task to an existing PTY session and wait for completion.
+   */
+  _sendTask (workDir, session, task) {
+    const pendingId = `pty-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+    session.state = 'busy';
+    session.currentTask = task;
+    session._pendingId = pendingId;
+
+    // Set up marker wait + timeout
+    const markerPromise = this._waitForMarker(pendingId, this.timeout);
+
+    // Send the task text to the PTY
+    session.pty.write(task.text + '\r');
+    this.logger.info(`PTY task sent to ${workDir}: ${task.text.slice(0, 100)}`);
+
+    // Handle completion asynchronously
+    markerPromise.then((marker) => {
+      session.state = 'idle';
+      session.currentTask = null;
+      session.sessionId = marker.sessionId;
+
+      const result = {
+        text: marker.lastAssistantMessage || '',
+        sessionId: marker.sessionId || null,
+        cost: marker.cost || 0,
+        numTurns: marker.numTurns || 0,
+        durationMs: marker.durationMs || 0,
+        contextWindow: marker.contextWindow || 0,
+        totalTokens: marker.totalTokens || 0,
+        isError: false,
+      };
+
+      this.logger.info(`PTY task completed in ${workDir} (session: ${result.sessionId || 'unknown'})`);
+      if (this.taskLogger) {
+        this.taskLogger.logAnswer(task.project || 'unknown', task.branch || 'main', result.text, 0);
+      }
+      this.emit('complete', workDir, task, result);
+    }).catch((err) => {
+      session.state = 'idle';
+      session.currentTask = null;
+
+      if (err.message === 'Marker timeout') {
+        this.logger.warn(`PTY task timed out in ${workDir}`);
+        this._destroyPty(workDir);
+        this.emit('timeout', workDir, task);
+      } else {
+        this.logger.error(`PTY task error in ${workDir}: ${err.message}`);
+        if (this.taskLogger) {
+          this.taskLogger.logAnswer(task.project || 'unknown', task.branch || 'main', err.message, 1);
+        }
+        this.emit('error', workDir, task, err.message);
+      }
+    });
+  }
+
+  /**
+   * Create a new PTY session for a workDir.
+   */
+  async _createPtySession (workDir, claudeArgs = []) {
+    const pty = await this._loadPty();
+    const spawn = pty.spawn || pty.default?.spawn;
+
+    if (!spawn) {
+      throw new Error('node-pty spawn function not found');
+    }
+
+    // Filter out pipe-mode-specific args
+    const args = claudeArgs.filter(a => a !== '-p' && a !== '--output-format' && a !== 'json');
+
+    this.logger.info(`Creating PTY session in ${workDir} with args: ${JSON.stringify(args)}`);
+
+    const shell = process.platform === 'win32' ? 'cmd.exe' : '/bin/bash';
+    const shellArgs = process.platform === 'win32'
+      ? ['/c', 'claude', ...args]
+      : ['-c', ['claude', ...args].join(' ')];
+
+    const ptyProcess = spawn(shell, shellArgs, {
+      name: 'xterm-256color',
+      cols: 120,
+      rows: 40,
+      cwd: workDir,
+      env: {
+        ...process.env,
+        CLAUDE_NOTIFY_FROM_LISTENER: '1',
+        TERM: 'xterm-256color',
+      },
+    });
+
+    const session = {
+      pty: ptyProcess,
+      state: 'starting',
+      currentTask: null,
+      sessionId: null,
+      workDir,
+      _pendingId: null,
+      _buffer: '',
+    };
+
+    ptyProcess.onData((data) => {
+      session._buffer += data;
+      // Keep buffer reasonable size
+      if (session._buffer.length > 50000) {
+        session._buffer = session._buffer.slice(-25000);
+      }
+    });
+
+    ptyProcess.onExit(({ exitCode }) => {
+      this.logger.info(`PTY exited in ${workDir} with code ${exitCode}`);
+      const currentSession = this.sessions.get(workDir);
+      if (currentSession === session) {
+        if (session._pendingId && this.pendingMarkers.has(session._pendingId)) {
+          this.pendingMarkers.delete(session._pendingId);
+          if (session.currentTask) {
+            const task = session.currentTask;
+            session.state = 'dead';
+            session.currentTask = null;
+            this.sessions.delete(workDir);
+            const errorMsg = `PTY process exited unexpectedly (code ${exitCode})`;
+            this.logger.error(errorMsg);
+            if (this.taskLogger) {
+              this.taskLogger.logAnswer(task.project || 'unknown', task.branch || 'main', errorMsg, exitCode || 1);
+            }
+            this.emit('error', workDir, task, errorMsg);
+            return;
+          }
+        }
+        this.sessions.delete(workDir);
+      }
+    });
+
+    // Wait for Claude to start up (stabilize output)
+    await this._waitForReady(session, 15000);
+
+    session.state = 'idle';
+    this.logger.info(`PTY session ready in ${workDir}`);
+    return session;
+  }
+
+  /**
+   * Wait for PTY output to stabilize (Claude has loaded).
+   */
+  _waitForReady (session, timeoutMs) {
+    return new Promise((resolve) => {
+      let lastLength = 0;
+      let stableCount = 0;
+      const checkInterval = 500;
+
+      const timer = setInterval(() => {
+        const currentLength = session._buffer.length;
+        if (currentLength > 0 && currentLength === lastLength) {
+          stableCount++;
+          if (stableCount >= 3) {
+            clearInterval(timer);
+            clearTimeout(timeout);
+            resolve();
+          }
+        } else {
+          stableCount = 0;
+        }
+        lastLength = currentLength;
+      }, checkInterval);
+
+      const timeout = setTimeout(() => {
+        clearInterval(timer);
+        resolve();
+      }, timeoutMs);
+    });
+  }
+
+  /**
+   * Destroy PTY process for a workDir.
+   */
+  _destroyPty (workDir) {
+    const session = this.sessions.get(workDir);
+    if (!session) {
+      return;
+    }
+
+    if (session._pendingId && this.pendingMarkers.has(session._pendingId)) {
+      this.pendingMarkers.delete(session._pendingId);
+    }
+
+    try {
+      if (session.pty) {
+        session.pty.kill();
+      }
+    } catch {
+      // already dead
+    }
+    this.sessions.delete(workDir);
+  }
+
+  /**
+   * Cancel the active task in a workDir.
+   */
+  cancel (workDir) {
+    const session = this.sessions.get(workDir);
+    if (!session) {
+      return;
+    }
+
+    try {
+      if (session.pty) {
+        session.pty.write('\x03');
+      }
+    } catch {
+      // ignore
+    }
+
+    if (session._pendingId && this.pendingMarkers.has(session._pendingId)) {
+      this.pendingMarkers.delete(session._pendingId);
+    }
+
+    this._destroyPty(workDir);
+  }
+
+  /**
+   * Check if a task is running in a workDir.
+   */
+  isRunning (workDir) {
+    const session = this.sessions.get(workDir);
+    return session?.state === 'busy';
+  }
+
+  /**
+   * Get active task info for a workDir.
+   */
+  getActive (workDir) {
+    const session = this.sessions.get(workDir);
+    return session?.currentTask || null;
+  }
+
+  /**
+   * Cancel all active tasks (for graceful shutdown).
+   */
+  cancelAll () {
+    for (const workDir of [...this.sessions.keys()]) {
+      this._destroyPty(workDir);
+    }
+    if (this._pollInterval) {
+      clearInterval(this._pollInterval);
+      this._pollInterval = null;
+    }
+  }
+}

package/notifier/notifier.js

@@ -4,7 +4,7 @@ import fs from 'fs';
 import path from 'path';
 import process from 'process';
 import { execSync, spawn } from 'child_process';
-import { CONFIG_PATH, STATE_PATH } from '../bin/constants.js';
+import { CONFIG_PATH, STATE_PATH, PTY_SIGNAL_DIR } from '../bin/constants.js';
 
 // ----------------------
 // CONFIG
@@ -158,9 +158,31 @@ function isNotifierDisabled () {
     return true;
   }
   // Skip notifications for listener-spawned tasks unless explicitly enabled
-  return process.env.CLAUDE_NOTIFY_FROM_LISTENER === '1'
-    && process.env.CLAUDE_NOTIFY_AFTER_LISTENER !== '1';
+  if (process.env.CLAUDE_NOTIFY_FROM_LISTENER === '1'
+    && process.env.CLAUDE_NOTIFY_AFTER_LISTENER !== '1') {
+    return 'listener-only';
+  }
+  return false;
+}
 
+function writePtySignalFile (event) {
+  const sessionId = event.session_id || 'unknown';
+  const cwd = event.cwd || process.cwd();
+  try {
+    fs.mkdirSync(PTY_SIGNAL_DIR, { recursive: true });
+    const signalFile = path.join(PTY_SIGNAL_DIR, `${sessionId}.json`);
+    fs.writeFileSync(signalFile, JSON.stringify({
+      sessionId,
+      cwd,
+      lastAssistantMessage: event.last_assistant_message || '',
+      cost: event.total_cost_usd || 0,
+      numTurns: event.num_turns || 0,
+      durationMs: event.duration_ms || 0,
+      timestamp: Date.now(),
+    }));
+  } catch {
+    // silent fail
+  }
 }
 
 // ----------------------
@@ -280,7 +302,9 @@ async function sendTelegram (config, state) {
       body: JSON.stringify(body),
     });
     const data = await res.json();
-    if (!data.ok) console.error('[telegram] HTML send failed:', JSON.stringify(data));
+    if (!data.ok) {
+      console.error('[telegram] HTML send failed:', JSON.stringify(data));
+    }
     if (data.ok && data.result?.message_id) {
       if (!state.sentMessages) {
         state.sentMessages = [];
@@ -637,7 +661,16 @@ process.stdin.on('end', async () => {
   const project = path.basename(cwd);
   const sessionId = event.session_id || 'default';
 
-  if (isNotifierDisabled()) {
+  const disabled = isNotifierDisabled();
+  if (disabled === true) {
+    process.exit(0);
+  }
+
+  // For listener-only mode: write PTY signal file on Stop, then exit
+  if (disabled === 'listener-only') {
+    if (eventType === 'Stop') {
+      writePtySignalFile(event);
+    }
     process.exit(0);
   }
 
@@ -695,7 +728,7 @@ process.stdin.on('end', async () => {
     label += `/${branch}`;
     labelHtml += `/${escapeHtml(branch)}`;
   }
-  labelHtml = `<code>${labelHtml}</code>`
+  labelHtml = `<code>${labelHtml}</code>`;
   const triggerLine = config.debug ? `\nTrigger: ${eventType}` : '';
 
   const desktopTitle = label;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-notification-plugin",
   "productName": "claude-notification-plugin",
-  "version": "1.1.29",
+  "version": "1.1.32",
   "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
   "type": "module",
   "engines": {
@@ -51,7 +51,8 @@
     "access": "public"
   },
   "dependencies": {
-    "node-notifier": "^10.0.1"
+    "node-notifier": "^10.0.1",
+    "node-pty": "^1.1.0"
   },
   "devDependencies": {
     "eslint-plugin-import": "^2.31.0",

package/listener/task-runner.js

@@ -1,195 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn } from 'child_process';
-import { EventEmitter } from 'events';
-
-const DEFAULT_TIMEOUT = 600_000; // 10 minutes
-
-/**
- * Parse JSON output from claude --output-format json.
- * Returns structured result or fallback with raw text.
- */
-function parseClaudeOutput (raw) {
-  try {
-    const data = JSON.parse(raw);
-    const modelUsage = data.modelUsage || {};
-    const model = Object.keys(modelUsage)[0];
-    const mu = model ? modelUsage[model] : {};
-    const totalTokens = (mu.inputTokens || 0)
-      + (mu.cacheReadInputTokens || 0)
-      + (mu.cacheCreationInputTokens || 0)
-      + (mu.outputTokens || 0);
-    return {
-      text: data.result || '',
-      sessionId: data.session_id || null,
-      cost: data.total_cost_usd || 0,
-      numTurns: data.num_turns || 0,
-      durationMs: data.duration_ms || 0,
-      contextWindow: mu.contextWindow || 0,
-      totalTokens,
-      isError: !!data.is_error,
-    };
-  } catch {
-    return { text: raw.trim(), sessionId: null };
-  }
-}
-
-/**
- * Runs claude CLI tasks and emits events on completion.
- */
-export class TaskRunner extends EventEmitter {
-  constructor (logger, timeout, taskLogger) {
-    super();
-    this.logger = logger;
-    this.timeout = timeout || DEFAULT_TIMEOUT;
-    this.taskLogger = taskLogger || null;
-    this.activeProcesses = new Map(); // workDir -> { child, timer, task }
-  }
-
-  /**
-   * Run a task in a specific workDir.
-   * @param {string} workDir - Working directory
-   * @param {object} task - Task object { id, text, telegramMessageId, ... }
-   * @param {string[]} claudeArgs - Extra CLI args
-   * @param {boolean} continueSession - Add --continue flag
-   * @returns {object} task with pid
-   */
-  run (workDir, task, claudeArgs = [], continueSession = false) {
-    if (this.activeProcesses.has(workDir)) {
-      throw new Error(`Already running a task in ${workDir}`);
-    }
-
-    this.logger.info(`Running task "${task.text}" in ${workDir}${continueSession ? ' (continue session)' : ' (new session)'}`);
-    if (this.taskLogger) {
-      this.taskLogger.logQuestion(task.project || 'unknown', task.branch || 'main', workDir, task.text);
-    }
-
-    const args = ['-p', task.text, '--output-format', 'json', ...claudeArgs];
-    if (continueSession) {
-      args.push('--continue');
-    }
-    const child = spawn('claude', args, {
-      cwd: workDir,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      windowsHide: true,
-      shell: process.platform === 'win32',
-      env: { ...process.env, CLAUDE_NOTIFY_FROM_LISTENER: '1' },
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (chunk) => {
-      stdout += chunk.toString();
-    });
-
-    child.stderr.on('data', (chunk) => {
-      stderr += chunk.toString();
-    });
-
-    const timer = setTimeout(() => {
-      this.logger.warn(`Task "${task.id}" timed out in ${workDir}`);
-      this._killProcess(workDir);
-      this.emit('timeout', workDir, task);
-    }, this.timeout);
-
-    child.on('close', (code) => {
-      clearTimeout(timer);
-      this.activeProcesses.delete(workDir);
-
-      if (code === null) {
-        // Process was killed (timeout or cancel)
-        return;
-      }
-
-      if (code === 0) {
-        const result = parseClaudeOutput(stdout);
-        this.logger.info(`Task "${task.id}" completed in ${workDir} (session: ${result.sessionId || 'unknown'})`);
-        if (this.taskLogger) {
-          this.taskLogger.logAnswer(task.project || 'unknown', task.branch || 'main', result.text, 0);
-        }
-        this.emit('complete', workDir, task, result);
-      } else {
-        const errorMsg = stderr.trim() || `Process exited with code ${code}`;
-        this.logger.error(`Task "${task.id}" failed in ${workDir}: ${errorMsg}`);
-        if (this.taskLogger) {
-          this.taskLogger.logAnswer(task.project || 'unknown', task.branch || 'main', errorMsg, code);
-        }
-        this.emit('error', workDir, task, errorMsg);
-      }
-    });
-
-    child.on('error', (err) => {
-      clearTimeout(timer);
-      this.activeProcesses.delete(workDir);
-      this.logger.error(`Task "${task.id}" spawn error: ${err.message}`);
-      this.emit('error', workDir, task, err.message);
-    });
-
-    task.pid = child.pid;
-    task.startedAt = new Date().toISOString();
-    task.continueSession = continueSession;
-    this.activeProcesses.set(workDir, { child, timer, task });
-
-    return task;
-  }
-
-  /**
-   * Cancel the active task in a workDir.
-   */
-  cancel (workDir) {
-    this._killProcess(workDir);
-  }
-
-  /**
-   * Check if a task is running in a workDir.
-   */
-  isRunning (workDir) {
-    return this.activeProcesses.has(workDir);
-  }
-
-  /**
-   * Get active task info for a workDir.
-   */
-  getActive (workDir) {
-    const entry = this.activeProcesses.get(workDir);
-    return entry?.task || null;
-  }
-
-  /**
-   * Cancel all active tasks (for graceful shutdown).
-   */
-  cancelAll () {
-    for (const workDir of this.activeProcesses.keys()) {
-      this._killProcess(workDir);
-    }
-  }
-
-  _killProcess (workDir) {
-    const entry = this.activeProcesses.get(workDir);
-    if (!entry) {
-      return;
-    }
-    clearTimeout(entry.timer);
-    try {
-      if (process.platform === 'win32') {
-        spawn('taskkill', ['/PID', String(entry.child.pid), '/T', '/F'], {
-          stdio: 'ignore',
-          windowsHide: true,
-        });
-      } else {
-        entry.child.kill('SIGTERM');
-        setTimeout(() => {
-          try {
-            entry.child.kill('SIGKILL');
-          } catch {
-            // already dead
-          }
-        }, 3000);
-      }
-    } catch {
-      // process already dead
-    }
-    this.activeProcesses.delete(workDir);
-  }
-}