claude-usage-limits 1.26.0 → 1.39.2

package/skills/usage-limits/scripts/relay.js

@@ -94,6 +94,11 @@ const DEFAULTS = {
   // it is also how you find out in the morning that nothing happened and have
   // no idea why.
   show: true,
+  // The hand-off carries how the user writes, so the resumed session answers
+  // in their voice without being reminded; and it asks for the two bug passes
+  // the user asks for on nearly every request. Both can be turned off.
+  voice: true,
+  bugcheck: 'on',
   // What happens after a wake fails for a reason that will not fix itself:
   // arm again for the next window, or stop and leave it to a person.
   onFailure: 'rearm',
@@ -191,9 +196,159 @@ function read() {
     config: parsed.config && typeof parsed.config === 'object' && !Array.isArray(parsed.config) ? parsed.config : {},
     armed: parsed.armed && typeof parsed.armed === 'object' && !Array.isArray(parsed.armed) ? parsed.armed : null,
     history: Array.isArray(parsed.history) ? parsed.history.slice(-10) : [],
+    ...(Array.isArray(parsed.others) && parsed.others.length
+      ? { others: parsed.others.filter((r) => r && typeof r === 'object' && !Array.isArray(r) && r.id) }
+      : {}),
   };
 }
 
+/* ------------------------------------------------- more than one session -- */
+
+// state.armed is the record armed first; every further session's record waits
+// in state.others, each with its own scheduled task. Two sessions arming on
+// the same night is the normal case (the plugin was tried ten times before
+// this and one of the failures was the second session being refused), so
+// nothing displaces anything: a session can only replace or cancel its own.
+function records(state) {
+  return [state && state.armed, ...(state && Array.isArray(state.others) ? state.others : [])].filter(Boolean);
+}
+function armedFor(state, id) {
+  if (!id) return null;
+  return records(state).find((r) => r && r.id === id) || null;
+}
+function putRecord(state, record) {
+  if (!state.armed || state.armed.id === record.id) { state.armed = record; return; }
+  const rest = (Array.isArray(state.others) ? state.others : []).filter((r) => r.id !== record.id);
+  rest.push(record);
+  state.others = rest;
+}
+function dropRecord(state, id) {
+  const rest = Array.isArray(state.others) ? state.others.filter((r) => r.id !== id) : [];
+  if (state.armed && state.armed.id === id) state.armed = rest.shift() || null;
+  if (rest.length) state.others = rest;
+  else delete state.others;
+}
+
+/* ------------------------------------------------- what stops a resume ---- */
+
+// Claude Code asks two questions on a start nobody is there to answer at four
+// in the morning: whether to trust the folder, and whether bypass permissions
+// is really meant. Both answers live in .claude.json. The folder key is spelled
+// the way the CLI that wrote it spelled it - on the machine this was written
+// on, both C:/x and C:\x keys exist for the same folder - so every spelling
+// gets the answer. This is what stopped the relay on 2026-09-20: the window
+// opened, the trust question appeared, and the wake waited forever.
+function claudeJsonFile() {
+  if (process.env.CLAUDE_CONFIG_DIR) return path.join(process.env.CLAUDE_CONFIG_DIR, '.claude.json');
+  return path.join(os.homedir(), '.claude.json');
+}
+function projectKeys(cwd) {
+  const raw = String(cwd || '').replace(/[\\/]+$/, '');
+  if (!raw) return [];
+  const fwd = raw.replace(/\\/g, '/');
+  const back = raw.replace(/\//g, '\\');
+  return [...new Set(process.platform === 'win32' ? [raw, fwd, back] : [raw])];
+}
+// Claude Code never writes trust for the home folder itself (its security
+// page says so, and 2026-09-20 proved it), so a session that lives in $HOME
+// is resumed from a small folder under the config dir that can be trusted,
+// with --add-dir pointing back at the real one. --resume <id> finds the
+// transcript from anywhere on 2.1.223 and later.
+function isHome(dir) {
+  const norm = (p) => String(p || '').replace(/[\\/]+$/, '').replace(/\\/g, '/').toLowerCase();
+  return Boolean(dir) && norm(dir) === norm(os.homedir());
+}
+function launchDirFor(cwd) {
+  if (!isHome(cwd)) return cwd;
+  const dir = path.join(configDir(), 'relay-cwd');
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch (err) {
+  }
+  return dir;
+}
+function readSettings() {
+  try {
+    return JSON.parse(fs.readFileSync(settingsFile(), 'utf8').replace(/^\uFEFF/, ''));
+  } catch (err) {
+    return null;
+  }
+}
+function settingIs(key, value) {
+  const parsed = readSettings();
+  return Boolean(parsed) && parsed[key] === value;
+}
+function applySetting(key, value) {
+  const file = settingsFile();
+  let raw = null;
+  let parsed = {};
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+    parsed = JSON.parse(raw.replace(/^\uFEFF/, ''));
+  } catch (err) {
+    if (raw !== null) return { changed: false, error: 'settings.json is not readable JSON; left untouched' };
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return { changed: false, error: 'settings.json is not an object; left untouched' };
+  if (parsed[key] === value) return { changed: false };
+  parsed[key] = value;
+  try {
+    fs.mkdirSync(configDir(), { recursive: true });
+    if (raw !== null) fs.writeFileSync(file + '.bak-usage-limits', raw);
+    fs.writeFileSync(file, JSON.stringify(parsed, null, 2) + '\n');
+  } catch (err) {
+    return { changed: false, error: err.message };
+  }
+  return { changed: true, file };
+}
+
+function preflightPrompts(cwd, config, options) {
+  const file = claudeJsonFile();
+  let raw = null;
+  let parsed = {};
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+    parsed = JSON.parse(raw.replace(/^\uFEFF/, ''));
+  } catch (err) {
+    if (raw !== null) return { ok: false, file, error: file + ' is not readable JSON; left untouched', changes: [] };
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return { ok: false, file, error: file + ' is not an object; left untouched', changes: [] };
+  const changes = [];
+  if (!parsed.projects || typeof parsed.projects !== 'object' || Array.isArray(parsed.projects)) parsed.projects = {};
+  for (const key of projectKeys(cwd)) {
+    const entry = parsed.projects[key];
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+      parsed.projects[key] = { allowedTools: [], hasTrustDialogAccepted: true };
+      changes.push('folder trust for ' + key);
+    } else if (entry.hasTrustDialogAccepted !== true) {
+      entry.hasTrustDialogAccepted = true;
+      changes.push('folder trust for ' + key);
+    }
+  }
+  if (config && config.permissionMode === 'bypassPermissions' && parsed.bypassPermissionsModeAccepted !== true) {
+    parsed.bypassPermissionsModeAccepted = true;
+    changes.push('bypass permissions accepted');
+  }
+  // The current build gates that dialog on settings.json instead.
+  if (config && config.permissionMode === 'bypassPermissions') {
+    if (options && options.dry) {
+      if (!settingIs('skipDangerousModePermissionPrompt', true)) changes.push('skipDangerousModePermissionPrompt in settings.json');
+    } else {
+      const skipped = applySetting('skipDangerousModePermissionPrompt', true);
+      if (skipped.changed) changes.push('skipDangerousModePermissionPrompt in settings.json');
+    }
+  }
+  if (raw === null) changes.push('created ' + file);
+  if (!changes.length || (options && options.dry)) return { ok: true, file, changes, dry: Boolean(options && options.dry) };
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    if (raw !== null) fs.writeFileSync(file + '.bak-usage-limits', raw);
+    writeAtomic(file, JSON.stringify(parsed, null, 2) + '\n');
+  } catch (err) {
+    return { ok: false, file, error: err.message, changes: [] };
+  }
+  return { ok: true, file, changes, backup: raw !== null ? file + '.bak-usage-limits' : null };
+}
+
 // Written to a sibling and renamed into place. Two hooks can run at once, and a
 // reader that lands between the truncate and the write of a plain writeFileSync
 // sees half a file; the rename is the only step another process can observe.
@@ -250,6 +405,8 @@ function settings(state) {
     offlineAttempts: Math.min(48, Math.max(1, number(stored.offlineAttempts, DEFAULTS.offlineAttempts))),
     offlineRetryMinutes: Math.min(120, Math.max(2, number(stored.offlineRetryMinutes, DEFAULTS.offlineRetryMinutes))),
     show: bool(stored.show, DEFAULTS.show),
+    voice: bool(stored.voice, DEFAULTS.voice),
+    bugcheck: pick(stored.bugcheck, ['on', 'always', 'off'], DEFAULTS.bugcheck),
     onFailure: pick(stored.onFailure, ['rearm', 'stop'], DEFAULTS.onFailure),
     maxRearms: Math.min(10, Math.max(0, number(stored.maxRearms, DEFAULTS.maxRearms))),
     runLog: bool(stored.runLog, DEFAULTS.runLog),
@@ -337,9 +494,29 @@ function detectWork(transcriptPath, options) {
 // The continuation the session wrote itself, stored by the /usage-limits:relay
 // note command. This is the good case: a paragraph from the session that knows
 // what it was doing beats anything reconstructed from a todo list.
-function saveContinuation(id, text) {
-  const body = String(text || '').slice(0, 8000).trim();
+// The continuation is delivered on stdin now (wake.js), where the cap is
+// 10 MB, so the old 8,000-character slice was a leftover from the argv era -
+// and a silent one: a plan that ran long simply lost its tail. 64 KB is more
+// than any note needs and small enough that a runaway write cannot fill a
+// disk.
+const CONTINUATION_MAX = 65536;
+
+// `options.force` is the only way to write ANOTHER session's armed
+// continuation. On 2026-09-14 a session wrote its note to whatever record was
+// armed without checking whose it was; the armed record belonged to a peer,
+// and the peer's 343-byte handoff was replaced with 3 KB of somebody else's
+// plan minutes before it was due to fire. One machine has one relay, so
+// displacement is normal - but a session may only overwrite a different
+// session's plan on purpose, never by default.
+function saveContinuation(id, text, options) {
+  const body = String(text || '').slice(0, CONTINUATION_MAX).trim();
   if (!body) return null;
+  const me = process.env.CLAUDE_CODE_SESSION_ID || process.env.CLAUDE_SESSION_ID || null;
+  const armedNow = armedFor(read(), id);
+  if (armedNow && me && me !== id && !(options && options.force)) {
+    note('refused to overwrite the armed continuation of ' + id + ' from session ' + me + ' (pass force to do it on purpose)');
+    return null;
+  }
   try {
     fs.mkdirSync(configDir(), { recursive: true });
     fs.writeFileSync(planFile(id), body + '\n');
@@ -347,9 +524,10 @@ function saveContinuation(id, text) {
     return null;
   }
   const state = read();
-  if (state.armed && state.armed.id === id) {
-    state.armed.continuation = true;
-    state.armed.continuationAt = Date.now();
+  const mine = armedFor(state, id);
+  if (mine) {
+    mine.continuation = true;
+    mine.continuationAt = Date.now();
     write(state);
   }
   return planFile(id);
@@ -369,6 +547,12 @@ function readContinuation(id) {
 // them and a form letter gets a form letter back. Written in the imperative,
 // because a resumed session that opens by asking what to do has wasted the
 // wake it was given.
+// Asked for on nearly every request, so the hand-off asks for it unprompted.
+const BUGCHECK_LINE =
+  'Before you call any of this done, check it for bugs twice: one full pass, then a second pass that assumes ' +
+  'the first missed something. The user asks for this on nearly every request, so do it without being asked, ' +
+  'unless the last turn already did both.';
+
 function compose(input) {
   const parts = [];
   const options = input || {};
@@ -395,6 +579,7 @@ function compose(input) {
     parts.push('The plan that was approved:\n\n' + work.plan);
   }
   parts.push('Verify anything that was mid-change before building on it: the last turn may have been cut off part-way through an edit.');
+  if (options.bugcheck !== false && options.bugcheck !== 'off') parts.push(BUGCHECK_LINE);
   const card = options.voice;
   if (card) parts.push('When you write back to the user, this is how they write:\n' + card);
   return parts.join('\n\n');
@@ -593,6 +778,84 @@ function remainingMs(deadline, ceiling) {
   return Math.max(0, Math.min(ceiling, left));
 }
 
+// What the PowerShell route may take when nothing bounds it. It used to be a
+// fixed eight seconds whether or not a hook was waiting, and on this machine
+// the ScheduledTasks module alone takes longer than that: measured
+// 2026-09-21, 32 seconds to load and register, 16 to unregister. So every arm
+// by hand timed out here (ETIMEDOUT, which has no stderr), fell through to
+// schtasks, and reported only the fallback's refusal - twice on the night of
+// 2026-09-20, with the primary route's failure never seen at all.
+const PS_ROUTE_MS = 60000;
+const SCHTASKS_MS = 8000;
+
+// One spawn's failure in a phrase that fits beside another's. A timeout has
+// no stderr, so reading only stderr is how the primary route's failure was
+// lost.
+function describeSpawn(label, run, timeoutMs) {
+  if (!run) return label + ': not attempted';
+  if (run.error) {
+    return label + ': ' + (run.error.code === 'ETIMEDOUT'
+      ? 'timed out after ' + Math.round(timeoutMs / 1000) + ' s'
+      : run.error.message);
+  }
+  const said = String(run.stderr || run.stdout || '').trim().split('\n')[0];
+  if (said) return label + ': ' + said;
+  return label + ': exited ' + run.status + ' with no output';
+}
+
+/* ------------------------------------------------------ the task launcher -- */
+
+// The task's own launcher: one small batch file per record, under the config
+// directory, holding the whole node command. Both registration routes point
+// at it, so the task action has one fixed shape whose length no longer
+// depends on where the plugin is installed. It has to be: schtasks caps /TR
+// at 261 characters, and the action used to carry node's path, the plugin
+// cache path to wake.js, the session id and the config directory - 326
+// characters on the 1.36.0 install - so the fallback was refused every time
+// it was tried. cmd's quoting rules apply to text this code wrote: a doubled
+// percent sign is the one escape needed inside double quotes, and a double
+// quote has no escape there, so it is dropped (no path can hold one).
+function wakeLauncherFile(id) {
+  return path.join(configDir(), 'relay-task-' + String(id).replace(/[^A-Za-z0-9_-]/g, '').slice(0, 8) + '.cmd');
+}
+
+function batchArg(text) {
+  return '"' + String(text).replace(/%/g, '%%').replace(/"/g, '') + '"';
+}
+
+function wakeLauncherScript(argv) {
+  return '@echo off\r\n' + [process.execPath].concat(argv).map(batchArg).join(' ') + '\r\n';
+}
+
+function writeWakeLauncher(id, argv) {
+  const file = wakeLauncherFile(id);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, wakeLauncherScript(argv), 'utf8');
+  return file;
+}
+
+// Deleting a batch file while cmd is still on its last line makes cmd end
+// with "The batch file cannot be found" (tested 2026-09-21), so a wake never
+// deletes its own launcher. They are swept here instead, from a process that
+// is not running under one: every relay-task-*.cmd whose record is gone.
+function sweepWakeLaunchers(state) {
+  const keep = new Set(records(state).map((r) => path.basename(wakeLauncherFile(r.id))));
+  let names;
+  try {
+    names = fs.readdirSync(configDir());
+  } catch (err) {
+    return;
+  }
+  for (const name of names) {
+    if (!/^relay-task-[A-Za-z0-9_-]{0,8}\.cmd$/.test(name) || keep.has(name)) continue;
+    try {
+      fs.unlinkSync(path.join(configDir(), name));
+    } catch (err) {
+      // A launcher that will not delete is a stray file, not a failed relay.
+    }
+  }
+}
+
 // Does Windows agree that this task will run?
 //
 // `state` and `next` come straight from Get-ScheduledTask and
@@ -611,6 +874,17 @@ function verifyRegistration(state, next, wanted, now) {
   if (!text) {
     return { ok: false, error: 'the scheduled task registered but Windows reports no next run time, so it will not fire' };
   }
+  // It has to LOOK like a timestamp before it is read as one.
+  //
+  // Date.parse is far too willing: Date.parse("12345") is the year 12345, which
+  // is finite, comfortably in the future, and would sail through every check
+  // below. This function exists to refuse a task that will not fire, so
+  // accepting garbage as proof that one will is the worst failure it has.
+  // PowerShell's .ToString("s") is always yyyy-MM-ddTHH:mm:ss; anything else is
+  // not an answer to the question that was asked.
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?/.test(text)) {
+    return { ok: false, error: 'could not read the next run time Windows reported: ' + text };
+  }
   const at = Date.parse(text);
   if (!Number.isFinite(at)) {
     return { ok: false, error: 'could not read the next run time Windows reported: ' + text };
@@ -630,17 +904,51 @@ function verifyRegistration(state, next, wanted, now) {
   return { ok: true, nextRun: at };
 }
 
+const HIDDEN_HOST = path.join(process.env.SystemRoot || 'C:' + path.sep + 'Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+
+// The task used to run node.exe directly, and node.exe is a console program:
+// under the scheduler, in an interactive session, it gets a console window
+// of its own. That was the "blank terminal that says Claude" - the wake's own
+// console, shared by its headless child - and closing it killed both (task
+// result 0xC000013A), so the wake never wrote its outcome. PowerShell can
+// start hidden and node inherits that; the session the wake opens for the
+// user is a new window (cmd /c start) and stays visible.
+function hiddenAction(launcher, cwd) {
+  return {
+    execute: HIDDEN_HOST,
+    argument: '-NoProfile -NonInteractive -WindowStyle Hidden -Command "& ' + psQuote(launcher) + '"',
+    cwd: cwd || os.homedir(),
+  };
+}
+
+// The one string schtasks measures: the /TR value.
+function taskAction(action) {
+  return '"' + action.execute + '" ' + action.argument;
+}
+
 function scheduleWindows(when, argv, name, cwd, deadline) {
+  // No time left is a plain refusal, not a hung hook - and not a launcher
+  // written for a task that is never registered.
+  if (Number.isFinite(deadline) && remainingMs(deadline, PS_ROUTE_MS) < 1500) {
+    return { ok: false, error: 'no time left in this hook to register the wake; it will arm on the next prompt' };
+  }
   let lastVerifyError = null;
   const date = new Date(when);
   const stamp =
     date.getFullYear() + '-' + two(date.getMonth() + 1) + '-' + two(date.getDate()) + ' ' +
     two(date.getHours()) + ':' + two(date.getMinutes()) + ':' + two(date.getSeconds());
-  const argument = argv.map(winArg).join(' ');
+  const idAt = argv.indexOf('--id');
+  let launcher;
+  try {
+    launcher = writeWakeLauncher(idAt !== -1 && argv[idAt + 1] ? argv[idAt + 1] : name, argv);
+  } catch (err) {
+    return { ok: false, error: 'could not write the wake launcher: ' + err.message };
+  }
+  const action = hiddenAction(launcher, cwd);
   const script = [
     '$ErrorActionPreference = "Stop"',
-    '$action = New-ScheduledTaskAction -Execute ' + psQuote(process.execPath) +
-      ' -Argument ' + psQuote(argument) + ' -WorkingDirectory ' + psQuote(cwd || os.homedir()),
+    '$action = New-ScheduledTaskAction -Execute ' + psQuote(action.execute) +
+      ' -Argument ' + psQuote(action.argument) + ' -WorkingDirectory ' + psQuote(action.cwd),
     '$trigger = New-ScheduledTaskTrigger -Once -At (Get-Date ' + psQuote(stamp) + ')',
     // A one-shot task does not remove itself. Without an expiry, every relay
     // leaves a dead entry in Task Scheduler forever; the wake also unregisters
@@ -677,10 +985,11 @@ function scheduleWindows(when, argv, name, cwd, deadline) {
   const file = path.join(os.tmpdir(), name + '.ps1');
   try {
     fs.writeFileSync(file, script, 'utf8');
+    const primaryMs = Math.max(500, remainingMs(deadline, PS_ROUTE_MS));
     const run = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', file], {
       encoding: 'utf8',
       windowsHide: true,
-      timeout: Math.max(500, remainingMs(deadline, 8000)),
+      timeout: primaryMs,
     });
     const registered = (run.stdout || '').match(/registered\|([^|\r\n]*)\|([^\r\n]*)/);
     if (run.status === 0 && registered) {
@@ -690,20 +999,38 @@ function scheduleWindows(when, argv, name, cwd, deadline) {
       // reporting a wake that is not going to happen.
       lastVerifyError = verdict.error;
     }
+    // Kept from here on, whatever the fallback does: the fallback's outcome
+    // is the second half of the answer, never the whole of it.
+    const primaryError = lastVerifyError ? 'ScheduledTasks: ' + lastVerifyError : describeSpawn('ScheduledTasks', run, primaryMs);
     // No time left for a second attempt is a plain refusal, not a hung hook.
-    if (remainingMs(deadline, 8000) < 1500) return { ok: false, error: 'no time left in this hook to register the wake; it will arm on the next prompt' };
+    if (remainingMs(deadline, SCHTASKS_MS) < 1500) {
+      return { ok: false, error: 'no time left in this hook to register the wake (' + primaryError + '); it will arm on the next prompt' };
+    }
     // schtasks cannot express StartWhenAvailable, so this path is a worse
     // guarantee and says so rather than pretending the two are the same.
+    const fallbackMs = Math.max(500, remainingMs(deadline, SCHTASKS_MS));
     const fallback = spawnSync(
       'schtasks.exe',
-      ['/Create', '/TN', name, '/TR', '"' + process.execPath + '" ' + argument, '/SC', 'ONCE',
+      ['/Create', '/TN', name, '/TR', taskAction(action), '/SC', 'ONCE',
         '/ST', two(date.getHours()) + ':' + two(date.getMinutes()),
         '/SD', two(date.getMonth() + 1) + '/' + two(date.getDate()) + '/' + date.getFullYear(),
         '/IT', '/Z', '/F'],
-      { encoding: 'utf8', windowsHide: true, timeout: Math.max(500, remainingMs(deadline, 8000)) }
+      { encoding: 'utf8', windowsHide: true, timeout: fallbackMs }
     );
-    if (fallback.status === 0) return { ok: true, how: 'schtasks', warning: 'a sleeping machine will miss this wake' };
-    return { ok: false, error: (lastVerifyError || run.stderr || fallback.stderr || 'could not register a scheduled task').trim().split('\n')[0] };
+    if (fallback.status === 0) {
+      return { ok: true, how: 'schtasks', warning: 'a sleeping machine will miss this wake (' + primaryError + ')', primaryError };
+    }
+    // Both paths failed. If the PowerShell one registered something that
+    // will not fire - or will fire at the wrong time - leaving it behind is
+    // an orphan that nothing tracks and nothing cancels.
+    if (lastVerifyError) {
+      try {
+        cancelSchedule(name);
+      } catch (err) {
+        // Nothing further to do; the expiry is the backstop.
+      }
+    }
+    return { ok: false, error: primaryError + '; ' + describeSpawn('schtasks', fallback, fallbackMs), primaryError };
   } catch (err) {
     return { ok: false, error: err.message };
   } finally {
@@ -715,7 +1042,7 @@ function scheduleWindows(when, argv, name, cwd, deadline) {
   }
 }
 
-function schedulePosix(when, argv, name, cwd) {
+function schedulePosix(when, argv, name, cwd, deadline) {
   const seconds = Math.max(60, Math.round((when - Date.now()) / 1000));
   // `at` is the right tool and is absent on most desktops now. A detached
   // sleeper is second best: it survives the terminal closing, but not a
@@ -724,9 +1051,12 @@ function schedulePosix(when, argv, name, cwd) {
   const at = spawnSync('sh', ['-c', 'command -v at >/dev/null 2>&1 && echo yes || echo no'], { encoding: 'utf8' });
   if ((at.stdout || '').trim() === 'yes') {
     const minutes = Math.max(1, Math.round(seconds / 60));
+    // Bounded by what the caller has left, like the Windows route: a hook is
+    // killed at ten seconds and this used to wait twenty. An `at` that runs
+    // out of time falls through to the sleeper below, which returns at once.
     const run = spawnSync('sh', ['-c', 'echo ' + JSON.stringify(command) + ' | at now + ' + minutes + ' minutes'], {
       encoding: 'utf8',
-      timeout: 20000,
+      timeout: Math.max(1000, remainingMs(deadline, 20000)),
     });
     // macOS ships `at` but launchd leaves atrun DISABLED by default, so the
     // command succeeds, prints a job id, and the wake never fires. Reporting
@@ -749,7 +1079,14 @@ function schedulePosix(when, argv, name, cwd) {
 
 function schedule(when, argv, name, cwd, deadline) {
   if (process.platform === 'win32') return scheduleWindows(when, argv, name, cwd, deadline);
-  return schedulePosix(when, argv, name, cwd);
+  // The same refusal the Windows route makes. The `at` spawn below may wait
+  // twenty seconds, inside a hook that is killed at ten, and a hook with no
+  // time left must say so rather than start a registration it cannot finish -
+  // the deadline was passed here and ignored on every platform but one.
+  if (Number.isFinite(deadline) && deadline - Date.now() < 1500) {
+    return { ok: false, error: 'no time left in this hook to register the wake; it will arm on the next prompt' };
+  }
+  return schedulePosix(when, argv, name, cwd, deadline);
 }
 
 function cancelSchedule(name) {
@@ -769,6 +1106,59 @@ function cancelSchedule(name) {
 
 // Everything that has to be true before a wake is scheduled, in the order that
 // makes the answer most useful to read.
+// A saved continuation is work by definition: the session wrote down what
+// comes next. On 2026-09-14 a session with an 8 KB note and no todo list hit
+// 100 per cent and was refused for having "no plan or unfinished todo list",
+// so nothing picked it up after the reset.
+function workWithContinuation(work, id) {
+  const base = work || { hasWork: false, pending: 0, source: null, todos: [], plan: null };
+  if (base.hasWork) return base;
+  const saved = id ? readContinuation(id) : '';
+  if (!saved) return base;
+  return Object.assign({}, base, { hasWork: true, pending: Math.max(1, base.pending || 0), source: 'continuation' });
+}
+
+// A wake that fired and never reported back. The 8:05 PM wake on 2026-09-14
+// was killed with its console (task result 0xC000013A), so finish() never
+// ran: the record stayed armed for a wake that was already over, its task
+// stayed registered, and status said "wake in now" for hours. A wake marks
+// wokeAt as its first act; a record past its wake with no mark for half an
+// hour never started, and one marked but silent for longer than a resume
+// can run has died. Either way it is history, and the slot is free.
+// Not 30 minutes: a task registered StartWhenAvailable runs when a sleeping
+// machine comes back, any time inside its 12-hour expiry, and reaping it
+// sooner would cancel the very catch-up run the registration promises.
+const LOST_UNSTARTED_MS = 12 * 60 * MINUTE + 30 * MINUTE;
+const LOST_RUNNING_MS = 3 * 60 * MINUTE + 10 * MINUTE;
+function reapLost(now) {
+  const state = read();
+  let reaped = false;
+  for (const armed of records(state)) {
+    if (!Number.isFinite(armed.wakeAt)) continue;
+    const limit = Number.isFinite(armed.wokeAt) ? armed.wokeAt + LOST_RUNNING_MS : armed.wakeAt + LOST_UNSTARTED_MS;
+    if (now < limit) continue;
+    const detail = Number.isFinite(armed.wokeAt)
+      ? 'the wake started ' + new Date(armed.wokeAt).toISOString() + ' and never reported back'
+      : 'the wake was due ' + new Date(armed.wakeAt).toISOString() + ' and never started, or died before it could say so';
+    state.history.push(Object.assign({}, armed, { endedAt: now, outcome: 'lost', detail }));
+    state.history = state.history.slice(-10);
+    dropRecord(state, armed.id);
+    note('lost ' + armed.id + ': ' + detail, now);
+    if (armed.task) {
+      try {
+        cancelSchedule(armed.task);
+      } catch (err) {
+      }
+    }
+    reaped = true;
+  }
+  if (reaped) {
+    write(state);
+    sweepWakeLaunchers(state);
+  }
+  return reaped;
+}
+
 function armable(input) {
   const options = input || {};
   const config = options.config || settings();
@@ -777,9 +1167,16 @@ function armable(input) {
   if (!binding || binding.percentUsed === null || binding.percentUsed === undefined) return { ok: false, why: 'no usable window reading' };
   if (binding.stale) return { ok: false, why: 'the reading is stale' };
   if (binding.percentUsed < config.at) return { ok: false, why: 'below ' + config.at + ' per cent' };
+  // The account's own reading has to be past the mark, not the local
+  // extrapolation on top of it: on 2026-09-20 the estimate ran 17 points hot
+  // and a relay armed on it would have armed a whole window early.
+  const beyond = Number.isFinite(binding.pointsBeyondSnapshot) ? binding.pointsBeyondSnapshot : 0;
+  const raw = binding.percentUsed - Math.max(0, beyond);
+  if (raw < config.at) return { ok: false, why: 'the account reads ' + Math.round(raw) + ' per cent; only the local estimate (' + Math.round(binding.percentUsed) + ') is past ' + config.at };
   if (!Number.isFinite(binding.resetsAt)) return { ok: false, why: 'the window has no known reset time' };
   if (!options.sessionId) return { ok: false, why: 'no session id' };
-  if (!options.work || !options.work.hasWork) return { ok: false, why: 'no plan or unfinished todo list to carry' };
+  const work = workWithContinuation(options.work, options.sessionId);
+  if (!work.hasWork) return { ok: false, why: 'no plan or unfinished todo list to carry, and no saved continuation' };
   // The boundary rule. Past the threshold but not yet at the backstop, arming
   // waits for the reply to finish - the Stop hook passes atCompletion and this
   // is the only caller that does. Mid-reply callers get told to wait, and the
@@ -798,28 +1195,46 @@ function arm(input) {
   const options = input || {};
   const now = Number.isFinite(options.now) ? options.now : Date.now();
   const config = options.config || settings();
+  reapLost(now);
+  options.work = workWithContinuation(options.work, options.sessionId);
   // `at` is an exact wake time, for work deferred to a moment somebody named
   // rather than to a window reset. The grace minutes exist so the meter has
   // really turned over before a resume fires; a time a person typed does not
   // want fifteen minutes added to it. Still floored a minute out, because a
   // task registered for a moment already past fires immediately.
-  const when = Number.isFinite(options.at)
+  let when = Number.isFinite(options.at)
     ? Math.max(options.at, now + MINUTE)
     : wakeAt(options.resetsAt, config.graceMinutes, now);
   if (!when) return { ok: false, error: 'no reset time to wake after' };
 
   const state = read();
   const id = options.sessionId;
+  // Two windows starting in the same second race each other for .claude.json
+  // (verified: it corrupts, and onboarding comes back). A minute apart is safe.
+  for (let guard = 0; guard < 20; guard++) {
+    const clash = records(state).find((r) => r.id !== id && Number.isFinite(r.wakeAt) && Math.abs(r.wakeAt - when) < MINUTE);
+    if (!clash) break;
+    when = clash.wakeAt + MINUTE;
+  }
+  const launchCwd = launchDirFor(options.cwd || process.cwd());
   const name = taskName(id, when);
   // Names are unique per wake now, so re-arming no longer replaces the old
-  // registration by name. Retire it explicitly, or every re-arm leaves a live
-  // task behind that would fire on its own.
-  if (state.armed && state.armed.task && state.armed.task !== name) {
-    try {
-      cancelSchedule(state.armed.task);
-    } catch (err) {
-      // The expiry removes it eventually either way.
-    }
+  // registration by name; the previous one has to be retired by hand or it
+  // stays live and fires on its own.
+  //
+  // It is retired AFTER the replacement is registered, never before. While
+  // the names were identical, -Force made this one atomic operation. With
+  // unique names, cancelling first opens a window in which the old wake is
+  // gone and the new one does not exist yet - and if registration then
+  // fails, that window never closes: the user is left with no relay at all,
+  // unattended, having had a working one a moment earlier.
+  const existing = armedFor(state, id);
+  const previousTask = existing && existing.task && existing.task !== name ? existing.task : null;
+  let preflight = null;
+  if (config.mode === 'resume' && (!options.hostName || options.hostName === host.CLAUDE) && options.preflight !== false) {
+    preflight = preflightPrompts(launchCwd, config);
+    if (preflight.ok && preflight.changes.length) note('pre-answered for ' + id + ': ' + preflight.changes.join(', '), now);
+    else if (!preflight.ok) note('could not pre-answer the start-up questions for ' + id + ': ' + preflight.error, now);
   }
   // Re-arming the same session for the same reset would register the task
   // twice; -Force replaces it, and the record is rewritten either way.
@@ -831,8 +1246,21 @@ function arm(input) {
   // testing meant it read the real one and found nothing armed.
   if (process.env.CLAUDE_CONFIG_DIR) argv.push('--config-dir', process.env.CLAUDE_CONFIG_DIR);
   const scheduled = options.schedule === false ? { ok: true, how: 'none' } : schedule(when, argv, name, options.cwd, options.deadline);
+  if (scheduled.ok && previousTask) {
+    // Safe now: the replacement exists.
+    try {
+      cancelSchedule(previousTask);
+    } catch (err) {
+      // The expiry removes it eventually either way.
+    }
+  }
   if (!scheduled.ok) {
-    note('arm failed for ' + id + ': ' + scheduled.error, now);
+    // The old wake is deliberately left alone here. A stale wake that still
+    // fires is worth more than none, and it carries the same continuation.
+    note('arm failed for ' + id + ': ' + scheduled.error + (previousTask ? '; the previous wake was left in place' : ''), now);
+    // A launcher written for a session that has no record is a stray; one
+    // that an earlier wake of this session still points at is kept with it.
+    sweepWakeLaunchers(state);
     return { ok: false, error: scheduled.error };
   }
 
@@ -841,6 +1269,7 @@ function arm(input) {
     task: scheduled.how === 'none' ? null : name,
     host: options.hostName || host.CLAUDE,
     cwd: options.cwd || process.cwd(),
+    launchCwd: launchCwd !== (options.cwd || process.cwd()) ? launchCwd : null,
     project: options.project || null,
     armedAt: now,
     wakeAt: when,
@@ -852,6 +1281,7 @@ function arm(input) {
     mode: config.mode,
     how: scheduled.how,
     warning: scheduled.warning || null,
+    preflight: preflight ? preflight.changes : null,
     attempt: 0,
     continuation: false,
     // The outstanding items travel with the record, not just their count. They
@@ -869,15 +1299,16 @@ function arm(input) {
   // Displacing somebody else's live relay is legitimate - one machine, one
   // relay - but it must not be silent. A wake still in the future belonged to
   // work that somebody expected to be picked up.
-  if (state.armed && state.armed.id !== id) {
-    if (Number.isFinite(state.armed.wakeAt) && state.armed.wakeAt > now) {
-      note('displacing the relay armed for ' + state.armed.id + ' (was due ' + new Date(state.armed.wakeAt).toISOString() + ')', now);
-    }
-    if (state.armed.task) cancelSchedule(state.armed.task);
-  }
-  state.armed = record;
+  const beside = records(state).filter((r) => r.id !== id).map((r) => r.id.slice(0, 8));
+  putRecord(state, record);
   write(state);
-  note('armed ' + id + ' for ' + new Date(when).toISOString() + ' via ' + scheduled.how, now);
+  sweepWakeLaunchers(state);
+  note(
+    'armed ' + id + ' for ' + new Date(when).toISOString() + ' via ' + scheduled.how +
+      (scheduled.primaryError ? ' (' + scheduled.primaryError + ')' : '') +
+      (beside.length ? ' beside ' + beside.join(', ') : ''),
+    now
+  );
   return { ok: true, record };
 }
 
@@ -896,24 +1327,27 @@ function arm(input) {
 // tidying up should say so.
 function disarm(reason, now, id) {
   const state = read();
-  if (!state.armed) return { ok: true, changed: false };
-  if (id && state.armed.id !== id) {
-    note('refused to disarm ' + state.armed.id + ' on behalf of ' + id, Number.isFinite(now) ? now : Date.now());
-    return { ok: true, changed: false, refused: true, armed: state.armed.id };
-  }
-  const record = state.armed;
-  if (record.task) cancelSchedule(record.task);
-  state.history.push(Object.assign({}, record, { endedAt: Number.isFinite(now) ? now : Date.now(), outcome: reason || 'cancelled' }));
+  const all = records(state);
+  if (!all.length) return { ok: true, changed: false };
+  const targets = id ? all.filter((r) => r.id === id) : all;
+  if (!targets.length) {
+    note('nothing armed for ' + id + '; ' + all.map((r) => r.id.slice(0, 8)).join(', ') + ' left as they were', Number.isFinite(now) ? now : Date.now());
+    return { ok: true, changed: false, refused: true, armed: all[0].id };
+  }
+  for (const record of targets) {
+    if (record.task) cancelSchedule(record.task);
+    state.history.push(Object.assign({}, record, { endedAt: Number.isFinite(now) ? now : Date.now(), outcome: reason || 'cancelled' }));
+    dropRecord(state, record.id);
+    try {
+      fs.unlinkSync(planFile(record.id));
+    } catch (err) {
+    }
+    note('disarmed ' + record.id + ': ' + (reason || 'cancelled'), now);
+  }
   state.history = state.history.slice(-10);
-  state.armed = null;
   write(state);
-  try {
-    fs.unlinkSync(planFile(record.id));
-  } catch (err) {
-    // The continuation file may never have been written.
-  }
-  note('disarmed ' + record.id + ': ' + (reason || 'cancelled'), now);
-  return { ok: true, changed: true, record };
+  sweepWakeLaunchers(state);
+  return { ok: true, changed: true, record: targets[0], records: targets };
 }
 
 function formatWait(ms) {
@@ -926,6 +1360,7 @@ function formatWait(ms) {
 
 function status(now) {
   const at = Number.isFinite(now) ? now : Date.now();
+  reapLost(at);
   const state = read();
   const config = settings(state);
   const able = capabilities();
@@ -934,16 +1369,19 @@ function status(now) {
     'Relay is ' + (config.enabled ? 'ON' : 'OFF') + ', arming at ' + config.at + ' per cent, waking ' +
       config.graceMinutes + ' min after the reset, delivery ' + config.mode + '.'
   );
-  if (state.armed) {
+  const all = records(state);
+  for (const armed of all) {
     lines.push(
-      'Armed: session ' + state.armed.id.slice(0, 8) + ' in ' + state.armed.cwd + ', wake in ' +
-        formatWait(state.armed.wakeAt - at) + ' (' + new Date(state.armed.wakeAt).toLocaleString() + '), via ' + state.armed.how + '.'
+      'Armed: session ' + armed.id.slice(0, 8) + ' in ' + armed.cwd + ', wake in ' +
+        formatWait(armed.wakeAt - at) + ' (' + new Date(armed.wakeAt).toLocaleString() + '), via ' + armed.how + '.'
     );
-    if (state.armed.warning) lines.push('  Caveat: ' + state.armed.warning + '.');
-    lines.push('  Continuation written: ' + (state.armed.continuation ? 'yes' : 'not yet'));
-  } else {
-    lines.push('Nothing armed.');
+    if (armed.warning) lines.push('  Caveat: ' + armed.warning + '.');
+    if (armed.preflight && armed.preflight.length) lines.push('  Pre-answered: ' + armed.preflight.join(', '));
+    if (armed.launchCwd) lines.push('  Resumes from ' + armed.launchCwd + ' (the home folder can never be trusted) with --add-dir back to ' + armed.cwd);
+    lines.push('  Continuation written: ' + (armed.continuation ? 'yes' : 'not yet'));
   }
+  if (!all.length) lines.push('Nothing armed.');
+  else if (all.length > 1) lines.push(all.length + ' sessions armed; each wakes on its own task.');
   lines.push(
     'Available here: ' + [
       able.claude ? 'claude CLI' : null,
@@ -1026,6 +1464,7 @@ async function armByHand(rest) {
   return (
     'Armed by hand for session ' + sessionId.slice(0, 8) + ': wake at ' +
       new Date(result.record.wakeAt).toLocaleString() + ' via ' + result.record.how + '.' +
+      (result.record.preflight && result.record.preflight.length ? ' Pre-answered: ' + result.record.preflight.join(', ') + '.' : '') +
       (text ? ' Continuation saved.' : ' No continuation yet - add one with: relay note "<text>"')
   );
 }
@@ -1067,6 +1506,36 @@ async function doctor(now) {
   const cli = caps.claude || caps.codex;
   add('a CLI to resume with', Boolean(cli), cli || 'neither the claude nor the codex CLI could be found on PATH');
 
+  // Whether there is a login for the wake to resume under, asked of the CLI
+  // itself: `claude auth status --json` reports loggedIn and nothing secret.
+  // WHEN it expires is the one thing this cannot check. That command reports
+  // no expiry (2.1.263, read from its output), and the only expiry on disk
+  // is inside .credentials.json, which the relay does not read for credential
+  // values. So it is stated as a limit rather than guessed at: a login that
+  // lapses before the wake stops the resumed run at a prompt nobody answers.
+  if (caps.claude) {
+    const auth = spawnSync(caps.claude, ['auth', 'status', '--json'], {
+      encoding: 'utf8',
+      windowsHide: true,
+      timeout: 20000,
+      shell: process.platform === 'win32' && /\.(cmd|bat)$/i.test(caps.claude),
+    });
+    let parsed = null;
+    try {
+      parsed = JSON.parse(String(auth.stdout || '').trim());
+    } catch (err) {
+      parsed = null;
+    }
+    if (parsed && typeof parsed.loggedIn === 'boolean') {
+      add('login', parsed.loggedIn, parsed.loggedIn
+        ? 'logged in' + (parsed.subscriptionType ? ' (' + parsed.subscriptionType + ')' : '') +
+          '. Its expiry is not checked: claude auth status does not report one and the relay does not read .credentials.json, so run /login before a relay that fires hours from now'
+        : 'not logged in - the resumed run would stop at the login prompt. Run: claude auth login');
+    } else {
+      add('login', true, 'claude auth status gave no answer; expiry is not checked either way, so run /login before a long relay', 'warning');
+    }
+  }
+
   const net = await require('./net.js').reachable({ timeoutMs: 8000 });
   add('network to the API', net.online, net.detail,
     net.online ? 'ok' : net.reason === 'intercepted' ? 'error' : 'warning');
@@ -1074,14 +1543,37 @@ async function doctor(now) {
   // Can a task actually be registered by this account? Registering and removing
   // a throwaway is the only honest answer; asking the policy is not.
   if (process.platform === 'win32') {
+    for (const rec of records(state)) {
+      const pre = preflightPrompts(rec.launchCwd || rec.cwd, config, { dry: true });
+      const quiet = pre.ok && !pre.changes.length;
+      add('start-up questions for ' + String(rec.id).slice(0, 8), quiet,
+        pre.ok
+          ? (quiet ? 'folder trust and bypass permissions already answered in ' + pre.file : 'the resumed window would stop at: ' + pre.changes.join(', ') + ' - run relay preflight, or re-arm')
+          : pre.error,
+        quiet ? 'ok' : 'warn');
+    }
+    if (!records(state).length && config.mode === 'resume') {
+      const pre = preflightPrompts(launchDirFor(process.cwd()), config, { dry: true });
+      const quiet = pre.ok && !pre.changes.length;
+      add('start-up questions here', quiet,
+        pre.ok
+          ? (quiet ? 'folder trust and bypass permissions already answered for ' + process.cwd() : 'a resume in ' + process.cwd() + ' would stop at: ' + pre.changes.join(', ') + ' - arming writes the answers')
+          : pre.error,
+        quiet ? 'ok' : 'warn');
+    }
     const probeName = 'usage-limits-doctor-probe';
-    const registered = scheduleWindows(at + 6 * 60 * MINUTE, [path.join(__dirname, 'wake.js'), '--id', 'doctor-probe'], probeName, os.homedir(), at + 20000);
+    // Ninety seconds, not twenty: the PowerShell route takes over thirty on
+    // this machine, and a probe cut off before it can finish reports the
+    // fallback, which is a different answer to the question being asked.
+    const registered = scheduleWindows(at + 6 * 60 * MINUTE, [path.join(__dirname, 'wake.js'), '--id', 'doctor-probe'], probeName, os.homedir(), at + 90000);
     add('scheduled tasks', registered.ok, registered.ok
       ? 'registered a test task via ' + registered.how + (registered.how === 'schtasks'
-        ? ' - the PowerShell path failed, so a sleeping machine will miss its wake'
+        ? ' - the PowerShell path failed (' + registered.primaryError + '), so a sleeping machine will miss its wake'
         : ' - StartWhenAvailable and WakeToRun are set, so a machine that was off or asleep still runs it')
       : registered.error, registered.ok && registered.how === 'schtasks' ? 'warning' : undefined);
     if (registered.ok) cancelSchedule(probeName);
+    // The probe's launcher has no record, so the sweep takes it.
+    sweepWakeLaunchers(state);
 
     // A wake at 3am is no use if the machine hibernates at midnight and the
     // task is not allowed to wake it. This reads the actual power policy.
@@ -1198,9 +1690,16 @@ function main(argv) {
   }
   if (command === 'note') {
     const state = read();
-    if (!state.armed) return 'Nothing is armed, so there is nowhere to put a continuation yet.';
+    const all = records(state);
+    if (!all.length) return 'Nothing is armed, so there is nowhere to put a continuation yet.';
+    // This session's own relay; with several armed and none this session's, the id has to be named.
+    const sessionAt = rest.indexOf('--session');
+    const named = sessionAt !== -1 ? rest[sessionAt + 1] : null;
+    const me = named || process.env.CLAUDE_CODE_SESSION_ID || process.env.CLAUDE_SESSION_ID || null;
+    const target = armedFor(state, me) || (all.length === 1 ? all[0] : null);
+    if (!target) return all.length + ' relays are armed (' + all.map((r) => r.id.slice(0, 8)).join(', ') + ') and none is this session\'s; pass --session <id>.';
     const fromFile = rest.indexOf('--file') !== -1 ? rest[rest.indexOf('--file') + 1] : null;
-    let text = fromFile ? '' : rest.filter((item) => item !== '--file').join(' ');
+    let text = fromFile ? '' : rest.filter((item, i) => item !== '--file' && item !== '--session' && !(sessionAt !== -1 && i === sessionAt + 1)).join(' ');
     if (fromFile) {
       try {
         text = fs.readFileSync(fromFile, 'utf8');
@@ -1208,12 +1707,17 @@ function main(argv) {
         return 'Could not read ' + fromFile;
       }
     }
-    const written = saveContinuation(state.armed.id, text);
-    return written ? 'Continuation saved for the relay (' + written + ').' : 'Nothing to save.';
+    const written = saveContinuation(target.id, text, { force: Boolean(named) });
+    return written ? 'Continuation saved for the relay of ' + target.id.slice(0, 8) + ' (' + written + ').' : 'Nothing to save.';
   }
   if (command === 'cancel') {
-    const result = disarm('cancelled by hand', Date.now());
-    return result.changed ? 'Relay cancelled and the scheduled wake removed.' : 'Nothing was armed.';
+    // This session's own relay by default; --all takes every session's down.
+    const me = process.env.CLAUDE_CODE_SESSION_ID || process.env.CLAUDE_SESSION_ID || null;
+    const every = rest.includes('--all') || !me || !armedFor(read(), me);
+    const result = disarm('cancelled by hand', Date.now(), every ? undefined : me);
+    if (!result.changed) return 'Nothing was armed.';
+    const n = result.records ? result.records.length : 1;
+    return n > 1 ? n + ' relays cancelled and their scheduled wakes removed.' : 'Relay cancelled and the scheduled wake removed.';
   }
   // Arming by hand, for the cases the hook cannot see: Codex writes no plan
   // tool into its rollouts, so nothing there ever reads as work to carry; and
@@ -1233,11 +1737,28 @@ function main(argv) {
     const config = configure({ backstopAt: Number(value) });
     return 'Past ' + config.backstopAt + ' per cent it stops waiting for a completion and arms immediately.';
   }
+  if (command === 'voice') {
+    const on = !['off', 'false', 'no', '0'].includes(String(value || 'on').toLowerCase());
+    configure({ voice: on });
+    return on
+      ? 'The hand-off will carry how you write, so the resumed session answers in your voice without being reminded.'
+      : 'The hand-off will not carry how you write.';
+  }
+  if (command === 'bugcheck') {
+    // pick() is local to settings(); the command checks the value itself.
+    const wanted = String(value || 'on').toLowerCase();
+    const choice = ['on', 'always', 'off'].includes(wanted) ? wanted : null;
+    if (!choice) return 'Bug check: on (the hand-off asks for two passes), always (every prompt does), or off.';
+    configure({ bugcheck: choice });
+    if (choice === 'off') return 'Neither the hand-off nor the prompt hook will ask for the two bug passes.';
+    if (choice === 'always') return 'Every prompt, and the hand-off, will ask for two bug passes before anything is called done.';
+    return 'The hand-off will ask for two bug passes before anything is called done.';
+  }
   if (command === 'show') {
     const on = !['off', 'false', 'no', '0'].includes(String(value || 'on').toLowerCase());
     configure({ show: on });
     return on
-      ? 'The resumed run will open in a window you can see, and its full output is kept either way (relay log --run).'
+      ? 'The resumed run will be a session in a window you can see, with Remote Control on; a headless run keeps its output in relay log --run.'
       : 'The resumed run will be invisible. Its output is still kept: relay log --run.';
   }
   if (command === 'onfailure' || command === 'on-failure') {
@@ -1259,6 +1780,18 @@ function main(argv) {
     return 'A machine that cannot reach the API will retry ' + config.offlineAttempts + ' times, ' +
       config.offlineRetryMinutes + ' minutes apart at first and backing off from there. Being offline never counts as a failed run.';
   }
+  if (command === 'preflight') {
+
+    const target = process.argv.slice(3).find((a) => !String(a).startsWith('--')) || process.cwd();
+
+    const r = preflightPrompts(target, settings(read()));
+
+    if (!r.ok) return 'Could not pre-answer: ' + r.error;
+
+    return r.changes.length ? 'Pre-answered: ' + r.changes.join('; ') + '.' + (r.backup ? ' Backup: ' + r.backup : '') : 'Nothing to pre-answer for ' + target + ': folder trust and bypass permissions are already in ' + r.file + '.';
+
+  }
+
   if (command === 'doctor' || command === 'check') return doctor(Date.now()).then((r) => r.text);
   if (command === 'log') {
     if (rest.includes('--run')) {
@@ -1275,7 +1808,7 @@ function main(argv) {
   return [
     'usage: relay.js [status|on|off|at N|grace N|mode notify|resume|permission MODE|model NAME|',
     '                 thinking off|resume|always|armon threshold|completion|backstop N|',
-    '                 show on|off|onfailure rearm|stop|offline N|doctor|',
+    '                 show on|off|onfailure rearm|stop|offline N|doctor|preflight [cwd]|',
     '                 arm [--session ID] [TEXT]|note TEXT|cancel|log [--run]]',
     '',
     status(Date.now()),
@@ -1297,7 +1830,9 @@ if (require.main === module) {
     );
 }
 
-module.exports = {
+module.exports = { workWithContinuation, reapLost, hiddenAction, BUGCHECK_LINE,
+  taskAction, wakeLauncherFile, wakeLauncherScript, writeWakeLauncher, sweepWakeLaunchers, batchArg, describeSpawn, PS_ROUTE_MS, SCHTASKS_MS,
+  records, armedFor, putRecord, dropRecord, preflightPrompts, claudeJsonFile, projectKeys, isHome, launchDirFor, applySetting, settingIs,
   DEFAULTS,
   MINUTE,
   main,