claude-notification-plugin 1.1.101 → 1.1.104

package/.claude-plugin/plugin.json

@@ -1,20 +1,20 @@
-{
-  "name": "claude-notification-plugin",
-  "version": "1.1.101",
-  "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
-  "author": {
-    "name": "Viacheslav Makarov",
-    "email": "npmjs@bazilio.ru"
-  },
-  "homepage": "https://github.com/Bazilio-san/claude-notification-plugin#readme",
-  "repository": "https://github.com/Bazilio-san/claude-notification-plugin",
-  "license": "MIT",
-  "keywords": [
-    "notification",
-    "telegram",
-    "windows",
-    "sound",
-    "voice",
-    "hooks"
-  ]
-}
+{
+  "name": "claude-notification-plugin",
+  "version": "1.1.104",
+  "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
+  "author": {
+    "name": "Viacheslav Makarov",
+    "email": "npmjs@bazilio.ru"
+  },
+  "homepage": "https://github.com/Bazilio-san/claude-notification-plugin#readme",
+  "repository": "https://github.com/Bazilio-san/claude-notification-plugin",
+  "license": "MIT",
+  "keywords": [
+    "notification",
+    "telegram",
+    "windows",
+    "sound",
+    "voice",
+    "hooks"
+  ]
+}

package/README.md

@@ -329,7 +329,7 @@ the same path cannot be registered twice under different aliases.
 | `projects`           | (required)            | Map of projects: `alias → { path }`                                                    |
 | `claudeArgs`         | `[]`                  | Extra CLI args for Claude (e.g. `["--permission-mode", "auto"]`)                       |
 | `continueSession`    | `true`                | Keep the PTY alive between Telegram tasks so subsequent tasks reuse the same live Claude session |
-| `resumeLastSession`  | `true`                | When spawning a fresh PTY, add `--continue` so Claude picks up the most recent JSONL in the workDir (bridges laptop CC session ↔ Telegram listener) |
+| `resumeLastSession`  | `true`                | When spawning a fresh PTY, resume the exact session whose ID the daemon captured from SessionStart (stored in `~/.claude/.session_state.json`). Survives listener restart. Falls back to a fresh session if no captured ID is available — does NOT use `--continue` blindly. |
 | `sessionsListLimit`  | `5`                   | How many most-recent sessions `/sessions` shows                                        |
 | `sessionWorkingThresholdSec` | `2`           | A locked JSONL with mtime ≤ this many seconds is considered actively writing (status `working`, resume disabled) |
 | `worktreeBaseDir`    | `~/.claude/worktrees` | Where auto-created worktrees are stored                                                |

package/commit-sha

@@ -1 +1 @@
-dd4f19294dff2f485865d9526ff5d9a749e36a8a
+6fb63d8cf4e4026a2909a47213b4303438712d8f

package/listener/listener.js

@@ -25,6 +25,11 @@ import {
 import { JsonlReader, resolveJsonlPath, resolveJsonlByMtime, cwdToProjectDir } from './jsonl-reader.js';
 import { listSessions } from './session-list.js';
 import { findLocking, killPid } from './file-locks.js';
+import {
+  getStoredSessionId,
+  setStoredSessionId,
+  clearStoredSessionId,
+} from './session-state.js';
 
 // ----------------------
 // CRASH PROTECTION
@@ -138,7 +143,25 @@ const taskLogDir = config.listener?.taskLogDir || listenerLogDir;
 fs.mkdirSync(taskLogDir, { recursive: true });
 const taskLogger = createTaskLogger(taskLogDir);
 
-const runner = new PtyRunner(logger, taskTimeout, taskLogger, taskLogDir);
+// Pass workDirs with in-flight active tasks so PtyRunner's startup cleanup
+// preserves their signal files instead of nuking the Stop hooks that fired
+// while the daemon was down.
+const activeWorkDirsOnBoot = Object.entries(queue.queues)
+  .filter(([, entry]) => entry?.active)
+  .map(([workDir]) => workDir);
+const runner = new PtyRunner(logger, taskTimeout, taskLogger, taskLogDir, activeWorkDirsOnBoot);
+
+// Capture Claude's real sessionId as soon as SessionStart fires, and persist it.
+// This is what lets the next task (or the daemon after a restart) launch with
+// `claude --resume <sid>` and continue *this exact* session — instead of
+// `--continue` picking whichever JSONL happens to have the freshest mtime.
+runner.on('ready', (workDir) => {
+  const sid = runner.getSessionId(workDir);
+  if (sid) {
+    setStoredSessionId(workDir, sid);
+    logger.info(`Captured sessionId for ${workDir}: ${sid}`);
+  }
+});
 
 const worktreeManager = new WorktreeManager(config, logger);
 
@@ -211,6 +234,41 @@ async function runWatchdog () {
   }
 }
 
+// 0. Migrate queue entries whose `project` alias no longer matches the config
+// (e.g. user renamed `mail` → `me`). Without this, /status, /cancel, and
+// completion notifications keep referring to the old alias even though the
+// workDir is unchanged.
+{
+  let migrated = 0;
+  for (const [workDir, entry] of Object.entries(queue.queues)) {
+    if (!entry) {
+      continue;
+    }
+    const normalizedWd = normalizeForCompare(workDir);
+    for (const [alias, proj] of Object.entries(listenerConfig.projects)) {
+      const projPath = typeof proj === 'string' ? proj : proj?.path;
+      if (!projPath || normalizeForCompare(projPath) !== normalizedWd) {
+        continue;
+      }
+      if (entry.project !== alias) {
+        logger.info(`Migrating queue alias for ${workDir}: ${entry.project} → ${alias}`);
+        entry.project = alias;
+        if (entry.active) {
+          entry.active.project = alias;
+        }
+        for (const t of entry.queue || []) {
+          t.project = alias;
+        }
+        migrated++;
+      }
+      break;
+    }
+  }
+  if (migrated > 0) {
+    queue._save();
+  }
+}
+
 // 1. Initial watchdog sweep on startup. Must finish before orphan recovery,
 // otherwise orphan recovery sees the stale active (still set) and re-spawns
 // the killed task while watchdog is still awaiting its Telegram notify.
@@ -268,6 +326,11 @@ async function notifyTaskCompletion (workDir, task, kind, payload = {}) {
       session.lastContextPct = Math.round((payload.totalTokens / payload.contextWindow) * 100);
     }
     sessions.set(workDir, session);
+    // Persist the sessionId so the next task — including across a listener
+    // restart — can resume this exact session via --resume <sid>.
+    if (payload.sessionId) {
+      setStoredSessionId(workDir, payload.sessionId);
+    }
 
     const parts = [];
     if (task.continueSession) {
@@ -369,19 +432,15 @@ function getClaudeArgs (projectAlias) {
   return projectArgs.length > 0 ? projectArgs : globalClaudeArgs;
 }
 
-function hasAnyJsonl (workDir) {
-  const dirName = cwdToProjectDir(workDir);
-  const dirPath = path.join(CLAUDE_DIR, 'projects', dirName);
-  try {
-    return fs.readdirSync(dirPath).some(f => f.endsWith('.jsonl'));
-  } catch {
-    return false;
-  }
-}
-
 // Decide whether to add --continue or --resume <id> to claudeArgs for a fresh PTY.
 // Priority: explicit caller flag > pending /resume <sid> > /newsession opt-out >
-// global resumeLastSession default. If reusing an idle PTY, claudeArgs are ignored anyway.
+// persisted sessionId for this workDir > global resumeLastSession default.
+//
+// The persisted-sessionId branch is what makes "continue across listener
+// restart" deterministic: we resume the exact session whose ID we captured
+// from SessionStart, instead of letting --continue pick the most-recently-
+// modified JSONL — which may belong to a different turn or branch.
+// If reusing an idle PTY, claudeArgs are ignored anyway.
 function applyResumeArgs (claudeArgs, workDir) {
   if (claudeArgs.includes('--continue') || claudeArgs.includes('--resume')) {
     return claudeArgs;
@@ -397,8 +456,21 @@ function applyResumeArgs (claudeArgs, workDir) {
     freshSessionDirs.delete(workDir);
     return claudeArgs;
   }
-  if (resumeLastSessionEnabled && hasAnyJsonl(workDir)) {
-    return [...claudeArgs, '--continue'];
+  if (resumeLastSessionEnabled) {
+    const storedSid = getStoredSessionId(workDir);
+    if (storedSid) {
+      const dirName = cwdToProjectDir(workDir);
+      const jsonlPath = path.join(CLAUDE_DIR, 'projects', dirName, `${storedSid}.jsonl`);
+      if (fs.existsSync(jsonlPath)) {
+        return [...claudeArgs, '--resume', storedSid];
+      }
+      // Stale entry — JSONL was deleted/moved. Drop the stored sid so we
+      // don't keep retrying a dead session.
+      clearStoredSessionId(workDir);
+      logger.warn(`Stored sessionId ${storedSid} for ${workDir} has no JSONL — cleared`);
+    }
+    // No reliable sid → start fresh instead of falling back to the old
+    // mtime-based --continue lottery.
   }
   return claudeArgs;
 }
@@ -839,6 +911,7 @@ function handleClear (args) {
   // Also reset session
   sessions.delete(workDir);
   freshSessionDirs.add(workDir);
+  clearStoredSessionId(workDir);
   logger.info(`Session reset for ${workDir} via /clear`);
 
   return `🧹 [${escapeHtml(label)}] Queue cleared (${count} tasks), session reset`;
@@ -898,6 +971,7 @@ function handleNewSession (args) {
 
   sessions.delete(workDir);
   freshSessionDirs.add(workDir);
+  clearStoredSessionId(workDir);
   logger.info(`Session reset for ${workDir} via /newsession`);
 
   if (session) {

package/listener/pty-runner.js

@@ -10,6 +10,13 @@ const DEFAULT_TIMEOUT = 600_000; // 10 minutes
 // Built-in slash-commands (forwarded via %cmd) rarely emit a Stop hook event,
 // so we fall back to "done" after this much buffer inactivity.
 const RAW_INACTIVITY_MS = 8_000;
+// Fallback for tasks where the Stop hook silently doesn't fire (e.g. resumed
+// sessions on Windows ConPTY): if the PTY buffer goes quiet AND its tail shows
+// Claude's idle status bar, treat the task as complete.
+const IDLE_PROMPT_FALLBACK_MS = 60_000;
+// Status-bar marker shown by Claude when it's idle at the prompt. Covers
+// "bypass permissions on", "accept edits on", "default mode" etc.
+const IDLE_PROMPT_RE = /\b(?:bypass permissions on|accept edits on|default mode|plan mode)\b/i;
 
 /**
  * PTY-based runner for Claude Code.
@@ -17,12 +24,19 @@ const RAW_INACTIVITY_MS = 8_000;
  * receives completion signals via marker files written by the notifier hook.
  */
 export class PtyRunner extends EventEmitter {
-  constructor (logger, timeout, taskLogger, ptyLogDir) {
+  constructor (logger, timeout, taskLogger, ptyLogDir, activeWorkDirs) {
     super();
     this.logger = logger;
     this.timeout = timeout || DEFAULT_TIMEOUT;
     this.taskLogger = taskLogger || null;
     this.ptyLogDir = ptyLogDir || null;
+    // Set of normalized workDir paths whose orphan tasks are about to be
+    // re-started by listener startup logic. Their pending signal files (if any)
+    // must be preserved through the cleanup phase, otherwise we lose hook
+    // events the daemon never saw because it wasn't running yet.
+    this._preserveSignalsForWorkDirs = new Set(
+      (activeWorkDirs || []).map((wd) => this._normalizePath(wd))
+    );
     // workDir -> { pty, state, currentTask, sessionId, workDir, _pendingId, _buffer, _logStream }
     this.sessions = new Map();
     this.pendingMarkers = new Map(); // pendingId -> resolve callback
@@ -50,17 +64,36 @@ export class PtyRunner extends EventEmitter {
       // ignore
     }
 
-    // Clean up stale marker files on startup
+    // Clean up stale marker files on startup, but preserve any whose `cwd`
+    // matches a workDir with an in-flight orphan task — those signals were
+    // written by Claude while the daemon was down and are the only way to
+    // notice that the task already finished.
     try {
       const files = fs.readdirSync(PTY_SIGNAL_DIR);
       for (const f of files) {
-        if (f.endsWith('.json')) {
+        if (!f.endsWith('.json')) {
+          continue;
+        }
+        const filePath = path.join(PTY_SIGNAL_DIR, f);
+        let preserve = false;
+        if (this._preserveSignalsForWorkDirs.size > 0) {
           try {
-            fs.unlinkSync(path.join(PTY_SIGNAL_DIR, f));
+            const marker = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            if (marker?.cwd && this._preserveSignalsForWorkDirs.has(this._normalizePath(marker.cwd))) {
+              preserve = true;
+            }
           } catch {
-            // ignore
+            // unreadable — fall through and delete
           }
         }
+        if (preserve) {
+          continue;
+        }
+        try {
+          fs.unlinkSync(filePath);
+        } catch {
+          // ignore
+        }
       }
     } catch {
       // ignore
@@ -222,7 +255,33 @@ export class PtyRunner extends EventEmitter {
       const CHECK_INTERVAL = 5000;
       const checker = setInterval(() => {
         const lastActivity = session?._lastActivityTime || 0;
-        if (lastActivity > 0 && Date.now() - lastActivity > inactivityMs) {
+        const idleMs = lastActivity > 0 ? Date.now() - lastActivity : 0;
+
+        // Idle-prompt fallback: PTY went quiet AND its tail shows Claude's
+        // idle status bar — treat as completed even if the Stop hook never
+        // produced a signal (happens with resumed sessions on Windows ConPTY).
+        if (idleMs > IDLE_PROMPT_FALLBACK_MS && session) {
+          const tailRaw = (session._buffer || '').slice(-3000);
+          const tailClean = cleanPtyOutput(tailRaw);
+          if (IDLE_PROMPT_RE.test(tailClean)) {
+            clearInterval(checker);
+            this.pendingMarkers.delete(pendingId);
+            const fullClean = cleanPtyOutput(session._buffer || '').trim();
+            const text = fullClean.length > 2000 ? fullClean.slice(-2000) : fullClean;
+            this.logger.warn(`PTY idle-prompt fallback completion in ${session.workDir} (no Stop signal in ${Math.round(idleMs / 1000)}s)`);
+            resolve({
+              lastAssistantMessage: text,
+              sessionId: session.sessionId || null,
+              cost: 0,
+              numTurns: 0,
+              durationMs: idleMs,
+              isIdleFallback: true,
+            });
+            return;
+          }
+        }
+
+        if (lastActivity > 0 && idleMs > inactivityMs) {
           clearInterval(checker);
           this.pendingMarkers.delete(pendingId);
           reject(new Error('Marker timeout'));

package/listener/session-state.js

@@ -0,0 +1,73 @@
+// Persistent map of workDir → last known Claude sessionId.
+// Survives listener restarts so the next task in a workDir can be launched
+// with `claude --resume <sid>` and continue exactly the session that was
+// running before the restart, instead of `--continue` blindly picking the
+// most-recently-modified JSONL (which may belong to a completed turn, a
+// different branch, or a manually-opened terminal in the same project dir).
+
+import fs from 'fs';
+import path from 'path';
+import { CLAUDE_DIR, normalizeForCompare } from '../bin/constants.js';
+
+const SESSION_STATE_PATH = path.join(CLAUDE_DIR, '.session_state.json');
+
+function readState () {
+  try {
+    const raw = fs.readFileSync(SESSION_STATE_PATH, 'utf-8');
+    const data = JSON.parse(raw);
+    return data && typeof data === 'object' ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeState (state) {
+  try {
+    fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+    const tmp = `${SESSION_STATE_PATH}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
+    fs.renameSync(tmp, SESSION_STATE_PATH);
+  } catch {
+    // best-effort; never throw
+  }
+}
+
+function keyFor (workDir) {
+  return normalizeForCompare(workDir);
+}
+
+export function getStoredSessionId (workDir) {
+  if (!workDir) {
+    return null;
+  }
+  const state = readState();
+  const entry = state[keyFor(workDir)];
+  return entry?.sessionId || null;
+}
+
+export function setStoredSessionId (workDir, sessionId) {
+  if (!workDir || !sessionId) {
+    return;
+  }
+  const state = readState();
+  state[keyFor(workDir)] = {
+    sessionId,
+    updatedAt: new Date().toISOString(),
+    workDir,
+  };
+  writeState(state);
+}
+
+export function clearStoredSessionId (workDir) {
+  if (!workDir) {
+    return;
+  }
+  const state = readState();
+  const k = keyFor(workDir);
+  if (k in state) {
+    delete state[k];
+    writeState(state);
+  }
+}
+
+export { SESSION_STATE_PATH };

package/package.json

@@ -1,65 +1,65 @@
-{
-  "name": "claude-notification-plugin",
-  "productName": "claude-notification-plugin",
-  "version": "1.1.101",
-  "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
-  "type": "module",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "files": [
-    ".claude-plugin/",
-    "bin/",
-    "claude_img/claude.png",
-    "hooks/",
-    "listener/",
-    "notifier/",
-    "commit-sha",
-    "README.md",
-    "LICENSE"
-  ],
-  "bin": {
-    "claude-notify": "bin/cli.js"
-  },
-  "scripts": {
-    "prepack": "git rev-parse HEAD > commit-sha",
-    "postinstall": "node bin/install.js",
-    "lint": "eslint .",
-    "lint:fix": "eslint --fix .",
-    "listener:restart": "claude-notify listener restart",
-    "listener:stop": "claude-notify listener stop",
-    "listener:start": "claude-notify listener start",
-    "listener:status": "claude-notify listener status"
-  },
-  "keywords": [
-    "claude",
-    "claude-code",
-    "notifications",
-    "telegram",
-    "hooks",
-    "macos",
-    "linux",
-    "cross-platform"
-  ],
-  "author": {
-    "name": "Viacheslav Makarov",
-    "email": "npmjs@bazilio.ru"
-  },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Bazilio-san/claude-notification-plugin.git"
-  },
-  "homepage": "https://github.com/Bazilio-san/claude-notification-plugin#readme",
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "node-notifier": "^10.0.1",
-    "node-pty": "^1.1.0"
-  },
-  "devDependencies": {
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-unused-imports": "^4.4.1"
-  }
-}
+{
+  "name": "claude-notification-plugin",
+  "productName": "claude-notification-plugin",
+  "version": "1.1.104",
+  "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    ".claude-plugin/",
+    "bin/",
+    "claude_img/claude.png",
+    "hooks/",
+    "listener/",
+    "notifier/",
+    "commit-sha",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "claude-notify": "bin/cli.js"
+  },
+  "scripts": {
+    "prepack": "git rev-parse HEAD > commit-sha",
+    "postinstall": "node bin/install.js",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "listener:restart": "claude-notify listener restart",
+    "listener:stop": "claude-notify listener stop",
+    "listener:start": "claude-notify listener start",
+    "listener:status": "claude-notify listener status"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "notifications",
+    "telegram",
+    "hooks",
+    "macos",
+    "linux",
+    "cross-platform"
+  ],
+  "author": {
+    "name": "Viacheslav Makarov",
+    "email": "npmjs@bazilio.ru"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bazilio-san/claude-notification-plugin.git"
+  },
+  "homepage": "https://github.com/Bazilio-san/claude-notification-plugin#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "node-notifier": "^10.0.1",
+    "node-pty": "^1.1.0"
+  },
+  "devDependencies": {
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-unused-imports": "^4.4.1"
+  }
+}