memex-mvp 0.10.2 → 0.10.6

package/HELP.md

@@ -331,6 +331,9 @@ memex telegram allow "Family"                      # auto-import на следу
 memex telegram block "*bank*"                      # никогда не индексировать (glob)
 memex telegram mode auto                           # pick (default) / auto / manual
 memex telegram notifications on --show-titles      # macOS notif когда детектится новый export
+memex telegram notifications target claude-cli     # клик по баннеру → откроет Claude Code CLI
+memex telegram open-pending                        # открыть pending в лучшем доступном клиенте
+memex telegram open-pending --in terminal          # forcefully в Terminal с командой
 memex telegram scan                                # one-shot ре-скан Downloads
 memex telegram status                              # all decisions
 

package/README.md

@@ -206,7 +206,7 @@ Terminal equivalents: `memex telegram check / pending / import 1 3 5 / skip 2 /
 
 1. **In the AI agent (active session)** — `memex_search` / `memex_recent` / `memex_overview` tool responses include a `telegram_pending` field with chat names. Agent surfaces it as a natural aside.
 2. **In the terminal** — any `memex` CLI command appends a 💡 tip line when pending > 0. Throttled to once per 6h.
-3. **macOS native notification** (opt-in) — daemon fires a banner when a new export is staged. `memex telegram notifications on` to enable. Default OFF for lock-screen privacy; add `--show-titles` if you want chat names in the banner.
+3. **macOS native notification** (opt-in) — daemon fires a banner when a new export is staged. `memex telegram notifications on` to enable. Default OFF for lock-screen privacy; add `--show-titles` if you want chat names in the banner. **v0.10.4+ clickable:** if `terminal-notifier` is installed (`brew install terminal-notifier`), clicking the banner opens — in priority order — Claude Code CLI in a fresh Terminal (Brian Chesky moment via SessionStart hook), Claude Desktop, or Terminal with `memex telegram pending` queued. Override priority via `memex telegram notifications target <auto|claude-cli|claude-desktop|terminal|none>`.
 4. **Brian Chesky hook (next Claude Code session)** — `memex context` injection includes a "🆕 N exports awaiting review" block with chat names. Claude leads with the question before you type anything.
 
 ---

package/ingest.js

@@ -1386,27 +1386,42 @@ function scheduleTelegramStaging(srcPath) {
       const dest = stageExport(srcPath, { moveOrCopy: 'move' });
       log(`+ telegram-export staged → pending/: ${basename(dest)}`);
 
-      // Channel C: macOS native notification. Default OFF, opt-in via
-      //   `memex telegram notifications on [--show-titles]`. Dedup by path
-      //   hash so re-stages of the same export don't re-notify.
+      // Channel C: macOS native notification (v0.10.4+ — clickable).
+      // Default OFF, opt-in via `memex telegram notifications on`. Dedup
+      // by path hash so re-stages of same export don't re-notify.
+      //
+      // Click behavior priority (auto): Claude Code CLI → Claude Desktop
+      // → Terminal. terminal-notifier required for click-through; without
+      // it banner is shown via osascript (informative text, no click).
       try {
         const notify = await import('./lib/telegram-notify.js');
+        const clickLib = await import('./lib/notify-click-action.js');
         const state = notify.loadNotifyState();
         if (state.notifications.enabled && !notify.notifShownFor(state, dest)) {
-          // Look up preview to know the chat name (only if user opted in)
           const list = listPending();
           const justStaged = list.find((e) => e.path === dest) || {};
           const totalPending = list.length;
           const showTitles = !!state.notifications.show_titles;
-          const title = `memex · ${totalPending} new Telegram chat${totalPending === 1 ? '' : 's'}`;
-          const body = showTitles && justStaged.chat_title
-            ? `"${justStaged.chat_title}" — ${justStaged.message_count?.toLocaleString?.() || '?'} msgs. Review with: memex telegram pending`
-            : `Review with: memex telegram pending`;
-          const fired = notify.fireMacosNotification(title, body, { subtitle: 'Ready to review' });
-          if (fired) {
+          const env = clickLib.detectEnvironment();
+          const target = clickLib.pickTarget(state.notifications.click_target || 'auto', env);
+          const clickable = !!env.terminal_notifier && target !== 'none';
+          const cta = clickLib.bannerCallToAction(target, clickable);
+
+          const title = 'memex';
+          const subtitle = `${totalPending} new Telegram chat${totalPending === 1 ? '' : 's'} ready to review`;
+          const message = showTitles && justStaged.chat_title
+            ? `"${justStaged.chat_title}" — ${(justStaged.message_count || 0).toLocaleString()} msgs · ${cta}`
+            : `${cta}`;
+
+          const r = clickLib.fireClickableNotification({
+            title, subtitle, message,
+            target: state.notifications.click_target || 'auto',
+            env,
+          });
+          if (r.backend !== 'noop') {
             notify.markNotifShown(state, [dest]);
             notify.saveNotifyState(state);
-            log(`  notif fired (macOS, ${showTitles ? 'with' : 'no'} title)`);
+            log(`  notif fired (${r.backend}, target=${r.target}, titles=${showTitles ? 'yes' : 'no'})`);
           }
         }
       } catch (e) {

package/lib/cli/index.js

@@ -1099,8 +1099,12 @@ async function cmdTelegram(args) {
     console.error('  mode [pick|auto|manual]  Get or set capture mode (default: pick)');
     console.error('  status                Show counts: allowed/skipped/blocked + recent imports');
     console.error('  scan                  One-shot rescan of ~/Downloads/Telegram Desktop/');
-    console.error('  notifications <on|off|status> [--show-titles]');
+    console.error('  notifications <on|off|status|target> [--show-titles]');
     console.error('                        macOS native notification on new export detect (default OFF)');
+    console.error('                        target <auto|claude-cli|claude-desktop|terminal|none>');
+    console.error('                                — what clicking the banner does (default auto)');
+    console.error('  open-pending [--in <claude|claude-desktop|terminal>]');
+    console.error('                        Open pending list in best available client (Claude CLI > Desktop > Terminal)');
     console.error('');
     console.error('  --json                Machine-readable output (works on most subcommands)');
     process.exit(sub ? 0 : 2);
@@ -1125,6 +1129,7 @@ async function cmdTelegram(args) {
     case 'status':      return tgCmdStatus(opts, decisions, pending);
     case 'scan':        return tgCmdScan(opts, discovery, pending);
     case 'notifications': return tgCmdNotifications(positionals, opts, args);
+    case 'open-pending':  return tgCmdOpenPending(positionals, opts, args);
     default:
       console.error(`Unknown 'memex telegram' subcommand: ${sub}`);
       console.error(`Run 'memex telegram --help' for usage.`);
@@ -1506,30 +1511,68 @@ async function tgCmdNotifications(positionals, opts, args) {
   const showTitlesFlag = args.includes('--show-titles');
   const noTitlesFlag = args.includes('--no-titles') || args.includes('--hide-titles');
   const notify = await import('../telegram-notify.js');
+  const click = await import('../notify-click-action.js');
   const state = notify.loadNotifyState();
 
   if (!action || action === 'status') {
-    if (opts.json) { console.log(JSON.stringify(state.notifications)); return; }
+    const env = click.detectEnvironment(true);
+    const effectiveTarget = click.pickTarget(state.notifications.click_target, env);
+    if (opts.json) {
+      console.log(JSON.stringify({
+        ...state.notifications,
+        backend: env.terminal_notifier ? 'terminal-notifier' : 'osascript',
+        effective_target: effectiveTarget,
+        environment: {
+          terminal_notifier_installed: !!env.terminal_notifier,
+          claude_cli_installed: !!env.claude_cli,
+          claude_desktop_installed: !!env.claude_desktop,
+        },
+      }, null, 2));
+      return;
+    }
     console.log(`Telegram notifications: ${state.notifications.enabled ? c.green('ON') : c.dim('OFF')}`);
-    console.log(`  show_titles: ${state.notifications.show_titles ? c.green('yes') : c.dim('no (privacy: just count)')}`);
+    console.log(`  show_titles:  ${state.notifications.show_titles ? c.green('yes') : c.dim('no (privacy: just count)')}`);
+    console.log(`  click target: ${c.cyan(state.notifications.click_target)} → ${click.targetLabel(effectiveTarget)}`);
+    console.log(`  backend:      ${env.terminal_notifier ? c.green('terminal-notifier') + c.dim(' (clickable)') : c.yellow('osascript') + c.dim(' (no click — install brew terminal-notifier for click)')}`);
+    console.log('');
+    console.log(`  Environment:`);
+    console.log(`    terminal-notifier: ${env.terminal_notifier ? c.green('✓ ' + env.terminal_notifier) : c.dim('✗ not installed — brew install terminal-notifier')}`);
+    console.log(`    Claude Code CLI:   ${env.claude_cli ? c.green('✓ ' + env.claude_cli) : c.dim('✗ not installed')}`);
+    console.log(`    Claude Desktop:    ${env.claude_desktop ? c.green('✓ ' + env.claude_desktop) : c.dim('✗ not installed')}`);
     console.log('');
     if (!state.notifications.enabled) {
       console.log('Enable: memex telegram notifications on');
-      console.log('  Optional: --show-titles to include chat names in the notification banner');
-      console.log('  ⚠ Without --show-titles, banner shows just "N new chat(s) ready to review".');
-      console.log('     With --show-titles, banner includes chat names — visible on lock screen.');
+      console.log('  --show-titles  include chat names in banner (default off — privacy on lock screen)');
     }
+    console.log('Override click target: memex telegram notifications target <auto|claude-cli|claude-desktop|terminal|none>');
     return;
   }
 
   if (action === 'on' || action === 'enable') {
     notify.setNotificationsEnabled(state, true, showTitlesFlag ? true : (noTitlesFlag ? false : null));
     notify.saveNotifyState(state);
-    if (opts.json) { console.log(JSON.stringify(state.notifications)); return; }
+    const env = click.detectEnvironment(true);
+    const effectiveTarget = click.pickTarget(state.notifications.click_target, env);
+    if (opts.json) {
+      console.log(JSON.stringify({
+        ...state.notifications,
+        backend: env.terminal_notifier ? 'terminal-notifier' : 'osascript',
+        effective_target: effectiveTarget,
+      }));
+      return;
+    }
     console.log(`${c.green('✓')} Telegram notifications: ON`);
-    console.log(`  show_titles: ${state.notifications.show_titles ? 'yes' : 'no (privacy)'}`);
+    console.log(`  show_titles:    ${state.notifications.show_titles ? 'yes' : 'no (privacy)'}`);
+    console.log(`  click target:   ${effectiveTarget} (${click.targetLabel(effectiveTarget)})`);
     console.log('');
-    console.log(c.dim('On first export, macOS may ask to grant notification permission.'));
+    if (!env.terminal_notifier) {
+      console.log(c.yellow('  ℹ Banner will not be clickable — install brew terminal-notifier for click-through.'));
+      console.log(c.dim('     Without it: banner text is self-contained ("Run: memex telegram pending").'));
+    } else if (effectiveTarget === 'claude-cli') {
+      console.log(c.dim('  ℹ First click → macOS will ask permission to control Terminal.'));
+      console.log(c.dim('     Allow it — that\'s how memex opens a new Terminal tab with Claude Code.'));
+    }
+    console.log(c.dim('  On first export, macOS may also ask to grant notification permission.'));
     return;
   }
   if (action === 'off' || action === 'disable') {
@@ -1539,10 +1582,62 @@ async function tgCmdNotifications(positionals, opts, args) {
     console.log(`${c.green('✓')} Telegram notifications: OFF`);
     return;
   }
-  console.error(`Unknown action: ${action}. Use: on | off | status`);
+  if (action === 'target') {
+    const newTarget = positionals[1];
+    if (!newTarget) {
+      console.error('Usage: memex telegram notifications target <auto|claude-cli|claude-desktop|terminal|none>');
+      process.exit(2);
+    }
+    try {
+      notify.setClickTarget(state, newTarget);
+      notify.saveNotifyState(state);
+    } catch (e) {
+      console.error(`✗ ${e.message}`);
+      process.exit(2);
+    }
+    const env = click.detectEnvironment(true);
+    const effectiveTarget = click.pickTarget(newTarget, env);
+    if (opts.json) { console.log(JSON.stringify({ click_target: newTarget, effective_target: effectiveTarget })); return; }
+    console.log(`${c.green('✓')} click target: ${newTarget} → ${click.targetLabel(effectiveTarget)}`);
+    if (newTarget !== effectiveTarget) {
+      console.log(c.dim(`  (your preference "${newTarget}" is not installed; falling back to "${effectiveTarget}")`));
+    }
+    return;
+  }
+  console.error(`Unknown action: ${action}. Use: on | off | status | target`);
   process.exit(2);
 }
 
+async function tgCmdOpenPending(positionals, opts, args) {
+  const click = await import('../notify-click-action.js');
+  // --in <X> flag override, else 'auto'
+  let preference = 'auto';
+  const inIdx = args.indexOf('--in');
+  if (inIdx >= 0 && args[inIdx + 1]) {
+    preference = args[inIdx + 1];
+    // Accept short aliases for ergonomics
+    if (preference === 'claude') preference = 'claude-cli';
+    if (preference === 'term') preference = 'terminal';
+    if (preference === 'desktop') preference = 'claude-desktop';
+  }
+  const env = click.detectEnvironment(true);
+  const target = click.pickTarget(preference, env);
+  if (target === 'none') {
+    console.error(`No click target available. Use --in <claude|claude-desktop|terminal>.`);
+    process.exit(1);
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({ preference, effective_target: target, label: click.targetLabel(target) }));
+  } else {
+    console.log(`${c.cyan('▶')} Opening pending in: ${click.targetLabel(target)}`);
+  }
+  const r = click.executeClickAction(preference, env);
+  if (!r.ran && !opts.json) {
+    console.error(`✗ Failed: ${r.reason || 'unknown'}`);
+    process.exit(1);
+  }
+}
+
 function tgCmdScan(opts, discovery, pending) {
   const paths = discovery.defaultDownloadsPaths();
   const found = discovery.discoverExports(paths);

package/lib/notify-click-action.js

@@ -0,0 +1,281 @@
+/**
+ * Notification click-action picker for Telegram capture (v0.10.4+).
+ *
+ * macOS `osascript display notification` banners are NOT clickable — clicking
+ * them opens the parent app (Script Editor), which is confusing. To get a real
+ * click-action we use third-party `terminal-notifier` (brew install) which has
+ * `-execute "<shell command>"` support.
+ *
+ * Click target priority (auto-detect):
+ *   1. Claude Code CLI installed → open Terminal, launch `claude`
+ *      → SessionStart hook (v0.8+) fires → agent leads with pending banner.
+ *      This is the "Brian Chesky moment" — the wow case.
+ *   2. Claude Desktop installed (no CLI) → `open -a Claude`
+ *      MCP is connected, but no auto-context. User has to ask.
+ *   3. Neither → open Terminal with `memex telegram pending` queued.
+ *
+ * User can override via `memex telegram notifications target <X>`:
+ *   auto · claude-cli · claude-desktop · terminal · none
+ *
+ * This module is shell-out heavy; everything runs detached so we never
+ * block the daemon's chokidar event loop.
+ */
+
+import { existsSync, accessSync, constants } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { join, delimiter } from 'node:path';
+import { spawn } from 'node:child_process';
+
+// ------------------------- Binary detection -------------------------
+
+/**
+ * Is a binary available on PATH? Returns the absolute path or null.
+ * We do this manually (vs `which`) so it's fast + cross-platform.
+ */
+export function findBin(name) {
+  const pathDirs = (process.env.PATH || '').split(delimiter).filter(Boolean);
+  // Also include common shell-rc-installed dirs that GUI daemons miss
+  const extras = [
+    join(homedir(), '.npm-global/bin'),
+    '/opt/homebrew/bin',
+    '/usr/local/bin',
+    '/usr/bin',
+  ];
+  for (const dir of [...pathDirs, ...extras]) {
+    const full = join(dir, name);
+    try {
+      accessSync(full, constants.X_OK);
+      return full;
+    } catch (_) { /* not here */ }
+  }
+  return null;
+}
+
+/**
+ * Detect the user's notification + click-action environment.
+ *
+ * Returns an object describing what's available and what we'd pick if
+ * `target === 'auto'`. Cached briefly — detection is cheap but we don't
+ * want to fs.exists() on every fired notification.
+ */
+let _detectCache = null;
+let _detectCacheAt = 0;
+const DETECT_CACHE_MS = 30_000;
+
+export function detectEnvironment(force = false) {
+  if (!force && _detectCache && (Date.now() - _detectCacheAt) < DETECT_CACHE_MS) {
+    return _detectCache;
+  }
+  const env = {
+    platform: platform(),
+    terminal_notifier: findBin('terminal-notifier'),
+    claude_cli: findBin('claude'),
+    claude_desktop: detectClaudeDesktop(),
+    memex_bin: findBin('memex'),
+  };
+  _detectCache = env;
+  _detectCacheAt = Date.now();
+  return env;
+}
+
+function detectClaudeDesktop() {
+  if (platform() !== 'darwin') return null;
+  const candidates = [
+    '/Applications/Claude.app',
+    join(homedir(), 'Applications/Claude.app'),
+  ];
+  for (const c of candidates) if (existsSync(c)) return c;
+  return null;
+}
+
+// ------------------------- Target selection -------------------------
+
+/**
+ * Decide which click-action target to use given the user's preference
+ * and detected environment.
+ *
+ * Returns one of: 'claude-cli', 'claude-desktop', 'terminal', 'none'.
+ *
+ *   preference = 'auto'           → priority: cli > desktop > terminal
+ *   preference = 'claude-cli'     → use if installed, else fall through to auto
+ *   preference = 'claude-desktop' → use if installed, else fall through to auto
+ *   preference = 'terminal'       → always Terminal (user opted out of Claude)
+ *   preference = 'none'           → no click action
+ */
+export function pickTarget(preference, env = detectEnvironment()) {
+  if (preference === 'none') return 'none';
+  if (preference === 'terminal') return 'terminal';
+  if (preference === 'claude-cli' && env.claude_cli) return 'claude-cli';
+  if (preference === 'claude-desktop' && env.claude_desktop) return 'claude-desktop';
+  // auto (or explicit-but-not-installed) — fall through priority
+  if (env.claude_cli) return 'claude-cli';
+  if (env.claude_desktop) return 'claude-desktop';
+  return 'terminal';
+}
+
+/**
+ * Human-readable label for the chosen target — shown in `notifications status`
+ * and used as the banner-text "call to action".
+ */
+export function targetLabel(target) {
+  switch (target) {
+    case 'claude-cli':     return 'Claude Code CLI (Brian Chesky moment)';
+    case 'claude-desktop': return 'Claude Desktop';
+    case 'terminal':       return 'Terminal with `memex telegram pending`';
+    case 'none':           return 'no click action';
+    default:               return target;
+  }
+}
+
+/**
+ * The call-to-action shown in the banner body. Depends on:
+ *   • target (claude-cli / claude-desktop / terminal / none)
+ *   • clickable (is terminal-notifier installed so the banner is actually clickable?)
+ *
+ * When NOT clickable, we drop the "Click to ..." phrasing and instead
+ * show the literal shell command so users without terminal-notifier
+ * still know exactly what to do.
+ */
+export function bannerCallToAction(target, clickable = true) {
+  if (!clickable) {
+    // No click possible — show concrete action user must take manually
+    if (target === 'claude-cli')     return 'Run: claude (or memex telegram pending)';
+    if (target === 'claude-desktop') return 'Open Claude Desktop, ask "what\'s pending in memex?"';
+    return 'Run: memex telegram pending';
+  }
+  switch (target) {
+    case 'claude-cli':     return 'Click to launch Claude';
+    case 'claude-desktop': return 'Click to open Claude Desktop';
+    case 'terminal':       return 'Click to open Terminal';
+    case 'none':           return 'Run: memex telegram pending';
+    default:               return 'memex telegram pending';
+  }
+}
+
+// ------------------------- Build click-action shell command -------------------------
+
+/**
+ * Compose the shell command that `terminal-notifier -execute` will run when
+ * the user clicks the banner.
+ *
+ * Returns null if target = 'none' (banner has no click action).
+ *
+ * Notes:
+ *   • Each target is wrapped in `osascript` to invoke macOS' Terminal app,
+ *     so the user lands in an interactive shell session (not a daemon-spawned
+ *     headless process).
+ *   • Quoting: we shell-escape the inner double quotes for AppleScript's
+ *     `do script` parameter.
+ */
+export function buildClickCommand(target, env = detectEnvironment()) {
+  if (target === 'none') return null;
+
+  if (target === 'claude-cli') {
+    // Open a fresh Terminal window, launch `claude` from $HOME so the
+    // SessionStart hook injects pending Telegram exports into the
+    // first message. The hook fires regardless of cwd; pending is always
+    // surfaced when count > 0.
+    const cliPath = env.claude_cli || 'claude';
+    return `osascript -e 'tell application "Terminal" to activate' ` +
+           `-e 'tell application "Terminal" to do script "cd ~ && ${escapeApple(cliPath)}"'`;
+  }
+
+  if (target === 'claude-desktop') {
+    const appPath = env.claude_desktop || '/Applications/Claude.app';
+    return `open ${shellQuote(appPath)}`;
+  }
+
+  if (target === 'terminal') {
+    // Open Terminal and run `memex telegram pending` so user sees the list
+    const memexBin = env.memex_bin || 'memex';
+    return `osascript -e 'tell application "Terminal" to activate' ` +
+           `-e 'tell application "Terminal" to do script "${escapeApple(memexBin)} telegram pending"'`;
+  }
+
+  return null;
+}
+
+// AppleScript "do script" takes a string — we need to escape backslash + dquote
+function escapeApple(s) {
+  return String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+// Conservative shell quote — used for `open <path>` where path may contain spaces
+function shellQuote(s) {
+  return `'${String(s).replace(/'/g, "'\\''")}'`;
+}
+
+// ------------------------- Fire the notification -------------------------
+
+/**
+ * Fire a clickable notification via terminal-notifier (preferred) or fall
+ * back to plain osascript (no click).
+ *
+ *   opts = {
+ *     title, subtitle, message,
+ *     target,    // 'auto' | 'claude-cli' | 'claude-desktop' | 'terminal' | 'none'
+ *     env,       // optional override of detected env (for tests)
+ *     dryRun,    // if true → compute backend+target+command but DON'T spawn.
+ *                //   Used by unit tests so `npm test` doesn't spam real
+ *                //   macOS notifications. Also honors env MEMEX_NO_FIRE=1.
+ *   }
+ *
+ * Returns { backend: 'terminal-notifier' | 'osascript' | 'noop',
+ *           target, click_command }
+ */
+export function fireClickableNotification(opts = {}) {
+  const env = opts.env || detectEnvironment();
+  if (env.platform !== 'darwin') return { backend: 'noop', target: 'none', click_command: null };
+
+  const target = pickTarget(opts.target || 'auto', env);
+  const click = buildClickCommand(target, env);
+  const dryRun = opts.dryRun === true || process.env.MEMEX_NO_FIRE === '1';
+
+  const title = opts.title || 'memex';
+  const subtitle = opts.subtitle || '';
+  const message = opts.message || '';
+
+  if (env.terminal_notifier && click) {
+    if (dryRun) return { backend: 'terminal-notifier', target, click_command: click };
+    const args = [
+      '-title', title,
+      '-message', message,
+      '-execute', click,
+    ];
+    if (subtitle) { args.push('-subtitle'); args.push(subtitle); }
+    args.push('-sound', 'Pop');
+    args.push('-sender', 'com.apple.Terminal');
+    try {
+      spawn(env.terminal_notifier, args, { detached: true, stdio: 'ignore' }).unref();
+      return { backend: 'terminal-notifier', target, click_command: click };
+    } catch (_) { /* fall through to osascript */ }
+  }
+
+  // Plain osascript fallback — banner is not clickable but text is informative
+  if (dryRun) return { backend: 'osascript', target: 'none', click_command: null };
+  const esc = (s) => String(s || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const sub = subtitle ? ` subtitle "${esc(subtitle)}"` : '';
+  const script = `display notification "${esc(message)}" with title "${esc(title)}"${sub} sound name "Pop"`;
+  try {
+    spawn('osascript', ['-e', script], { detached: true, stdio: 'ignore' }).unref();
+    return { backend: 'osascript', target: 'none', click_command: null };
+  } catch (_) {
+    return { backend: 'noop', target: 'none', click_command: null };
+  }
+}
+
+/**
+ * Run the click-action directly (for `memex telegram open-pending` CLI).
+ * Same target-resolution logic as the notification, just invoked from CLI.
+ */
+export function executeClickAction(preference = 'auto', env = detectEnvironment()) {
+  const target = pickTarget(preference, env);
+  const cmd = buildClickCommand(target, env);
+  if (!cmd) return { ran: false, target, reason: 'no-action' };
+  try {
+    spawn('sh', ['-c', cmd], { detached: true, stdio: 'ignore' }).unref();
+    return { ran: true, target, command: cmd };
+  } catch (e) {
+    return { ran: false, target, reason: e.message };
+  }
+}

package/lib/telegram-decisions.js

@@ -119,9 +119,21 @@ export function allowChat(state, title, now = new Date()) {
   return state;
 }
 
+/**
+ * Skip a chat title — record a per-chat decision so future re-exports
+ * of this chat are auto-skipped.
+ *
+ * IMPORTANT: if the chat is ALREADY in allowed_chats, this is a no-op
+ * on the decisions state. The user has previously committed to indexing
+ * this chat; "skip" in this case means "throw away THIS export file"
+ * (the file removal is the caller's job), NOT "block this chat forever".
+ * If the user truly wants to stop indexing a previously-allowed chat,
+ * they should use `memex telegram remove <title>` (purges from memex.db
+ * AND marks as skipped).
+ */
 export function skipChat(state, title, now = new Date()) {
+  if (isAllowed(state, title)) return state;   // preserve prior import decision
   if (isSkipped(state, title)) return state;
-  state.allowed_chats = state.allowed_chats.filter((c) => norm(c.title) !== norm(title));
   state.skipped_chats.push({ title, skipped_at: now.toISOString() });
   return state;
 }

package/lib/telegram-notify.js

@@ -33,6 +33,7 @@ import {
   writeFileSync,
   renameSync,
   mkdirSync,
+  statSync,
 } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { join, dirname } from 'node:path';
@@ -49,9 +50,20 @@ const DEFAULT_STATE = () => ({
   notifications: {
     enabled: false,    // privacy-first: opt-in for macOS notification
     show_titles: false, // even when on, don't leak chat names by default
+    // v0.10.4+: which app to open when the user clicks the banner.
+    //   'auto'           → priority: claude-cli > claude-desktop > terminal
+    //   'claude-cli'     → force open Claude Code CLI in a new Terminal tab
+    //   'claude-desktop' → force open Claude Desktop GUI
+    //   'terminal'       → force open Terminal with `memex telegram pending`
+    //   'none'           → banner not clickable
+    // If terminal-notifier is not installed, click is impossible — banner
+    // text falls back to "Run: memex telegram pending".
+    click_target: 'auto',
   },
 });
 
+export const VALID_CLICK_TARGETS = ['auto', 'claude-cli', 'claude-desktop', 'terminal', 'none'];
+
 export function loadNotifyState(path = STATE_PATH) {
   if (!existsSync(path)) return DEFAULT_STATE();
   try {
@@ -95,8 +107,26 @@ export function markCliTipShown(state, now = new Date()) {
 
 // ---------------------- Notification dedup ----------------------
 
+/**
+ * Stable hash of a pending export for notification dedup.
+ *
+ * v0.10.5+: hash now incorporates the file's mtime in addition to path.
+ *
+ * Why: Telegram Desktop reuses the same folder name on same-day re-exports
+ * (e.g. ChatExport_2026-05-16). After memex imports & removes that folder
+ * from pending, a fresh export with the same date creates the same path
+ * again. Path-only hash collided → notification was incorrectly deduped
+ * as "already shown".
+ *
+ * Including mtime makes the hash content-aware: same path + different
+ * mtime → fresh hash → notification fires. If the path doesn't exist
+ * (file was deleted), we fall back to path-only — it's an edge case
+ * (notifShownFor check before fire, file should exist).
+ */
 export function notifIdFor(path) {
-  return createHash('sha256').update(String(path)).digest('hex').slice(0, 16);
+  let mtimeKey = '';
+  try { mtimeKey = String(Math.floor(statSync(path).mtimeMs)); } catch (_) { /* path missing — fall back to path-only */ }
+  return createHash('sha256').update(String(path) + ':' + mtimeKey).digest('hex').slice(0, 16);
 }
 
 export function notifShownFor(state, path) {
@@ -148,6 +178,14 @@ export function setNotificationsEnabled(state, enabled, showTitles = null) {
   return state;
 }
 
+export function setClickTarget(state, target) {
+  if (!VALID_CLICK_TARGETS.includes(target)) {
+    throw new Error(`Invalid click_target '${target}'. Valid: ${VALID_CLICK_TARGETS.join(', ')}`);
+  }
+  state.notifications.click_target = target;
+  return state;
+}
+
 // ---------------------- Channel B formatter ----------------------
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memex-mvp",
-  "version": "0.10.2",
+  "version": "0.10.6",
   "description": "Local-first MCP server for cross-agent AI memory. One SQLite + FTS5 corpus across Claude Code, Cowork, Cursor, Continue, Zed, Obsidian, and Telegram — passively captured, verbatim, searchable from any MCP-compatible client.",
   "type": "module",
   "main": "server.js",
@@ -26,7 +26,7 @@
     "sync": "node ingest.js",
     "ingest": "node ingest.js",
     "bot": "node bot/index.js",
-    "test": "node test/parser.test.js && node test/bot-inbox.test.js && node test/search-sort.test.js && node test/store-document.test.js && node test/cli.test.js && node test/hook.test.js && node test/telegram-html.test.js && node test/telegram-decisions.test.js && node test/telegram-pending.test.js && node test/telegram-notify.test.js",
+    "test": "node test/parser.test.js && node test/bot-inbox.test.js && node test/search-sort.test.js && node test/store-document.test.js && node test/cli.test.js && node test/hook.test.js && node test/telegram-html.test.js && node test/telegram-decisions.test.js && node test/telegram-pending.test.js && node test/telegram-notify.test.js && node test/notify-click-action.test.js",
     "prepublishOnly": "npm test"
   },
   "engines": {