@@ -246,6 +246,20 @@ timestamps, suspect a stamps/lines desync before suspecting `separatorForRange()
   misleading. If you add another notice type, leave `boundary` off it unless it genuinely
   marks the start of a run.
 
+Two traps that both hid boundaries, worth knowing because neither looks like a boundary bug:
+
+- **Gaps must be measured against the nearest *real* timestamp, not `stamps[i-1]`.** Notices
+  carry no timestamp (`NaN`), and `NaN` on either side of a subtraction makes the delta `NaN`,
+  so the lull *spanning* a notice vanished. That killed exactly the boundary you most want: the
+  one between the pre-reset run and the post-reset run, with the reset notice sitting in the
+  middle. `prevFiniteStamp()` walks back past stampless entries (capped, so it can't go
+  quadratic).
+- **The anti-stacking guard in `buildRows()` must not suppress a boundary behind a notice.** It
+  originally read `if (sep && !(prevRow && prevRow.sep))`, which was right when only run/idle
+  rules were `sep` rows — but notices became `sep` rows too, so a reset notice silently ate the
+  idle rule for the gap right after it. They now merge: the notice row is upgraded to
+  `boundary: true` and the idle/clock detail is appended to its label.
+
 `jumpToBoundary()` keeps its own `lastBoundaryRow` rather than reading `state.scroll` back,
 because a boundary inside the final page can't reach the top -- render clamps scroll to
 `maxScroll`. Measuring the next jump from the clamped position would silently skip that
 
@@ -4,6 +4,30 @@ All notable changes to `nplog` are documented here. Versions follow
 [Semantic Versioning](https://semver.org/): MAJOR for breaking CLI/output changes, MINOR for
 new features, PATCH for fixes. Check the current version with `nplog --version`.
 
+## [1.3.0] - 2026-07-30
+
+Startup in `--plugin` mode is a common case that read badly: the file already contains the tail
+of a run that began before nplog did, and `←`/`→` reported no boundaries even after triggering a
+command. Three fixes, two of them real bugs:
+
+- **`--plugin` now book-ends the seeded history.** A rule marks where the retained output starts
+  (NotePlan overwrites the file each run, so nothing earlier survives) and another marks
+  `nplog started watching here -- <clock>`. The second is a navigable boundary, so `←` has
+  somewhere useful to land immediately — "show me only what I actually watched" — rather than
+  reporting nothing at all.
+- **Fixed: a lull spanning an entry with no timestamp went undetected.** Idle gaps compared
+  strictly against the immediately-preceding entry, so a `NaN` stamp on either side produced a
+  `NaN` delta. nplog's own notices carry no timestamp, which meant the notice sitting between a
+  `--plugin` reset and the new run's first line hid the single most useful boundary in the
+  buffer. Gaps are now measured against the nearest real timestamp, walking past stampless
+  entries.
+- **Fixed: a notice rule swallowed the boundary immediately after it.** The anti-stacking guard
+  in `buildRows()` suppressed a rule whenever one already sat directly above — correct for two
+  run/idle rules, but since 1.1.2 notices are rules too, so the reset notice silently ate the
+  idle rule for the very gap that separates the old run from the new one. They now **merge**
+  into one navigable rule carrying both facts:
+  `─── _MCP-console.log was reset by NotePlan (new run)   2026-07-30 17:40:36  1h40m idle ───`
+
 ## [1.2.0] - 2026-07-30
 
 - **`←` / `→` jump between run boundaries**, scrolling the previous/next one to the top of the
 
@@ -274,12 +274,16 @@ The footer shows where you landed:
 
 `←` goes back in time, `→` forward. Both stop at the ends rather than wrapping, and say so.
 
-Only the [run and idle rules](#run-separators) count as boundaries. The `--plugin` mode
-[reset notice](#--plugin-fastest-data-for-one-plugin) deliberately does **not** — NotePlan
-rewriting `_MCP-console.log` is a file-truncation artifact, and it doesn't reliably line up
-with a new run, so jumping to one would land you somewhere misleading. In `--plugin` mode that
-leaves idle lulls as the only boundaries, since
-[named-run rules never appear there](#--plugin-fastest-data-for-one-plugin).
+Only the [run and idle rules](#run-separators) count as boundaries — plus the
+`nplog started watching here` rule in `--plugin` mode, so there's always somewhere to land even
+before the first reset. A bare `--plugin` reset notice deliberately does **not** count on its
+own: NotePlan rewriting `_MCP-console.log` is a file-truncation artifact that doesn't reliably
+line up with a new run. When a reset *does* coincide with a real idle gap — which is the normal
+case when you trigger a command — the two merge into one navigable rule carrying both facts:
+
+```
+───── _MCP-console.log was reset by NotePlan (new run)   2026-07-30 17:40:36  1h40m idle ─────
+```
 
 A boundary inside the final page can't literally reach the top — there aren't enough rows below
 it — so the view stops at the bottom while the footer still names the boundary you asked for.
@@ -499,6 +503,19 @@ or asks once if it can't tell, and remembers the answer in `~/.config/nplog/conf
 `NPLOG_APP_SUPPORT_DIR` yourself to override it (or skip `install.sh` and let auto-detection
 run every time).
 
+**What you see on startup.** The file already holds the tail of a run that began before nplog
+did, so that seeded content is book-ended to make it legible rather than looking like a normal
+complete run:
+
+```
+───── start of retained output -- NotePlan overwrites this file each run, so nothing earlier survives ─────
+  … whatever was already in the file …
+───── nplog started watching here -- 2026-07-30 17:40:31 ─────
+```
+
+The second rule is a [jump target](#jumping-between-runs), so `←` gets you to "only what I
+actually watched" straight away.
+
 If the plugin hasn't logged anything yet this session, `nplog` warns rather than erroring,
 and keeps watching for the file to appear:
 
 
@@ -87,7 +87,7 @@ const PLUGINS_DIR = path.join(CONTAINER_DIR, 'Plugins')
 // there and missing here. The main log is a strict superset and the only ground truth.
 
 // Bump this and add a matching entry to CHANGELOG.md for any user-visible change.
-const VERSION = '1.2.0'
+const VERSION = '1.3.0'
 
 const MAX_LINES = 50000 // ring-buffer cap; ~50k lines keeps memory modest
 const CONTEXT_MODES = [0, 1, 5, 10] // 0 == matched lines only
@@ -342,17 +342,29 @@ function pushLine(text, stampMs) {
 // array, deliberately: a second index-parallel array is exactly the shape
 // that produced the ^L stamps/lines desync bug (see AGENTS.md), and text
 // can't drift out of sync with itself. NUL never appears in log output, so
-// it's safe as a sentinel; strip it with noticeLabel() anywhere the text
+// it's safe as a sentinel; strip it with parseNotice() anywhere the text
 // escapes to a consumer (JSON, etc).
 const NOTICE_PREFIX = '\u0000notice\u0000'
 
-function pushNotice(label) {
-  pushLine(NOTICE_PREFIX + label)
+// Layout after the sentinel: one flag char ('B' = navigable boundary, '-' =
+// not) then the label. The flag rides along in the text for the same reason
+// the sentinel does -- no parallel array to fall out of sync.
+//
+// boundary=true only for notices that genuinely mark "a new stretch of work
+// starts here" and so are worth landing on with the arrow keys. A
+// _MCP-console.log reset is NOT one: it's a NotePlan file-rewrite artifact
+// that doesn't reliably coincide with a run.
+function pushNotice(label, boundary) {
+  pushLine(NOTICE_PREFIX + (boundary ? 'B' : '-') + label)
 }
 
-// Returns the human-readable label if `text` is a notice, else null.
-function noticeLabel(text) {
-  return text.startsWith(NOTICE_PREFIX) ? text.slice(NOTICE_PREFIX.length) : null
+// Returns {label, boundary} if `text` is one of nplog's notices, else null.
+function parseNotice(text) {
+  if (!text.startsWith(NOTICE_PREFIX)) return null
+  return {
+    boundary: text.charAt(NOTICE_PREFIX.length) === 'B',
+    label: text.slice(NOTICE_PREFIX.length + 1),
+  }
 }
 
 const INDENT_UNIT = 2 // spaces per nesting level
@@ -567,6 +579,28 @@ function separatorClock(ms) {
   return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`
 }
 
+// Not every entry has a parseable timestamp -- nplog's own notices carry
+// none, and neither does anything logged before the first timestamped line.
+// Comparing strictly against stamps[i-1] made a NaN on either side produce a
+// NaN delta, so a real lull *spanning* such an entry went undetected. That
+// bit hardest exactly where it mattered most: across a --plugin reset the
+// notice sits between the old run's last line and the new run's first, which
+// hid the single most useful boundary in the buffer. Walk back to the nearest
+// real stamp instead, so the gap is measured across the gap-less entry.
+//
+// Bounded because the scan is per-entry: a long stretch of stampless lines
+// would otherwise make this quadratic. Past the cap there is no usable
+// reference anyway, so reporting "no gap" is the honest answer.
+const MAX_STAMP_BACKSCAN = 50
+
+function prevFiniteStamp(i) {
+  const floor = Math.max(0, i - MAX_STAMP_BACKSCAN)
+  for (let k = i; k >= floor; k--) {
+    if (Number.isFinite(stamps[k])) return stamps[k]
+  }
+  return NaN
+}
+
 // What run/idle boundary falls in buffer entries [from..to], or null.
 //
 // A range rather than a single entry, because with a filter applied the run
@@ -591,7 +625,7 @@ function separatorForRange(from, to) {
       runIndex = i
     }
     if (state.idleGapMs > 0 && i > 0) {
-      const delta = stamps[i] - stamps[i - 1]
+      const delta = stamps[i] - prevFiniteStamp(i - 1)
       // widest lull in the range, so a filtered view reports the real one
       if (Number.isFinite(delta) && delta >= state.idleGapMs && delta > idleMs) idleMs = delta
     }
@@ -669,24 +703,38 @@ function buildRows() {
     }
     const sep = seps[i]
     const prevRow = rows.length > 0 ? rows[rows.length - 1] : null
-    if (sep && !(prevRow && prevRow.sep)) {
-      // A labelled rule says everything the anonymous skipped-lines rule does
-      // and more, so replace rather than stack the two.
-      if (prevRow && prevRow.gap) rows.pop()
+    if (sep) {
       // `boundary` marks the rules that represent a real break in the work --
       // an idle lull or an "Executing function" run start. That's what ←/→
-      // navigate between. Deliberately NOT set on the notice rows below: an
+      // navigate between. Notice rows (below) don't get it on their own: an
       // _MCP-console.log reset is a NotePlan file-rewrite artifact, not a
-      // reliable indicator that a new run began, so jumping to one would land
-      // you somewhere misleading.
-      rows.push({ sep: true, boundary: true, label: [sep.clock, sep.idle, sep.runText].filter(Boolean).join('  ') })
+      // reliable indicator that a new run began.
+      const label = [sep.clock, sep.idle, sep.runText].filter(Boolean).join('  ')
+      if (prevRow && prevRow.sep) {
+        // A rule already sits here, so don't stack a second one -- but don't
+        // silently drop this boundary either. That combination is exactly
+        // what a --plugin reset produces: the reset notice lands first and
+        // used to swallow the idle rule for the very gap that separates the
+        // old run from the new one, leaving the most useful boundary in the
+        // buffer unreachable with ←/→. Fold the detail into the existing rule
+        // and let it become navigable instead.
+        if (!prevRow.boundary) {
+          prevRow.boundary = true
+          if (label) prevRow.label = prevRow.label ? `${prevRow.label}   ${label}` : label
+        }
+      } else {
+        // A labelled rule says everything the anonymous skipped-lines rule
+        // does and more, so replace rather than stack the two.
+        if (prevRow && prevRow.gap) rows.pop()
+        rows.push({ sep: true, boundary: true, label })
+      }
     }
     // The rule already displays this entry's text, so don't repeat it below.
     if (sep && sep.runIndex === item.index) continue
     // nplog's own stream-boundary notices render as rules, not as log text.
-    const notice = noticeLabel(item.text)
+    const notice = parseNotice(item.text)
     if (notice !== null) {
-      rows.push({ sep: true, label: notice })
+      rows.push({ sep: true, boundary: notice.boundary, label: notice.label })
       continue
     }
     if (item.text.indexOf('\n') === -1) {
@@ -1472,7 +1520,7 @@ function streamPending(flush) {
         run: streamRun || null,
         // notice lines are nplog's own, not the plugin's -- emit the label
         // without the internal sentinel so consumers never see it
-        text: noticeLabel(text) ?? text,
+        text: (parseNotice(text) || {}).label ?? text,
       })}\n`,
     )
   }
@@ -1545,7 +1593,7 @@ function emitJson(file, waitInfo) {
       source: /^\[WebView/.test(e.text) ? 'webview' : 'plugin',
       run: e.run || null,
       // see streamPending: strip the internal notice sentinel before emitting
-      text: noticeLabel(e.text) ?? e.text,
+      text: (parseNotice(e.text) || {}).label ?? e.text,
     }
     process.stdout.write(`${JSON.stringify(rec)}\n`)
   }
@@ -1663,13 +1711,15 @@ function main() {
     process.exit(1)
   }
 
+  let pluginHadHistory = false
   if (opts.pluginMode) {
     let st = null
     try {
       st = fs.statSync(file)
     } catch (err) {
       // doesn't exist -- st stays null
     }
+    pluginHadHistory = Boolean(st && st.size > 0)
     if (!st || st.size === 0) {
       console.error(`nplog: ${file}`)
       console.error(st ? '       exists but is empty.' : "       doesn't exist yet.")
@@ -1692,7 +1742,20 @@ function main() {
     process.exit(1)
   }
 
+  // Whatever is already in a plugin's _MCP-console.log at startup is the tail
+  // of a run that was underway before nplog existed -- NotePlan overwrote
+  // anything earlier. Book-ending the seeded content makes that legible
+  // instead of looking like a normal, complete run: one notice for where the
+  // retained data starts, one for where live capture began. The second is a
+  // navigable boundary, so ← always has something to land on even before the
+  // first reset -- "show me only what I actually watched".
+  if (opts.pluginMode && pluginHadHistory) {
+    pushNotice('start of retained output -- NotePlan overwrites this file each run, so nothing earlier survives', false)
+  }
   openFile(file, true)
+  if (opts.pluginMode) {
+    pushNotice(`nplog started watching here -- ${separatorClock(Date.now())}`, true)
+  }
 
   out.write(`${ESC}[?1049h${ESC}[2J`) // alternate screen keeps the real scrollback clean
   process.stdin.setRawMode(true)