claude-notification-plugin 1.0.78 → 1.0.82

package/.claude-plugin/plugin.json

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

package/README.md

@@ -20,6 +20,8 @@ Cross-platform notifications for Claude Code task completion. Sends alerts to Te
 
 Auto-updates, seamless integration with the plugin ecosystem.
 
+These commands are run in the Claude Code terminal:
+
 ```shell
 /plugin marketplace add Bazilio-san/claude-plugins
 /plugin install claude-notification-plugin@bazilio-plugins
@@ -239,6 +241,26 @@ Alternative for Chat ID: add **@userinfobot** to a chat and it will reply with t
 
 Your remote control for Claude: send a message in Telegram, and the task starts running on your PC. See **[LISTENER.md](LISTENER.md)** for the full guide.
 
+When installed as a plugin, you can manage the listener daemon directly from Claude Code with the `/listener` slash command.
+These commands are run in the Claude Code terminal:
+`/claude-notification-plugin:listener start | stop | status | logs | restart`
+
+## CLI Commands Registration
+
+When installed as a **plugin**, CLI commands (`claude-notify-listener`, etc.) are not in PATH.
+The `/claude-notification-plugin:setup` command registers them automatically by
+placing wrapper scripts next to the `claude` binary.
+
+To manage manually:
+
+```bash
+claude-notify-register            # register CLI commands
+claude-notify-register list       # show registration status
+claude-notify-register unregister # remove CLI commands
+```
+
+When installed via `npm install -g`, npm links the commands itself — no extra step needed.
+
 ## Testing (load without install)
 
 ```bash

package/bin/install.js

@@ -166,6 +166,16 @@ async function main () {
     notifyAfterSeconds: 15,
     notifyOnWaiting: false,
     debug: false,
+    listener: {
+      projects: {},
+      worktreeBaseDir: path.join(home, '.claude', 'worktrees'),
+      autoCreateWorktree: true,
+      taskTimeoutMinutes: 30,
+      maxQueuePerWorkDir: 10,
+      maxTotalTasks: 50,
+      logDir: '',
+      taskLogDir: '',
+    },
   };
 
   // Merge defaults with existing config (user values take priority)

package/bin/listener-cli.js

@@ -9,9 +9,19 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+const DEFAULT_LOG_DIR = path.join(os.homedir(), '.claude');
 const PID_FILE = path.join(os.homedir(), '.claude', '.listener.pid');
-const LOG_FILE = path.join(os.homedir(), '.claude', '.listener.log');
 const CONFIG_FILE = path.join(os.homedir(), '.claude', 'notifier.config.json');
+
+function getLogFile () {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    const logDir = cfg.listener?.logDir || DEFAULT_LOG_DIR;
+    return path.join(logDir, '.cc-n-listener.log');
+  } catch {
+    return path.join(DEFAULT_LOG_DIR, '.cc-n-listener.log');
+  }
+}
 const LISTENER_SCRIPT = path.join(__dirname, '..', 'listener', 'listener.js');
 
 const command = process.argv[2];
@@ -101,10 +111,11 @@ function startDaemon () {
   }
 
   // Ensure log directory exists
-  fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+  const logFile = getLogFile();
+  fs.mkdirSync(path.dirname(logFile), { recursive: true });
 
   // Open log file for child stdio
-  const logFd = fs.openSync(LOG_FILE, 'a');
+  const logFd = fs.openSync(logFile, 'a');
 
   // Spawn detached child
   const child = spawn(process.execPath, [LISTENER_SCRIPT], {
@@ -122,7 +133,7 @@ function startDaemon () {
   fs.writeFileSync(PID_FILE, String(child.pid));
 
   console.log(`Listener started (PID: ${child.pid})`);
-  console.log(`Log: ${LOG_FILE}`);
+  console.log(`Log: ${logFile}`);
   console.log(`Projects: ${Object.keys(config.listener.projects).join(', ')}`);
 }
 
@@ -179,13 +190,14 @@ function showStatus () {
     return;
   }
 
+  const logFile = getLogFile();
   console.log(`Status: running (PID: ${pid})`);
-  console.log(`Log: ${LOG_FILE}`);
+  console.log(`Log: ${logFile}`);
 
   // Show last few log lines
   try {
-    if (fs.existsSync(LOG_FILE)) {
-      const content = fs.readFileSync(LOG_FILE, 'utf-8');
+    if (fs.existsSync(logFile)) {
+      const content = fs.readFileSync(logFile, 'utf-8');
       const lines = content.trim().split('\n');
       const last = lines.slice(-5);
       console.log('\nRecent log:');
@@ -199,12 +211,13 @@ function showStatus () {
 }
 
 function showLogs () {
+  const logFile = getLogFile();
   try {
-    if (!fs.existsSync(LOG_FILE)) {
+    if (!fs.existsSync(logFile)) {
       console.log('No log file found');
       return;
     }
-    const content = fs.readFileSync(LOG_FILE, 'utf-8');
+    const content = fs.readFileSync(logFile, 'utf-8');
     const lines = content.trim().split('\n');
     const last = lines.slice(-50);
     for (const line of last) {

package/bin/register-cli.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PLUGIN_ROOT = path.resolve(__dirname, '..');
+
+const BINS = {
+  'claude-notify-listener': 'bin/listener-cli.js',
+  'claude-notify-install': 'bin/install.js',
+  'claude-notify-uninstall': 'bin/uninstall.js',
+};
+
+function findClaudeDir () {
+  try {
+    const cmd = process.platform === 'win32' ? 'where claude' : 'which claude';
+    const result = execSync(cmd, { encoding: 'utf-8', windowsHide: true }).trim();
+    // 'where' on Windows may return multiple lines
+    const first = result.split('\n')[0].trim();
+    return path.dirname(first);
+  } catch {
+    return null;
+  }
+}
+
+function register () {
+  const claudeDir = findClaudeDir();
+  if (!claudeDir) {
+    console.error('Could not find "claude" in PATH.');
+    console.error('Make sure Claude Code CLI is installed and available.');
+    process.exit(1);
+  }
+
+  const isWindows = process.platform === 'win32';
+  const created = [];
+
+  for (const [name, relPath] of Object.entries(BINS)) {
+    const scriptPath = path.join(PLUGIN_ROOT, relPath);
+
+    if (!fs.existsSync(scriptPath)) {
+      console.warn(`  Skip ${name}: ${scriptPath} not found`);
+      continue;
+    }
+
+    if (isWindows) {
+      const cmdFile = path.join(claudeDir, `${name}.cmd`);
+      const content = `@echo off\r\nnode "${scriptPath}" %*\r\n`;
+      fs.writeFileSync(cmdFile, content);
+      created.push(cmdFile);
+    } else {
+      const shFile = path.join(claudeDir, name);
+      const content = `#!/bin/sh\nexec node "${scriptPath}" "$@"\n`;
+      fs.writeFileSync(shFile, content, { mode: 0o755 });
+      created.push(shFile);
+    }
+  }
+
+  if (created.length > 0) {
+    console.log('Registered CLI commands:');
+    for (const f of created) {
+      console.log(`  ${f}`);
+    }
+  } else {
+    console.log('No commands were registered.');
+  }
+}
+
+function list () {
+  const claudeDir = findClaudeDir();
+  if (!claudeDir) {
+    console.log('Claude CLI not found in PATH.');
+    return;
+  }
+
+  const isWindows = process.platform === 'win32';
+  const ext = isWindows ? '.cmd' : '';
+  let found = 0;
+
+  for (const name of Object.keys(BINS)) {
+    const filePath = path.join(claudeDir, `${name}${ext}`);
+    const exists = fs.existsSync(filePath);
+    console.log(`  ${exists ? '+' : '-'} ${name}${exists ? ` (${filePath})` : ''}`);
+    if (exists) {
+      found++;
+    }
+  }
+
+  console.log('');
+  console.log(`${found}/${Object.keys(BINS).length} commands registered in ${claudeDir}`);
+}
+
+function unregister () {
+  const claudeDir = findClaudeDir();
+  if (!claudeDir) {
+    console.log('Claude CLI not found in PATH — nothing to unregister.');
+    return;
+  }
+
+  const isWindows = process.platform === 'win32';
+  const removed = [];
+
+  for (const name of Object.keys(BINS)) {
+    const ext = isWindows ? '.cmd' : '';
+    const filePath = path.join(claudeDir, `${name}${ext}`);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      removed.push(filePath);
+    }
+  }
+
+  if (removed.length > 0) {
+    console.log('Removed CLI commands:');
+    for (const f of removed) {
+      console.log(`  ${f}`);
+    }
+  } else {
+    console.log('No CLI commands found to remove.');
+  }
+}
+
+const action = process.argv[2];
+
+if (action === 'unregister' || action === 'remove') {
+  unregister();
+} else if (action === 'list' || action === 'status') {
+  list();
+} else if (action === 'register' || !action) {
+  register();
+} else {
+  console.log('Usage: claude-notify-register <register|unregister|list>');
+  console.log('');
+  console.log('Commands:');
+  console.log('  register     Register CLI commands next to claude binary (default)');
+  console.log('  unregister   Remove registered CLI commands');
+  console.log('  list         Show registration status of CLI commands');
+  process.exit(1);
+}

package/bin/uninstall.js

@@ -3,6 +3,7 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import { execSync } from 'child_process';
 
 const home = os.homedir();
 const claudeDir = path.join(home, '.claude');
@@ -46,6 +47,26 @@ for (const file of [configPath, statePath]) {
   }
 }
 
+// Remove CLI wrapper scripts
+const CLI_BINS = ['claude-notify-listener', 'claude-notify-install', 'claude-notify-uninstall'];
+let cliBinsRemoved = false;
+try {
+  const cmd = process.platform === 'win32' ? 'where claude' : 'which claude';
+  const claudeBin = execSync(cmd, { encoding: 'utf-8', windowsHide: true }).trim().split('\n')[0].trim();
+  const claudeBinDir = path.dirname(claudeBin);
+  const ext = process.platform === 'win32' ? '.cmd' : '';
+
+  for (const name of CLI_BINS) {
+    const filePath = path.join(claudeBinDir, `${name}${ext}`);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      cliBinsRemoved = true;
+    }
+  }
+} catch {
+  // claude not in PATH — nothing to remove
+}
+
 // Remove plugin cache (old versions left by Claude Code)
 const pluginCacheDir = path.join(claudeDir, 'plugins', 'cache', 'bazilio-plugins', 'claude-notification-plugin');
 let cacheRemoved = false;
@@ -61,4 +82,7 @@ console.log('Config files deleted.');
 if (cacheRemoved) {
   console.log('Plugin cache cleaned.');
 }
+if (cliBinsRemoved) {
+  console.log('CLI wrapper scripts removed.');
+}
 console.log('');

package/commands/setup.md

@@ -38,7 +38,15 @@ Help the user configure the notification plugin. The config file is `~/.claude/n
    }
    ```
 
-5. **Confirm** — show the user a summary of what was saved.
+5. **Register CLI commands** — so that `claude-notify-listener`, `claude-notify-install`, and `claude-notify-uninstall` are available from the terminal (not just inside Claude).
+
+   Run in a shell:
+   ```bash
+   node "${CLAUDE_PLUGIN_ROOT}/bin/register-cli.js"
+   ```
+   This finds the directory where `claude` is installed and creates wrapper scripts there. Show the output to the user. If registration fails (e.g. `claude` not in PATH), inform the user but do NOT treat it as a fatal error — the rest of setup is still valid.
+
+6. **Confirm** — show the user a summary of what was saved.
 
 ## Important
 

package/listener/LISTENER-DETAILED.md

@@ -201,7 +201,8 @@ Running two listeners is impossible — the PID file prevents it. And this is im
 | **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 |
 | **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 log to `~/.claude/.listener.log`. Rotation when exceeding 5 MB (old file → `.log.old`) |
+| **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 |
 
 ---
 
@@ -304,7 +305,9 @@ Full example of `~/.claude/notifier.config.json` with the listener section:
     "autoCreateWorktree": true,
     "taskTimeoutMinutes": 30,
     "maxQueuePerWorkDir": 10,
-    "maxTotalTasks": 50
+    "maxTotalTasks": 50,
+    "logDir": "~/.claude",
+    "taskLogDir": "~/.claude"
   }
 }
 ```
@@ -319,6 +322,8 @@ Full example of `~/.claude/notifier.config.json` with the listener section:
 | `taskTimeoutMinutes` | `30` | Maximum task execution time in minutes. Force-stopped when exceeded |
 | `maxQueuePerWorkDir` | `10` | Maximum tasks in the queue for a single working directory |
 | `maxTotalTasks` | `50` | Maximum tasks across all queues combined |
+| `logDir` | `~/.claude` | Directory for the listener operational log (`.cc-n-listener.log`) |
+| `taskLogDir` | same as `logDir` | Directory for task Q&A logs (`.cc-n-task-*.log`). Each project/branch gets its own file |
 
 ### What is `projects`?
 
@@ -392,7 +397,7 @@ If the worktree doesn't exist, it will be created automatically.
 5. When Claude finishes → sends the result to Telegram
 6. If there's a next task in the queue → starts it
 
----
+---RFr 
 
 ## Projects and worktrees
 
@@ -750,6 +755,44 @@ Handling long responses:
 
 ---
 
+## Logs
+
+The listener writes two types of logs:
+
+### Listener log (operational)
+
+Internal events: startup, incoming messages, task lifecycle, errors.
+**Does NOT contain** Claude's questions and answers.
+
+Default path: `~/.claude/.cc-n-listener.log`
+Customizable via `listener.logDir` in config.
+Rotation: 5 MB (old file → `.log.old`).
+
+### Task logs (Q&A with Claude)
+
+Each project/branch gets its own log file with full questions sent to Claude and answers received.
+
+Default directory: same as `listener.logDir` (i.e. `~/.claude/`)
+Customizable via `listener.taskLogDir` in config.
+Filename pattern: `.cc-n-task-<project>[_<branch>].log`
+Rotation: 5 MB per file (old file → `.log.old`).
+
+Each entry includes a timestamp, working directory, task text (question), and Claude's full response (answer).
+
+Example config to customize both log directories:
+
+```json
+{
+  "listener": {
+    "logDir": "/var/log/claude-listener",
+    "taskLogDir": "/var/log/claude-listener/tasks",
+    "projects": { ... }
+  }
+}
+```
+
+---
+
 ## State files
 
 All files are stored in `~/.claude/`:
@@ -757,7 +800,8 @@ All files are stored in `~/.claude/`:
 | File | Description |
 |---|---|
 | `.listener.pid` | PID of the running daemon. On `start`, it checks whether the process is alive |
-| `.listener.log` | Operation log. Rotation when exceeding 5 MB (old file → `.log.old`) |
+| `.cc-n-listener.log` | Operational log. Rotation when exceeding 5 MB (old file → `.log.old`) |
+| `.cc-n-task-*.log` | Task Q&A logs, one per project/branch. Rotation at 5 MB each |
 | `.task_queues.json` | Current state of all queues. Persisted to disk after every change |
 | `.task_history.json` | Last 50 completed tasks (for `/history`) |
 

package/listener/listener.js

@@ -5,6 +5,7 @@ import os from 'os';
 import path from 'path';
 import process from 'process';
 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';
@@ -16,7 +17,7 @@ import { parseMessage, parseTarget } from './message-parser.js';
 // ----------------------
 
 const CONFIG_PATH = path.join(os.homedir(), '.claude', 'notifier.config.json');
-const LOG_PATH = path.join(os.homedir(), '.claude', '.listener.log');
+const DEFAULT_LOG_DIR = path.join(os.homedir(), '.claude');
 
 function loadConfig () {
   try {
@@ -33,7 +34,9 @@ function loadConfig () {
 // ----------------------
 
 const config = loadConfig();
-const logger = createLogger(LOG_PATH);
+const listenerLogDir = config.listener?.logDir || DEFAULT_LOG_DIR;
+fs.mkdirSync(listenerLogDir, { recursive: true });
+const logger = createLogger(path.join(listenerLogDir, '.cc-n-listener.log'));
 
 // Validate required fields
 const token = process.env.CLAUDE_NOTIFY_TELEGRAM_TOKEN || config.telegramToken || config.telegram?.token;
@@ -61,7 +64,10 @@ const queue = new WorkQueue(
   listenerConfig.maxQueuePerWorkDir || 10,
   listenerConfig.maxTotalTasks || 50,
 );
-const runner = new TaskRunner(logger, taskTimeout);
+const taskLogDir = config.listener?.taskLogDir || listenerLogDir;
+fs.mkdirSync(taskLogDir, { recursive: true });
+const taskLogger = createTaskLogger(taskLogDir);
+const runner = new TaskRunner(logger, taskTimeout, taskLogger);
 const worktreeManager = new WorktreeManager(config, logger);
 
 const startTime = Date.now();
@@ -96,24 +102,35 @@ runner.on('complete', async (workDir, task, output) => {
   const entry = queue.queues[workDir];
   const label = formatLabel(entry);
 
-  // Send result
-  let text = `✅ [${label}] Done: ${escapeHtml(task.text)}`;
+  // Delete the "Running" message
+  await poller.deleteMessage(task.runningMessageId);
+
+  // Build result: try replying to user's original message without duplicating the task text.
+  // If reply fails (user deleted their message), resend with task text included.
+  const headerShort = `✅ [${label}] Done:`;
+  const headerFull = `✅ [${label}] Done: ${escapeHtml(task.text)}`;
+  let body = '';
   if (output) {
     if (output.length > 20000) {
       const head = output.slice(0, 2000);
       const tail = output.slice(-2000);
-      text += `\n\n<pre>${escapeHtml(head)}\n\n... (${output.length} chars) ...\n\n${escapeHtml(tail)}</pre>`;
-      // Also send as file
+      body = `\n\n<pre>${escapeHtml(head)}\n\n... (${output.length} chars) ...\n\n${escapeHtml(tail)}</pre>`;
       await poller.sendDocument(
         Buffer.from(output, 'utf-8'),
         `result_${task.id}.txt`,
         `Full output for: ${task.text.slice(0, 100)}`
       );
     } else {
-      text += `\n\n<pre>${escapeHtml(output)}</pre>`;
+      body = `\n\n<pre>${escapeHtml(output)}</pre>`;
     }
   }
-  await poller.sendMessage(text, task.telegramMessageId);
+
+  // Try reply to original message (short header, task text visible in quote)
+  const sentId = await poller.sendMessage(headerShort + body, task.telegramMessageId);
+  if (!sentId && task.telegramMessageId) {
+    // Reply failed — original message was deleted, send without reply but with full task text
+    await poller.sendMessage(headerFull + body);
+  }
 
   // Process next in queue
   const next = queue.onTaskComplete(workDir, output);
@@ -125,10 +142,14 @@ runner.on('complete', async (workDir, task, output) => {
 runner.on('error', async (workDir, task, errorMsg) => {
   const entry = queue.queues[workDir];
   const label = formatLabel(entry);
-  await poller.sendMessage(
-    `❌ [${label}] Error: ${escapeHtml(task.text)}\n\n<pre>${escapeHtml(errorMsg)}</pre>`,
-    task.telegramMessageId,
-  );
+
+  await poller.deleteMessage(task.runningMessageId);
+
+  const body = `\n\n<pre>${escapeHtml(errorMsg)}</pre>`;
+  const sentId = await poller.sendMessage(`❌ [${label}] Error:${body}`, task.telegramMessageId);
+  if (!sentId && task.telegramMessageId) {
+    await poller.sendMessage(`❌ [${label}] Error: ${escapeHtml(task.text)}${body}`);
+  }
 
   const next = queue.onTaskComplete(workDir, `ERROR: ${errorMsg}`);
   if (next) {
@@ -139,10 +160,16 @@ runner.on('error', async (workDir, task, errorMsg) => {
 runner.on('timeout', async (workDir, task) => {
   const entry = queue.queues[workDir];
   const label = formatLabel(entry);
-  await poller.sendMessage(
-    `⏰ [${label}] Task forcefully stopped — timeout exceeded (${Math.round(taskTimeout / 60000)} min): ${escapeHtml(task.text)}`,
-    task.telegramMessageId,
-  );
+  const timeoutMin = Math.round(taskTimeout / 60000);
+
+  await poller.deleteMessage(task.runningMessageId);
+
+  const headerShort = `⏰ [${label}] Task forcefully stopped — timeout exceeded (${timeoutMin} min)`;
+  const headerFull = `${headerShort}: ${escapeHtml(task.text)}`;
+  const sentId = await poller.sendMessage(headerShort, task.telegramMessageId);
+  if (!sentId && task.telegramMessageId) {
+    await poller.sendMessage(headerFull);
+  }
 
   const next = queue.onTaskComplete(workDir, 'TIMEOUT');
   if (next) {
@@ -164,10 +191,11 @@ function formatLabel (entry) {
   return `@${entry.project}`;
 }
 
-function startTask (workDir, task) {
+async function startTask (workDir, task) {
   const entry = queue.queues[workDir];
   const label = formatLabel(entry);
-  poller.sendMessage(`⏳ [${label}] Running: ${escapeHtml(task.text)}`, task.telegramMessageId);
+  const runningMsgId = await poller.sendMessage(`⏳ [${label}] Running: ${escapeHtml(task.text)}`, task.telegramMessageId);
+  task.runningMessageId = runningMsgId;
   try {
     const started = runner.run(workDir, task);
     queue.markStarted(workDir, started.pid);

package/listener/task-logger.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+
+const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB
+
+function sanitize (str) {
+  return str.replace(/[/\\:*?"<>|\s]+/g, '_').replace(/^_+|_+$/g, '');
+}
+
+function rotateIfNeeded (filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (stat.size > MAX_LOG_SIZE) {
+      const backup = filePath + '.old';
+      if (fs.existsSync(backup)) {
+        fs.unlinkSync(backup);
+      }
+      fs.renameSync(filePath, backup);
+    }
+  } catch {
+    // file doesn't exist yet
+  }
+}
+
+/**
+ * Creates a task logger that writes Q&A logs for Claude tasks.
+ * Each project/branch combo gets its own log file.
+ *
+ * @param {string} logDir - Directory for task log files
+ */
+export function createTaskLogger (logDir) {
+  fs.mkdirSync(logDir, { recursive: true });
+
+  function getLogPath (project, branch) {
+    const parts = [project];
+    if (branch && branch !== 'main' && branch !== 'master') {
+      parts.push(branch);
+    }
+    const name = `.cc-n-task-${sanitize(parts.join('_'))}.log`;
+    return path.join(logDir, name);
+  }
+
+  return {
+    logQuestion (project, branch, workDir, taskText) {
+      const logPath = getLogPath(project, branch);
+      rotateIfNeeded(logPath);
+      const ts = new Date().toISOString();
+      const entry = `\n${'='.repeat(80)}\n`
+        + `[${ts}] QUESTION\n`
+        + `Project: @${project}${branch && branch !== 'main' && branch !== 'master' ? '/' + branch : ''}\n`
+        + `WorkDir: ${workDir}\n`
+        + `Task: ${taskText}\n`;
+      fs.appendFileSync(logPath, entry);
+    },
+
+    logAnswer (project, branch, output, exitCode) {
+      const logPath = getLogPath(project, branch);
+      rotateIfNeeded(logPath);
+      const ts = new Date().toISOString();
+      const status = exitCode === 0 ? 'OK' : `ERROR (code ${exitCode})`;
+      const entry = `[${ts}] ANSWER [${status}]\n`
+        + `${output || '(no output)'}\n`;
+      fs.appendFileSync(logPath, entry);
+    },
+  };
+}

package/listener/task-runner.js

@@ -9,10 +9,11 @@ const DEFAULT_TIMEOUT = 600_000; // 10 minutes
  * Runs claude CLI tasks and emits events on completion.
  */
 export class TaskRunner extends EventEmitter {
-  constructor (logger, timeout) {
+  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 }
   }
 
@@ -28,6 +29,9 @@ export class TaskRunner extends EventEmitter {
     }
 
     this.logger.info(`Running task "${task.text}" in ${workDir}`);
+    if (this.taskLogger) {
+      this.taskLogger.logQuestion(task.project || 'unknown', task.branch || 'main', workDir, task.text);
+    }
 
     const args = ['-p', task.text, '--output-format', 'text'];
     const child = spawn('claude', args, {
@@ -66,10 +70,16 @@ export class TaskRunner extends EventEmitter {
 
       if (code === 0) {
         this.logger.info(`Task "${task.id}" completed in ${workDir}`);
+        if (this.taskLogger) {
+          this.taskLogger.logAnswer(task.project || 'unknown', task.branch || 'main', stdout.trim(), 0);
+        }
         this.emit('complete', workDir, task, stdout.trim());
       } 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);
       }
     });

package/listener/telegram-poller.js

@@ -50,6 +50,7 @@ export class TelegramPoller {
 
   async sendMessage (text, replyToMessageId) {
     const chunks = splitMessage(text);
+    let firstMessageId = null;
     for (const chunk of chunks) {
       try {
         const body = {
@@ -68,7 +69,7 @@ export class TelegramPoller {
         const data = await res.json();
         if (!data.ok) {
           // Retry without HTML parse mode
-          await fetch(`${this.baseUrl}/sendMessage`, {
+          const res2 = await fetch(`${this.baseUrl}/sendMessage`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
@@ -77,11 +78,36 @@ export class TelegramPoller {
               ...(replyToMessageId ? { reply_to_message_id: replyToMessageId } : {}),
             }),
           });
+          const data2 = await res2.json();
+          if (data2.ok && !firstMessageId) {
+            firstMessageId = data2.result.message_id;
+          }
+        } else if (!firstMessageId) {
+          firstMessageId = data.result.message_id;
         }
       } catch (err) {
         this.logger.error(`sendMessage error: ${err.message}`);
       }
     }
+    return firstMessageId;
+  }
+
+  async deleteMessage (messageId) {
+    if (!messageId) {
+      return;
+    }
+    try {
+      await fetch(`${this.baseUrl}/deleteMessage`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          chat_id: this.chatId,
+          message_id: messageId,
+        }),
+      });
+    } catch (err) {
+      this.logger.error(`deleteMessage error: ${err.message}`);
+    }
   }
 
   async sendDocument (buffer, filename, caption) {

package/listener/work-queue.js

@@ -54,6 +54,8 @@ export class WorkQueue {
     const task = {
       id: generateId(),
       text,
+      project,
+      branch: branch || 'main',
       telegramMessageId,
       addedAt: new Date().toISOString(),
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-notification-plugin",
   "productName": "claude-notification-plugin",
-  "version": "1.0.78",
+  "version": "1.0.82",
   "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
   "type": "module",
   "engines": {
@@ -21,7 +21,8 @@
     "claude-notify-install": "bin/install.js",
     "claude-notify-uninstall": "bin/uninstall.js",
     "claude-notifier": "notifier/notifier.js",
-    "claude-notify-listener": "bin/listener-cli.js"
+    "claude-notify-listener": "bin/listener-cli.js",
+    "claude-notify-register": "bin/register-cli.js"
   },
   "scripts": {
     "lint": "eslint .",