unsnooze 1.19.1 → 1.19.3

package/src/install.js

@@ -14,14 +14,14 @@
 import { readFileSync, writeFileSync, renameSync, existsSync, copyFileSync, rmSync, mkdirSync, unlinkSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { homedir, userInfo } from 'node:os';
-import { join, dirname, delimiter } from 'node:path';
-import { CLAUDE_SETTINGS, STATE_DIR, WINDOWS_TASK_NAME } from './config.js';
+import { join, dirname, basename, delimiter } from 'node:path';
+import { CLAUDE_SETTINGS, STATE_DIR, WINDOWS_TASK_NAME, DAEMON_ON_DEMAND } from './config.js';
 import { getConfig, configFileExists } from './settings.js';
 import { xmlEscape } from './notify.js';
 import { installGrokHooks, uninstallGrokHooks } from './agents/grok.js';
 import { getAgent } from './agents/index.js';
 import { findCsgProcesses, findCsgAutostarts } from './doctor.js';
-import { UNSNOOZE_BIN, stopResumer } from './spawn.js';
+import { UNSNOOZE_BIN, stopResumer, restartDaemon, stopDaemon } from './spawn.js';
 import { uninstallStatuslineShim } from './usage.js';
 import { powershellProfilePath } from './powershell.js';
 import { fishConfigPath } from './fish.js';
@@ -248,11 +248,12 @@ export function installFishBlock(content, agents = ['claude'], bin = UNSNOOZE_BI
 // GUI sessions (VS Code extension, desktop apps) never pass through the shell
 // wrappers, so their limit stops are only caught while `unsnooze daemon` is
 // alive. Autostart keeps it alive: a launchd user agent on macOS, a systemd
-// user unit on Linux/WSL.
+// user unit on Linux/WSL. Native Windows deliberately gets neither a unit nor
+// a Scheduled Task — the daemon is started on demand there (DAEMON_ON_DEMAND).
 
 export const DAEMON_LABEL = 'com.unsnooze.daemon';
-// Task Scheduler has no reverse-DNS convention and shows this name to the user
-// in taskschd.msc, so it is a plain word rather than the launchd label.
+// The Scheduled Task name unsnooze <= 1.19.1 used; kept for the uninstall that
+// removes one left behind.
 export { WINDOWS_TASK_NAME };
 
 // Is this process running under the supervisor we install, rather than from
@@ -269,14 +270,15 @@ export { WINDOWS_TASK_NAME };
 export function isSupervised({ platform = process.platform, env = process.env } = {}) {
   if (platform === 'darwin') return env.XPC_SERVICE_NAME === DAEMON_LABEL;
   if (platform === 'linux') return typeof env.INVOCATION_ID === 'string' && env.INVOCATION_ID !== '';
-  // win32 stays false on purpose, even though we now install a Scheduled Task.
-  // launchd KeepAlive and systemd Restart=always bring the daemon straight
-  // back; a logon-triggered task does not restart anything until the next
-  // logon. Answering true here would let the version-skew guard exit 0 into
-  // nothing and stop Windows watching silently — the exact failure mode of
-  // issue #8, just with a different trigger. The cost is that a Windows daemon
-  // keeps running pre-upgrade code until the user logs back in; that is the
-  // lesser of the two, and `unsnooze doctor` reports the skew.
+  // win32 stays false on purpose. launchd KeepAlive and systemd Restart=always
+  // bring the daemon straight back; on Windows it is only started again by the
+  // next wrapped launch or StopFailure hook, which may be hours away. Answering
+  // true here would let the version-skew guard exit 0 into nothing and stop
+  // Windows watching silently — the exact failure mode of issue #8, just with a
+  // different trigger. The cost is that a Windows daemon keeps running
+  // pre-upgrade code until it is restarted (a sign-out, or re-running
+  // `unsnooze install --daemon`); that is the lesser of the two, and
+  // `unsnooze doctor` reports the skew.
   return false;
 }
 
@@ -434,20 +436,49 @@ function defaultActivate(cmd, args) {
   }
 }
 
+// Native Windows keeps its "unit" in the state dir: a marker that asks for the
+// daemon to be started on demand. `dir` relocates it, as it does the unit dir
+// elsewhere.
+function onDemandMarker(dir) {
+  return dir ? join(dir, basename(DAEMON_ON_DEMAND)) : DAEMON_ON_DEMAND;
+}
+
+const ON_DEMAND_NOTE = 'While this file exists, the unsnooze daemon is started on demand — by the\n'
+  + 'agent wrappers and the StopFailure hook — whenever it is not running. Nothing\n'
+  + 'is registered to run at sign-in. `unsnooze uninstall` removes this file.\n';
+
+// unsnooze <= 1.19.1 registered the daemon as a logon Scheduled Task. Nothing
+// creates one now, but an install from then may still have it; uninstall
+// removes it. Ask before deleting, so a machine that never had one — most of
+// them: creating it needed an elevated shell — only ever sees a read-only
+// query. /f so the delete is not an interactive prompt. 'removed', 'stuck'
+// (it exists but the delete failed — a task created from an elevated shell
+// can need one to delete), or null when there was none.
+export function removeLegacyScheduledTask({ activate = defaultActivate } = {}) {
+  if (!activate('schtasks', ['/query', '/tn', WINDOWS_TASK_NAME])) return null;
+  return activate('schtasks', ['/delete', '/f', '/tn', WINDOWS_TASK_NAME]) ? 'removed' : 'stuck';
+}
+
 export function installDaemonAutostart({
   platform = process.platform, dir = null, activate = defaultActivate, path = undefined,
+  start = restartDaemon,
 } = {}) {
-  // Native Windows has no unit *file* — the Task Scheduler holds the record —
-  // so it is handled before the file-based platforms below. It matters more
-  // here than anywhere else: the transcript watcher lives in the daemon, and
-  // headless has no pane monitor to fall back on, so without this a Windows
-  // machine only ever catches limit stops through the StopFailure hook.
+  // Native Windows matters more than anywhere: the transcript watcher lives in
+  // the daemon, and headless has no pane monitor to fall back on. But nothing
+  // is registered with Windows to start it. Up to 1.19.1 this created a logon
+  // Scheduled Task (`schtasks /create /sc onlogon /tr "node … daemon"`), and
+  // Microsoft Defender flagged setup as Trojan:Win32/Commando.A!ml for it —
+  // an interpreter running a script from %APPDATA% at every logon is exactly
+  // how malware persists, and any logon entry (Run key, Startup folder) reads
+  // the same way. Without elevation schtasks refused the task anyway. So the
+  // daemon is started now, and started again on demand (spawn.js ensureDaemon).
   if (platform === 'win32') {
-    // /f overwrites an existing task rather than failing with "already exists",
-    // which is what re-running setup does every time.
-    activate('schtasks', ['/create', '/f', '/tn', WINDOWS_TASK_NAME, '/sc', 'onlogon',
-      '/tr', `"${process.execPath}" "${UNSNOOZE_BIN}" daemon`]);
-    return `Scheduled Task \\${WINDOWS_TASK_NAME}`;
+    const marker = onDemandMarker(dir);
+    atomicWrite(marker, ON_DEMAND_NOTE);
+    // Same interlock as the unit platforms below: the real starter only runs
+    // for the marker it would actually read.
+    if (start !== restartDaemon || marker === DAEMON_ON_DEMAND) start();
+    return marker;
   }
   const target = autostartUnitPath({ platform, dir });
   if (!target) return null;
@@ -528,11 +559,30 @@ export function healDaemonAutostart({
   return installDaemonAutostart({ platform, dir, activate, path: better });
 }
 
-export function uninstallDaemonAutostart({ platform = process.platform, dir = null, activate = defaultActivate } = {}) {
+export function uninstallDaemonAutostart({
+  platform = process.platform, dir = null, activate = defaultActivate, stop = stopDaemon,
+  say = () => {},
+} = {}) {
   if (platform === 'win32') {
-    // /f so a missing task is not an interactive prompt on an uninstall path.
-    activate('schtasks', ['/delete', '/f', '/tn', WINDOWS_TASK_NAME]);
-    return `Scheduled Task \\${WINDOWS_TASK_NAME}`;
+    const removed = [];
+    // The marker first, so nothing starts the daemon again once it is stopped
+    // (and an on-demand daemon that is only now starting sees it gone).
+    const marker = onDemandMarker(dir);
+    if (existsSync(marker)) {
+      try { unlinkSync(marker); removed.push(marker); } catch { /* still there — not reported as removed */ }
+    }
+    const live = marker === DAEMON_ON_DEMAND;
+    if (stop !== stopDaemon || live) stop();
+    // The interlock again: a relocated marker is a fixture, and the machine's
+    // real Task Scheduler is none of its business.
+    const act = (activate === defaultActivate && !live) ? () => false : activate;
+    const legacy = removeLegacyScheduledTask({ activate: act });
+    if (legacy === 'removed') removed.push(`Scheduled Task \\${WINDOWS_TASK_NAME}`);
+    else if (legacy === 'stuck') {
+      say(`could not delete the Scheduled Task \\${WINDOWS_TASK_NAME} an earlier version created; `
+        + `from an administrator shell run: schtasks /delete /tn ${WINDOWS_TASK_NAME} /f`);
+    }
+    return removed.length ? removed.join(' and ') : null;
   }
   if (platform === 'darwin') {
     const target = join(dir || autostartDir(platform), `${DAEMON_LABEL}.plist`);
@@ -696,8 +746,21 @@ export function cmdInstall(rest, { agents = enabledAgents() } = {}) {
 
   // 4. Daemon autostart (GUI-session watching), opt-in via --daemon / wizard.
   if (opts.daemon) {
-    const target = installDaemonAutostart();
-    if (target) console.log(`unsnooze: daemon autostart installed (${target}) — GUI sessions are watched`);
+    // On Windows the start's outcome is kept, so the message can be honest.
+    let started = null;
+    const target = installDaemonAutostart(process.platform === 'win32'
+      ? { start: () => { started = restartDaemon(); } } : {});
+    if (target && process.platform === 'win32') {
+      if (started) console.log(`unsnooze: daemon started in the background (pid ${started}) — GUI sessions are watched`);
+      else console.log('unsnooze: the daemon did not start — run `unsnooze daemon` to see why');
+      console.log('unsnooze: nothing is registered to run at sign-in (no Scheduled Task); your wrapped');
+      console.log('unsnooze: agents and the Claude hook start the daemon again whenever it is not running');
+      // A task left by 1.19.1 or earlier is deliberately not looked for here:
+      // node.exe spawning schtasks.exe is the pairing Defender reacted to, and
+      // setup should spawn nothing of the kind. Such a task only starts this
+      // same daemon at sign-in, which the pidfile tolerates; uninstall removes
+      // it.
+    } else if (target) console.log(`unsnooze: daemon autostart installed (${target}) — GUI sessions are watched`);
     else console.log('unsnooze: daemon autostart is not supported on this platform');
   }
 
@@ -724,7 +787,16 @@ export function cmdUninstall(rest) {
   const opts = parseArgs(rest);
   const explicitRc = rest.includes('--zshrc');
 
-  // Stop the resumer/daemon first so it cannot keep writing state after hooks
+  // Whatever starts the daemon goes first — the launchd/systemd unit, or on
+  // Windows the marker the wrappers and the hook consult — so nothing can
+  // start it again mid-uninstall. On Windows this order also stops the daemon
+  // while its pidfile still proves which process it is, not after
+  // stopResumer has killed it and left a pid that may already be someone
+  // else's.
+  const autostart = uninstallDaemonAutostart({ say: m => console.log(`unsnooze: ${m}`) });
+  if (autostart) console.log(`unsnooze: daemon autostart removed (${autostart})`);
+
+  // Stop the resumer/daemon so it cannot keep writing state after hooks
   // are gone (zombie-daemon-running-deleted-code failure mode).
   try {
     const result = stopResumer();
@@ -780,9 +852,6 @@ export function cmdUninstall(rest) {
     }
   }
 
-  const autostart = uninstallDaemonAutostart();
-  if (autostart) console.log(`unsnooze: daemon autostart removed (${autostart})`);
-
   // Restore Claude statusLine if our usage shim was chained in.
   try {
     const r = uninstallStatuslineShim({ settingsPath: opts.settings });

package/src/launcher.js

@@ -8,7 +8,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { getMultiplexer } from './multiplexer.js';
 import { getAgent } from './agents/index.js';
 import { getConfig, resolveLaunchExtraArgs } from './settings.js';
-import { spawnDetached, monitorSpawnArgs } from './spawn.js';
+import { spawnDetached, monitorSpawnArgs, ensureDaemon } from './spawn.js';
 import { makeLogger } from './logger.js';
 import { createLeaseId, processBirth, writeLease, removeLease } from './lease.js';
 import { recordOwnedSession } from './mux-sessions.js';
@@ -36,6 +36,16 @@ export function resolvePaneOwner(muxName, env = process.env) {
   return null;
 }
 
+// A headless revival runs this launcher detached, with no console and no
+// terminal on any stdio. On Windows the agent would then be given a console
+// window of its own — an empty window popping up on the desktop at every
+// reset, which closing kills the revival. Hide it there. Whenever a terminal
+// is attached nothing changes: the agent, a console program, shares the
+// launcher's console, and windowsHide only affects a console Windows creates.
+export function hideAgentWindow(streams = process) {
+  return !(streams.stdin?.isTTY || streams.stdout?.isTTY || streams.stderr?.isTTY);
+}
+
 function runUnwatched(agent, args, reason) {
   if (reason) process.stderr.write(`unsnooze: ${reason}\n`);
   return runPassthrough(agent, args);
@@ -49,7 +59,9 @@ function runPassthrough(agent, args) {
   return r.status ?? 1;
 }
 
-export function runLauncher(args, agentId = 'claude', { processBirthFn = processBirth } = {}) {
+export function runLauncher(args, agentId = 'claude', {
+  processBirthFn = processBirth, ensureDaemonFn = ensureDaemon,
+} = {}) {
   const agent = getAgent(agentId);
 
   // Recursion / nested-launch guard: inside an unsnooze-managed session, a
@@ -122,6 +134,12 @@ export function runLauncher(args, agentId = 'claude', { processBirthFn = process
     }
   }
 
+  // Nothing keeps the daemon running on native Windows (see ensureDaemon), so
+  // every watched launch makes sure it is. Here, past the re-exec above, so a
+  // launch that wraps itself asks once, not twice. A no-op everywhere else,
+  // and until `install --daemon` has asked for the daemon.
+  ensureDaemonFn();
+
   const rawPane = mux.currentPaneId();
   const paneOwner = resolvePaneOwner(mux.name, process.env);
   // A backend may know it cannot safely address the pane it is sitting in —
@@ -179,7 +197,7 @@ export function runLauncher(args, agentId = 'claude', { processBirthFn = process
   // the reason, never as a crash with no exit code for the resumer to read.
   let child;
   try {
-    child = spawn(agent.bin, args, { stdio: 'inherit', env: childEnv });
+    child = spawn(agent.bin, args, { stdio: 'inherit', env: childEnv, windowsHide: hideAgentWindow() });
   } catch (err) {
     return launchFailed(agent, err);
   }

package/src/monitor.js

@@ -18,12 +18,14 @@ import {
 } from './config.js';
 import { detectLimit, isBusy, overloadMatch, modelRemedy } from './patterns.js';
 import { getAgent } from './agents/index.js';
+import { pendingCodexPrompt } from './agents/codex.js';
 import { getConfig } from './settings.js';
 import { notify } from './notify.js';
 import { parseResetTime, resetAtMs, sourceRank } from './time-parser.js';
 import { upsertSession, setStatus, readState, updateState } from './state.js';
 import { prepareCalibrationSample, applyCalibrationToState } from './usage.js';
 import { latestRateLimitFromTranscript } from './watchers/claude.js';
+import { hasCodexProgressAfter } from './watchers/codex.js';
 import { spawnResumerIfNeeded, spawnDetached, monitorSpawnArgs, UNSNOOZE_BIN } from './spawn.js';
 import { restartOnVersionSkew, hasVersionSkew, PKG_VERSION } from './update-check.js';
 import { makeLogger } from './logger.js';
@@ -327,6 +329,16 @@ export function createMonitor({
     const visible = mux.capturePaneVisible
       ? await mux.capturePaneVisible(pane).catch(() => '')
       : text;
+    if (agent.id === 'codex' && Object.values(readState().sessions).some(rec =>
+      rec.agent === 'codex' && rec.mux === muxName && rec.pane === pane
+      && rec.paneOwner === paneOwner && (rec.leaseId ?? null) === leaseId
+      && ['resuming', 'failed'].includes(rec.status)
+      && pendingCodexPrompt(visible, rec.pendingPrompt))) {
+      // The resumer owns this unsubmitted draft. Its old banner is not a new
+      // stop; refreshing detectedAt here would invalidate the submit retry.
+      firstTick = false;
+      return;
+    }
     if (agent.menu && agent.menu.isPrompt(visible, PANE_SCAN_LINES)) {
       if (!getConfig('menuAutoAnswer')) {
         // Watch-only mode: record the stop (reset time may not be visible
@@ -399,17 +411,21 @@ export function createMonitor({
     }
 
     // A banner leaving the 12-line scan is not evidence of a resume: ordinary
-    // output (including background-agent notices) can scroll it away. Claude
-    // is terminal only after its parent transcript records newer non-error
-    // assistant usage. Other adapters retain their legacy behavior until they
-    // expose an equally authoritative progress signal.
+    // output (including background-agent notices) can scroll it away, and in
+    // Codex a keypress or tab switch can hide it while the session is still
+    // stopped. Claude is terminal only after its parent transcript records
+    // newer non-error assistant usage; Codex only after its rollout records
+    // newer model output (or, with no rollout to read, the legacy rule).
+    // Other adapters retain their legacy behavior until they expose an
+    // equally authoritative progress signal.
     if (trackedKey) {
       const state = readState();
       const rec = state.sessions[trackedKey];
       if (rec && rec.status === 'stopped') {
         const cutoff = rec.bannerAt ?? rec.detectedAt;
-        const progressed = agent.id !== 'claude'
-          || hasClaudeParentUsageAfter(rec, cutoff);
+        const progressed = agent.id === 'claude' ? hasClaudeParentUsageAfter(rec, cutoff)
+          : agent.id === 'codex' ? hasCodexProgressAfter(rec, cutoff) !== false
+            : true;
         if (progressed) {
           const next = setStatus(trackedKey, 'resumed', {
             lastAttemptAt: Date.now(), bannerCleared: true, lastError: null,

package/src/patterns.js

@@ -96,6 +96,25 @@ function quotedLineFlags(lines) {
   return flags;
 }
 
+// A banner the terminal soft-wraps continues on the next rows until its
+// closing punctuation. Codex writes one long line, so at some widths the
+// reset clock lands on a later row than the phrase that introduces it:
+//   "... or try" / "again at 6:02 PM."    "... try again at 6:02" / "PM."
+// Rejoin those rows. Stop at a blank row, at the next TUI glyph, or once the
+// sentence has ended, so a footer hint below the banner is never absorbed.
+const WRAP_MAX_ROWS = 3;
+const NEW_BLOCK = /^\s*[›•■⏺⚠>]/;
+function joinWrapped(lines, idx) {
+  let joined = lines[idx].trim();
+  for (let j = idx + 1; j <= idx + WRAP_MAX_ROWS && j < lines.length; j++) {
+    if (/[.!?]$/.test(joined)) break;
+    const next = lines[j].trim();
+    if (!next || NEW_BLOCK.test(lines[j])) break;
+    joined += ` ${next}`;
+  }
+  return joined;
+}
+
 export function detectLimit(text, tailLines = 12, sets = claudePatterns) {
   const lines = contentLines(text, tailLines);
 
@@ -138,7 +157,10 @@ export function detectLimit(text, tailLines = 12, sets = claudePatterns) {
   // Most recent reset line wins (the TUI never clears old banners from scrollback).
   let resetLine = null;
   for (let i = lines.length - 1; i >= 0; i--) {
-    if (sets.resetPatterns.some(p => p.test(lines[i]))) { resetLine = lines[i].trim(); break; }
+    if (sets.resetPatterns.some(p => p.test(lines[i]))) {
+      resetLine = sets.bannerWraps ? joinWrapped(lines, i) : lines[i].trim();
+      break;
+    }
   }
   if (!resetLine) {
     for (let i = lines.length - 1; i >= 0; i--) {

package/src/resumer.js

@@ -16,6 +16,7 @@ import {
 } from './config.js';
 import { detectLimit, isBusy, modelRemedy } from './patterns.js';
 import { getAgent } from './agents/index.js';
+import { pendingCodexPrompt } from './agents/codex.js';
 import { parseResetTime, resetAtMs, nextProbeDelayMs } from './time-parser.js';
 import {
   readState, updateState, setStatus, dueSessions, activeStopped,
@@ -224,7 +225,7 @@ function paneStopOwner(rec, state = readState()) {
 // One live pane can accept one wake. Legacy/subagent detections outside the
 // short ingest-dedupe window are therefore collapsed here: the newest active
 // stop owns the target and older active records become explicit history.
-function claimStopForResume(rec) {
+function claimStopForResume(rec, pendingPrompt = null) {
   const cutoff = stopEpisodeAt(rec);
   let claimed = false;
   updateState(state => {
@@ -254,6 +255,7 @@ function claimStopForResume(rec) {
         // single point where unsnooze takes ownership of a stop, whether the
         // wake is typed, driven through the menu, or reopened.
         resumedBy: 'unsnooze',
+        pendingPrompt, submitRetries: 0,
       });
       claimed = true;
     }
@@ -713,7 +715,7 @@ export async function dispatchOne(rec, {
       // assessPane is asynchronous. Close the final human/provider-resume race
       // after assessment and immediately before the keystroke.
       if (finishIfClaudeProgressed(rec, agent)) return 'already-resumed';
-      if (!claimStopForResume(rec)) return 'stale';
+      if (!claimStopForResume(rec, agent.id === 'codex' ? resumeMessage : null)) return 'stale';
       await mux.sendText(rec.pane, resumeMessage);
       log(`${key}: sent continue via ${rec.mux} ${rec.paneOwner ?? '-'}:${rec.pane}`);
       notifyContext();
@@ -874,11 +876,11 @@ function recordVerifyRetry(rec, lastError) {
   let applied;
   if (verifyRetries >= MAX_VERIFY_RETRIES) {
     const attempts = (rec.attempts || 0) + 1;
-    applied = transitionStopEpisode(rec, 'stopped', {
+    applied = transitionStopEpisode(rec, rec.pendingPrompt ? 'failed' : 'stopped', {
       attempts,
       // Same backoff (and same manual exemption) as routed retries.
       resetAt: rec.manual ? Date.now() : Date.now() + retryBackoffMs(attempts),
-      lastError,
+      lastError: rec.pendingPrompt ? `${lastError} — wake submission unconfirmed; inspect the Codex pane` : lastError,
       verifyRetries: 0, resumeEpisodeAt: null,
     }, { expect: ['resuming'] });
   } else {
@@ -917,6 +919,29 @@ export async function verifyOne(key, { resolveMux = resolveRecordMux } = {}) {
   catch (err) {
     return recordVerifyRetry(rec, `verify capture: ${err.message}`);
   }
+  // A delayed TUI can process text and Enter as a single paste burst (#30).
+  // Recover only our exact draft, never type it again or treat the banner
+  // above it as a fresh refusal. Re-check the normal ownership/busy gates
+  // and the stop episode immediately before every additional Enter.
+  if (agent.id === 'codex' && pendingCodexPrompt(text, rec.pendingPrompt)) {
+    const a = await assessPane(rec, agent, { mux });
+    const current = readState().sessions[key];
+    if (!current || current.status !== 'resuming' || !samePaneTarget(current, rec)
+      || stopEpisodeAt(current) !== stopEpisodeAt(rec)) return 'stale';
+    if (a.busy) return 'pending';
+    if ((rec.submitRetries || 0) >= 3 || !a.authorized || typeof mux.sendKey !== 'function') {
+      transitionStopEpisode(rec, 'failed', {
+        lastError: 'wake prompt not submitted — inspect the Codex pane and press Enter to continue',
+      }, { expect: ['resuming'] });
+      return 'held';
+    }
+    if (!pendingCodexPrompt(a.text, rec.pendingPrompt)) return 'pending';
+    if (!transitionStopEpisode(rec, 'resuming', { submitRetries: (rec.submitRetries || 0) + 1 },
+      { expect: ['resuming'] })) return 'stale';
+    try { await mux.sendKey(rec.pane, 'Enter'); }
+    catch (err) { log(`${key}: submit retry failed: ${err.message}`); }
+    return 'pending';
+  }
   const d = detectLimit(text, PANE_SCAN_LINES, agent.patterns);
   if (d.hit || (agent.menu && agent.menu.isPrompt(text, PANE_SCAN_LINES))) {
     // Limit not actually reset — reschedule from the fresh banner.