gsd-pi 2.71.0-dev.06b86c6 → 2.71.0-dev.7a61d89

package/src/resources/extensions/gsd/forensics.ts

@@ -650,19 +650,33 @@ function getDbCompletionCounts(): DbCompletionCounts | null {
  * Exported for testability.
  */
 export function detectStuckLoops(units: UnitMetrics[], anomalies: ForensicAnomaly[]): void {
-  // First, collect unique startedAt values per type/id key
-  const dispatchMap = new Map<string, Set<number>>();
+  // First, collect unique startedAt values per type/id key, bucketed by
+  // autoSessionKey when available so cross-session recovery does not look
+  // like a within-session stuck loop.
+  const dispatchMap = new Map<string, Map<string, Set<number>>>();
   for (const u of units) {
     const key = `${u.type}/${u.id}`;
-    let starts = dispatchMap.get(key);
+    let sessionBuckets = dispatchMap.get(key);
+    if (!sessionBuckets) {
+      sessionBuckets = new Map();
+      dispatchMap.set(key, sessionBuckets);
+    }
+
+    const sessionKey = u.autoSessionKey ?? "__legacy__";
+    let starts = sessionBuckets.get(sessionKey);
     if (!starts) {
       starts = new Set();
-      dispatchMap.set(key, starts);
+      sessionBuckets.set(sessionKey, starts);
     }
     starts.add(u.startedAt);
   }
-  for (const [key, starts] of dispatchMap) {
-    const count = starts.size;
+
+  for (const [key, sessionBuckets] of dispatchMap) {
+    const hasSessionAwareData = Array.from(sessionBuckets.keys()).some((sessionKey) => sessionKey !== "__legacy__");
+    const count = hasSessionAwareData
+      ? Math.max(...Array.from(sessionBuckets.values(), (starts) => starts.size))
+      : (sessionBuckets.get("__legacy__")?.size ?? 0);
+
     if (count > 1) {
       const [unitType, ...idParts] = key.split("/");
       anomalies.push({
@@ -671,7 +685,9 @@ export function detectStuckLoops(units: UnitMetrics[], anomalies: ForensicAnomal
         unitType,
         unitId: idParts.join("/"),
         summary: `Unit ${key} was dispatched ${count} times`,
-        details: `Repeated dispatch suggests the unit completed but its artifacts weren't verified, or the state machine kept returning it.`,
+        details: hasSessionAwareData
+          ? `Repeated dispatch within the same auto session suggests the unit completed but its artifacts were not verified, or the state machine kept returning it. Cross-session recovery runs are ignored.`
+          : `Repeated dispatch suggests the unit completed but its artifacts weren't verified, or the state machine kept returning it.`,
       });
     }
   }

package/src/resources/extensions/gsd/guided-flow.ts

@@ -15,7 +15,7 @@ import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { buildSkillActivationBlock } from "./auto-prompts.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
-import { startAuto } from "./auto.js";
+import { startAutoDetached } from "./auto.js";
 import { clearLock } from "./crash-recovery.js";
 import {
   assessInterruptedSession,
@@ -67,7 +67,6 @@ export {
   showQueue, handleQueueReorder, showQueueAdd,
   buildExistingMilestonesContext,
 } from "./guided-flow-queue.js";
-import { getErrorMessage } from "./error-utils.js";
 import { logWarning } from "./workflow-logger.js";
 
 // ─── ID Generation with Reservation ─────────────────────────────────────────
@@ -244,11 +243,7 @@ export function checkAutoStartAfterDiscuss(): boolean {
 
   pendingAutoStartMap.delete(basePath);
   ctx.ui.notify(`Milestone ${milestoneId} ready.`, "info");
-  startAuto(ctx, pi, basePath, false, { step }).catch((err) => {
-    ctx.ui.notify(`Auto-start failed: ${getErrorMessage(err)}`, "error");
-    logWarning("guided", `auto start error: ${getErrorMessage(err)}`);
-    debugLog("auto-start-failed", { error: getErrorMessage(err) });
-  });
+  startAutoDetached(ctx, pi, basePath, false, { step });
   return true;
 }
 
@@ -1305,7 +1300,7 @@ export async function showSmartEntry(
       ],
     });
     if (resume === "resume") {
-      await startAuto(ctx, pi, basePath, false, {
+      startAutoDetached(ctx, pi, basePath, false, {
         interrupted,
         step: interrupted.pausedSession?.stepMode ?? false,
       });
@@ -1647,7 +1642,7 @@ export async function showSmartEntry(
       });
 
       if (choice === "auto") {
-        await startAuto(ctx, pi, basePath, false);
+        startAutoDetached(ctx, pi, basePath, false);
       } else if (choice === "status") {
         const { fireStatusViaCommand } = await import("./commands.js");
         await fireStatusViaCommand(ctx);
@@ -1859,7 +1854,7 @@ export async function showSmartEntry(
     });
 
     if (choice === "auto") {
-      await startAuto(ctx, pi, basePath, false);
+      startAutoDetached(ctx, pi, basePath, false);
       return;
     }
 

package/src/resources/extensions/gsd/interrupted-session.ts

@@ -34,6 +34,7 @@ export interface PausedSessionMetadata {
   activeEngineId?: string;
   activeRunDir?: string | null;
   autoStartTime?: number;
+  milestoneLock?: string | null;
 }
 
 export interface InterruptedSessionAssessment {

package/src/resources/extensions/gsd/metrics.ts

@@ -41,6 +41,7 @@ export interface UnitMetrics {
   model: string;           // model ID used
   startedAt: number;       // ms timestamp
   finishedAt: number;      // ms timestamp
+  autoSessionKey?: string; // identifies one auto-mode run across pause/resume
   tokens: TokenCounts;
   cost: number;            // total USD cost
   toolCalls: number;
@@ -133,7 +134,16 @@ export function snapshotUnitMetrics(
   unitId: string,
   startedAt: number,
   model: string,
-  opts?: { tier?: string; modelDowngraded?: boolean; contextWindowTokens?: number; truncationSections?: number; continueHereFired?: boolean; promptCharCount?: number; baselineCharCount?: number },
+  opts?: {
+    tier?: string;
+    modelDowngraded?: boolean;
+    contextWindowTokens?: number;
+    truncationSections?: number;
+    continueHereFired?: boolean;
+    promptCharCount?: number;
+    baselineCharCount?: number;
+    autoSessionKey?: string;
+  },
 ): UnitMetrics | null {
   if (!ledger) return null;
 
@@ -181,6 +191,7 @@ export function snapshotUnitMetrics(
     model,
     startedAt,
     finishedAt: Date.now(),
+    ...(opts?.autoSessionKey ? { autoSessionKey: opts.autoSessionKey } : {}),
     tokens,
     cost,
     toolCalls,

package/src/resources/extensions/gsd/milestone-actions.ts

@@ -20,7 +20,7 @@ import {
 } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
-import { isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
+import { getMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
 import { logWarning } from "./workflow-logger.js";
 
 // ─── Park ──────────────────────────────────────────────────────────────────
@@ -77,9 +77,16 @@ export function unparkMilestone(basePath: string, milestoneId: string): boolean
   if (!mDir || !existsSync(mDir)) return false;
 
   const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
-  if (!existsSync(parkedPath)) return false; // not parked
+  const hadParkedFile = existsSync(parkedPath);
+  const dbThinksParked = isDbAvailable() && getMilestone(milestoneId)?.status === "parked";
 
-  unlinkSync(parkedPath);
+  // Recover the reverse desync too: DB can still say "parked" even when the
+  // PARKED marker was lost on disk, and /gsd unpark should repair that state.
+  if (!hadParkedFile && !dbThinksParked) return false;
+
+  if (hadParkedFile) {
+    unlinkSync(parkedPath);
+  }
   // Sync DB status so deriveStateFromDb picks up the unparked milestone (#2694)
   if (isDbAvailable()) {
     try {

package/src/resources/extensions/gsd/notification-overlay.ts

@@ -1,6 +1,6 @@
 // GSD Extension — Notification History Overlay
 // Scrollable panel showing all persisted notifications with severity filtering.
-// Toggled with Ctrl+Alt+N (⌃⌥N on macOS) or opened from /gsd notifications.
+// Toggled with Ctrl+Alt+N (⌃⌥N on macOS), Ctrl+Shift+N fallback, or /gsd notifications.
 
 import type { Theme } from "@gsd/pi-coding-agent";
 import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
@@ -9,11 +9,11 @@ import {
   readNotifications,
   markAllRead,
   clearNotifications,
-  getUnreadCount,
   type NotificationEntry,
   type NotifySeverity,
 } from "./notification-store.js";
-import { padRight, centerLine, joinColumns, formatDuration } from "../shared/mod.js";
+import { formattedShortcutPair } from "./shortcut-defs.js";
+import { padRight, joinColumns } from "../shared/mod.js";
 
 type FilterMode = "all" | "error" | "warning" | "info";
 const FILTER_CYCLE: FilterMode[] = ["all", "error", "warning", "info"];
@@ -63,6 +63,12 @@ function formatTimestamp(ts: string): string {
   }
 }
 
+function notificationSignature(entries: readonly NotificationEntry[]): string {
+  return entries
+    .map((entry) => `${entry.ts}|${entry.severity}|${entry.read ? 1 : 0}|${entry.message}`)
+    .join("\n");
+}
+
 export class GSDNotificationOverlay {
   private tui: { requestRender: () => void };
   private theme: Theme;
@@ -72,6 +78,7 @@ export class GSDNotificationOverlay {
   private scrollOffset = 0;
   private filterIndex = 0;
   private entries: NotificationEntry[] = [];
+  private entriesSignature = "";
   private refreshTimer: ReturnType<typeof setInterval>;
   private disposed = false;
   private resizeHandler: (() => void) | null = null;
@@ -88,6 +95,7 @@ export class GSDNotificationOverlay {
     // Mark all as read on open
     markAllRead();
     this.entries = readNotifications();
+    this.entriesSignature = notificationSignature(this.entries);
 
     // Resize handler
     this.resizeHandler = () => {
@@ -101,9 +109,11 @@ export class GSDNotificationOverlay {
     this.refreshTimer = setInterval(() => {
       if (this.disposed) return;
       const fresh = readNotifications();
-      if (fresh.length !== this.entries.length) {
-        this.entries = fresh;
+      const signature = notificationSignature(fresh);
+      if (signature !== this.entriesSignature) {
         markAllRead();
+        this.entries = readNotifications();
+        this.entriesSignature = notificationSignature(this.entries);
         this.invalidate();
         this.tui.requestRender();
       }
@@ -120,7 +130,12 @@ export class GSDNotificationOverlay {
   }
 
   handleInput(data: string): void {
-    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c")) || matchesKey(data, Key.ctrlAlt("n"))) {
+    if (
+      matchesKey(data, Key.escape) ||
+      matchesKey(data, Key.ctrl("c")) ||
+      matchesKey(data, Key.ctrlAlt("n")) ||
+      matchesKey(data, Key.ctrlShift("n"))
+    ) {
       this.dispose();
       this.onClose();
       return;
@@ -165,6 +180,7 @@ export class GSDNotificationOverlay {
     if (data === "c") {
       clearNotifications();
       this.entries = [];
+      this.entriesSignature = notificationSignature(this.entries);
       this.scrollOffset = 0;
       this.invalidate();
       this.tui.requestRender();
@@ -250,7 +266,8 @@ export class GSDNotificationOverlay {
     lines.push(hr());
 
     // Controls
-    lines.push(row(th.fg("dim", "↑/↓ scroll  f filter  c clear  Esc close")));
+    const closeShortcut = formattedShortcutPair("notifications");
+    lines.push(row(th.fg("dim", `↑/↓ scroll  f filter  c clear  Esc close  (${closeShortcut})`)));
     lines.push(blank());
 
     // Entries

package/src/resources/extensions/gsd/notification-store.ts

@@ -35,6 +35,7 @@ let _basePath: string | null = null;
 let _lineCount = 0;  // Hint for rotation — not authoritative for public API
 let _suppressCount = 0;
 let _recentMessageTimestamps = new Map<string, number>();
+const _changeListeners = new Set<() => void>();
 
 // ─── Public API ─────────────────────────────────────────────────────────
 
@@ -93,6 +94,7 @@ export function appendNotification(
     if (_lineCount > MAX_ENTRIES) {
       _rotate();
     }
+    _emitChange();
   } catch {
     // Non-fatal — never let persistence break the caller
   }
@@ -121,6 +123,7 @@ export function markAllRead(basePath?: string): void {
   const hasUnread = entries.some((e) => !e.read);
   if (!hasUnread) return;
 
+  let changed = false;
   try {
     _withLock(bp, () => {
       // Re-read inside lock to get freshest state
@@ -128,10 +131,12 @@ export function markAllRead(basePath?: string): void {
       if (fresh.length === 0 || !fresh.some((e) => !e.read)) return;
       const lines = fresh.map((e) => JSON.stringify({ ...e, read: true }));
       _atomicWrite(bp, lines.join("\n") + "\n");
+      changed = true;
     });
   } catch {
     // Non-fatal
   }
+  if (changed) _emitChange();
 }
 
 /**
@@ -145,6 +150,8 @@ export function clearNotifications(basePath?: string): void {
     _withLock(bp, () => {
       _atomicWrite(bp, "");
     });
+    _lineCount = 0;
+    _emitChange();
   } catch {
     // Non-fatal
   }
@@ -189,6 +196,17 @@ export function unsuppressPersistence(): void {
   _suppressCount = Math.max(0, _suppressCount - 1);
 }
 
+/**
+ * Subscribe to notification-store mutations (append, mark-read, clear).
+ * Returns an unsubscribe function.
+ */
+export function onNotificationStoreChange(listener: () => void): () => void {
+  _changeListeners.add(listener);
+  return () => {
+    _changeListeners.delete(listener);
+  };
+}
+
 // ─── Test Helpers ───────────────────────────────────────────────────────
 
 /**
@@ -199,6 +217,7 @@ export function _resetNotificationStore(): void {
   _lineCount = 0;
   _suppressCount = 0;
   _recentMessageTimestamps = new Map();
+  _changeListeners.clear();
 }
 
 // ─── Internal ───────────────────────────────────────────────────────────
@@ -234,12 +253,23 @@ function _rotate(): void {
       const trimmed = entries.slice(entries.length - MAX_ENTRIES);
       const lines = trimmed.map((e) => JSON.stringify(e));
       _atomicWrite(_basePath!, lines.join("\n") + "\n");
+      _lineCount = trimmed.length;
     });
   } catch {
     // Non-fatal
   }
 }
 
+function _emitChange(): void {
+  for (const listener of _changeListeners) {
+    try {
+      listener();
+    } catch {
+      // Non-fatal
+    }
+  }
+}
+
 /**
  * Atomic file rewrite via temp-file + rename. Prevents partial reads
  * by other processes (web API subprocess, parallel workers).

package/src/resources/extensions/gsd/notification-widget.ts

@@ -5,8 +5,8 @@
 
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
 
-import { getUnreadCount, readNotifications } from "./notification-store.js";
-import { formatShortcut } from "./files.js";
+import { getUnreadCount, onNotificationStoreChange } from "./notification-store.js";
+import { formattedShortcutPair } from "./shortcut-defs.js";
 
 // ─── Pure rendering ──���────────────────────────���─────────────────────────
 
@@ -14,18 +14,7 @@ export function buildNotificationWidgetLines(): string[] {
   const unread = getUnreadCount();
   if (unread === 0) return [];
 
-  const entries = readNotifications();
-  const latest = entries[0]; // newest-first
-  if (!latest) return [];
-
-  const icon = latest.severity === "error" ? "✗" : latest.severity === "warning" ? "⚠" : "●";
-  const badge = `${unread} unread`;
-  const msgMax = 80;
-  const truncated = latest.message.length > msgMax
-    ? latest.message.slice(0, msgMax - 1) + "…"
-    : latest.message;
-
-  return [`  ${icon} [${badge}]  ${truncated}  (${formatShortcut("Ctrl+Alt+N")} or /gsd notifications)`];
+  return [`  🔔 Notifications: ${unread} unread  (${formattedShortcutPair("notifications")})`];
 }
 
 // ─── Widget init ────────────────────────────────────────────────────────
@@ -51,6 +40,7 @@ export function initNotificationWidget(ctx: ExtensionContext): void {
       _tui.requestRender();
     };
 
+    const unsubscribe = onNotificationStoreChange(refresh);
     const refreshTimer = setInterval(refresh, REFRESH_INTERVAL_MS);
 
     return {
@@ -62,6 +52,7 @@ export function initNotificationWidget(ctx: ExtensionContext): void {
         cachedLines = undefined;
       },
       dispose(): void {
+        unsubscribe();
         clearInterval(refreshTimer);
       },
     };

package/src/resources/extensions/gsd/parallel-monitor-overlay.ts

@@ -2,7 +2,8 @@
  * GSD Parallel Monitor Overlay
  *
  * Full-screen TUI overlay showing real-time parallel worker progress.
- * Opened via `/gsd parallel watch` or Ctrl+Alt+P (⌃⌥P on macOS).
+ * Opened via `/gsd parallel watch`, Ctrl+Alt+P (⌃⌥P on macOS),
+ * or Ctrl+Shift+P fallback.
  * Reads the same data sources as `scripts/parallel-monitor.mjs` but
  * renders as a native pi-tui overlay with theme integration.
  */
@@ -15,6 +16,7 @@ import type { Theme } from "@gsd/pi-coding-agent";
 import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
 
 import { formatDuration, STATUS_GLYPH, STATUS_COLOR } from "../shared/mod.js";
+import { formattedShortcutPair } from "./shortcut-defs.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────
 
@@ -347,7 +349,12 @@ export class ParallelMonitorOverlay {
   }
 
   handleInput(data: string): void {
-    if (matchesKey(data, Key.escape) || data === "q") {
+    if (
+      matchesKey(data, Key.escape) ||
+      matchesKey(data, Key.ctrlAlt("p")) ||
+      matchesKey(data, Key.ctrlShift("p")) ||
+      data === "q"
+    ) {
       this.dispose();
       this.onClose();
       return;
@@ -486,7 +493,7 @@ export class ParallelMonitorOverlay {
       }
       lines.push(`  ${t.bold("Total: $" + this.workers.reduce((s, wk) => s + wk.cost, 0).toFixed(2))}`);
     }
-    lines.push(t.fg("muted", "  ESC/q to close  │  ↑↓ scroll"));
+    lines.push(t.fg("muted", `  ESC/q/${formattedShortcutPair("parallel")} close  │  ↑↓ scroll`));
 
     // Apply scroll — use terminal rows as height estimate
     const termHeight = process.stdout.rows || 40;

package/src/resources/extensions/gsd/shortcut-defs.ts

@@ -0,0 +1,49 @@
+// Canonical GSD shortcut definitions used by registration, help text, and overlays.
+
+import { formatShortcut } from "./files.js";
+
+export type GSDShortcutId = "dashboard" | "notifications" | "parallel";
+
+type GSDShortcutDef = {
+  key: "g" | "n" | "p";
+  action: string;
+  command: string;
+};
+
+export const GSD_SHORTCUTS: Record<GSDShortcutId, GSDShortcutDef> = {
+  dashboard: {
+    key: "g",
+    action: "Open GSD dashboard",
+    command: "/gsd status",
+  },
+  notifications: {
+    key: "n",
+    action: "Open notification history",
+    command: "/gsd notifications",
+  },
+  parallel: {
+    key: "p",
+    action: "Open parallel worker monitor",
+    command: "/gsd parallel watch",
+  },
+};
+
+function combo(prefix: "Ctrl+Alt+" | "Ctrl+Shift+", key: string): string {
+  return `${prefix}${key.toUpperCase()}`;
+}
+
+export function primaryShortcutCombo(id: GSDShortcutId): string {
+  return combo("Ctrl+Alt+", GSD_SHORTCUTS[id].key);
+}
+
+export function fallbackShortcutCombo(id: GSDShortcutId): string {
+  return combo("Ctrl+Shift+", GSD_SHORTCUTS[id].key);
+}
+
+export function shortcutPair(id: GSDShortcutId, formatter: (combo: string) => string = (combo) => combo): string {
+  return `${formatter(primaryShortcutCombo(id))} / ${formatter(fallbackShortcutCombo(id))}`;
+}
+
+export function formattedShortcutPair(id: GSDShortcutId): string {
+  return shortcutPair(id, formatShortcut);
+}

package/src/resources/extensions/gsd/tests/forensics-stuck-loops.test.ts

@@ -101,3 +101,65 @@ test("#1943 detectStuckLoops ignores watchdog duplicates but flags real re-dispa
   assert.equal(anomalies.length, 1, `expected 1 anomaly (for the 3x dispatched task), got ${anomalies.length}`);
   assert.ok(anomalies[0].summary.includes("3 times"));
 });
+
+test("#3760 detectStuckLoops ignores cross-session recovery re-dispatches", () => {
+  const anomalies: ForensicAnomaly[] = [];
+
+  const units: UnitMetrics[] = [
+    makeUnit({
+      type: "plan-slice",
+      id: "M001/S02",
+      startedAt: 1000,
+      finishedAt: 2000,
+      autoSessionKey: "session-a",
+    }),
+    makeUnit({
+      type: "plan-slice",
+      id: "M001/S02",
+      startedAt: 5000,
+      finishedAt: 6000,
+      autoSessionKey: "session-b",
+    }),
+  ];
+
+  detectStuckLoops(units, anomalies);
+
+  assert.equal(anomalies.length, 0, "cross-session recovery should not be flagged as a stuck loop");
+});
+
+test("#3760 detectStuckLoops still flags repeated dispatches within one auto session", () => {
+  const anomalies: ForensicAnomaly[] = [];
+
+  const units: UnitMetrics[] = [
+    makeUnit({
+      type: "complete-slice",
+      id: "M011/S02",
+      startedAt: 1000,
+      finishedAt: 2000,
+      autoSessionKey: "session-a",
+    }),
+    makeUnit({
+      type: "complete-slice",
+      id: "M011/S02",
+      startedAt: 5000,
+      finishedAt: 6000,
+      autoSessionKey: "session-a",
+    }),
+    makeUnit({
+      type: "complete-slice",
+      id: "M011/S02",
+      startedAt: 9000,
+      finishedAt: 10000,
+      autoSessionKey: "session-b",
+    }),
+  ];
+
+  detectStuckLoops(units, anomalies);
+
+  assert.equal(anomalies.length, 1, "within-session retries should still be flagged");
+  assert.ok(anomalies[0].summary.includes("2 times"), `summary should reflect the worst same-session loop: ${anomalies[0].summary}`);
+  assert.ok(
+    anomalies[0].details.includes("Cross-session recovery runs are ignored"),
+    `details should explain the session-aware rule: ${anomalies[0].details}`,
+  );
+});

package/src/resources/extensions/gsd/tests/format-shortcut.test.ts

@@ -4,6 +4,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { formatShortcut } from '../files.ts';
+import { formattedShortcutPair, primaryShortcutCombo, fallbackShortcutCombo } from '../shortcut-defs.ts';
 
 // ─── formatShortcut renders per-platform shortcuts ──────────────────────
 
@@ -67,3 +68,17 @@ test('formatShortcut: passes through plain key names', () => {
   assert.strictEqual(formatShortcut('Escape'), 'Escape');
   assert.strictEqual(formatShortcut('Enter'), 'Enter');
 });
+
+test("shortcut-defs: exposes canonical dashboard combos", () => {
+  assert.equal(primaryShortcutCombo("dashboard"), "Ctrl+Alt+G");
+  assert.equal(fallbackShortcutCombo("dashboard"), "Ctrl+Shift+G");
+});
+
+test("shortcut-defs: formats shortcut pair using platform symbols", () => {
+  const pair = formattedShortcutPair("notifications");
+  if (process.platform === "darwin") {
+    assert.equal(pair, "⌃⌥N / ⌃⇧N");
+  } else {
+    assert.equal(pair, "Ctrl+Alt+N / Ctrl+Shift+N");
+  }
+});