claude-usage-limits 1.26.0 → 1.39.1

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

@@ -27,7 +27,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { spawnSync } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 
 const relay = require('./relay.js');
 const net = require('./net.js');
@@ -143,8 +143,21 @@ function userIsPresent(cli) {
 // None of this is restored by --resume: a headless resume starts in the
 // permission mode a fresh -p run would, so a session that was running with
 // edits accepted comes back asking a person who is not there.
+// The prompt is NOT in here. It travels on stdin - see deliverClaude.
+//
+// It used to be the argument after -p, and on 2026-09-14 a relay booked for
+// 09:55 fired on time, three times, and died three times with the one line
+// "The command line is too long." The continuation had grown to 7.5 KB and
+// Windows caps a command line at 8,191 characters. Every retry hit the same
+// wall, because the failure was deterministic, and the work sat on disk until
+// somebody came home at 2:52 PM and found nothing done.
+//
+// claude -p reads the prompt from stdin when none is given as an argument and
+// stdin is not a terminal, with a 10 MB cap. A 12 KB prompt was fed through
+// that way and answered before this change was made. The prompt parameter is
+// kept in the signature so callers and tests do not change shape.
 function claudeArgs(record, prompt, config, fallback) {
-  const args = fallback ? ['--continue', '-p', prompt] : ['--resume', record.id, '-p', prompt];
+  const args = fallback ? ['--continue', '-p'] : ['--resume', record.id, '-p'];
   if (config.permissionMode) args.push('--permission-mode', config.permissionMode);
   // Nobody is awake to answer a prompt. Deny it rather than stall on it: a
   // resumed run that sits waiting for a keystroke burns its whole timeout and
@@ -179,14 +192,272 @@ function spawnOptionsFor(record, config, cli) {
     encoding: 'utf8',
     cwd: record.cwd,
     timeout: RESUME_TIMEOUT_MS,
-    windowsHide: config && config.show === false,
+    // Always. The seen run is the interactive window (deliverVisible); this
+    // headless one shared the wake's console once and died with it.
+    windowsHide: true,
     shell: process.platform === 'win32' && /\.(cmd|bat)$/i.test(cli),
+    // The visible launcher sets this in its own script; the headless run
+    // inherited the wake's environment and could start an update at launch,
+    // with nobody there to watch it. Only when nothing has set it already.
+    env: Object.assign({}, process.env, process.env.DISABLE_AUTOUPDATER === undefined ? { DISABLE_AUTOUPDATER: '1' } : {}),
   };
 }
 
-function deliverClaude(record, prompt, config, cli, runs) {
+// The window that says "Claude" and nothing else.
+//
+// On 2026-09-14 the 8:05 PM relay fired, resumed the session and worked - in
+// a console window that showed only its title. `claude -p` prints its result
+// when it has finished and nothing before, the wake was capturing both
+// streams for the run log anyway, and a headless run does not register with
+// Remote Control, so the phone showed nothing either. The user's words: "just
+// a blank terminal screen that says Claude".
+//
+// So when the run is meant to be seen (relay show, the default) it is a real
+// interactive session in its own window: resumed by id, model and permission
+// mode set, Remote Control on under a name that says what it is, and the
+// first prompt given as a short argument that points at the hand-off on
+// disk. The hand-off itself cannot ride on argv (8,191 characters) and an
+// interactive session's stdin is its keyboard, so the file is the one
+// channel that fits every length. The session reads it with one tool call
+// and carries on, and from then on it is a session like any other: on
+// screen, on claude.ai/code, and typed into.
+//
+// The launcher is a .cmd file rather than a command line, so the only
+// quoting rules that have to hold are cmd's own, applied to text this code
+// wrote. `call` matters: claude.cmd is itself a batch file, and a batch file
+// run without call never returns to the lines below it - the exit code
+// would never be written and a failure would close the window unread.
+const LAUNCH_GRACE_MS = 20000;
+
+function wakePromptFile(id) {
+  return path.join(relay.configDir(), 'relay-wake-' + id + '.md');
+}
+
+function launcherFile(id) {
+  return path.join(relay.configDir(), 'relay-wake-' + id + (process.platform === 'win32' ? '.cmd' : '.sh'));
+}
+
+function exitFile(id) {
+  return path.join(relay.configDir(), 'relay-wake-' + id + '.exit');
+}
+
+// Short, plain, and free of quotes: it goes through cmd and then argv.
+function pointerPrompt(file) {
+  return (
+    'The usage window has reset and this is the plugin picking the work back up, not a new request. ' +
+    'The full hand-off is in the file ' + file + ' - read it with the Read tool now and carry on from it ' +
+    'at full quality, without re-asking what to do. If the working directory is not the project folder, ' +
+    'it was resumed from a trusted folder on purpose: use absolute paths.'
+  );
+}
+
+// Doubled percent signs are the one escape cmd needs inside double quotes;
+// a double quote itself has no escape there, so it is dropped.
+function cmdArg(text) {
+  return '"' + String(text).replace(/%/g, '%%').replace(/"/g, '') + '"';
+}
+
+function visibleArgs(record, config, promptFile) {
+  const args = ['--resume', record.id];
+  if (record.launchCwd) args.push('--add-dir', record.cwd);
+  if (config && config.permissionMode) args.push('--permission-mode', config.permissionMode);
+  if (config && config.model) args.push('--model', config.model);
+  args.push('--remote-control', 'usage-limits relay ' + (record.project || path.basename(record.cwd)));
+  args.push(pointerPrompt(promptFile));
+  return args;
+}
+
+function launcherScript(record, config, cli, promptFile, exitPath) {
+  const name = String(record.project || path.basename(record.cwd)).replace(/[&|<>^%"]/g, '');
+  return [
+    '@echo off',
+    'title Claude relay - ' + name,
+    'cd /d ' + cmdArg(record.launchCwd || record.cwd),
+    'set DISABLE_AUTOUPDATER=1',
+    // Seen live on 2026-09-14: launched from inside a session, the window
+    // inherited that session's markers - transcript saving was off (the
+    // child-session marker) and the hooks took it for the parent (its id).
+    // The resumed session is nobody's child, whoever opened the window.
+    'set CLAUDE_CODE_CHILD_SESSION=',
+    'set CLAUDE_CODE_SESSION_ID=',
+    'call ' + cmdArg(cli) + ' ' + visibleArgs(record, config, promptFile).map(cmdArg).join(' '),
+    'set CODE=%ERRORLEVEL%',
+    '> ' + cmdArg(exitPath) + ' echo %CODE%',
+    'if not "%CODE%"=="0" (',
+    '  echo.',
+    '  echo [usage-limits relay] claude exited with code %CODE%. The window stays open so the message above can be read; the plan is still on disk.',
+    '  pause >nul',
+    ')',
+    '',
+  ].join('\r\n');
+}
+
+// `claude --resume` finds a session by its transcript, one folder per project
+// under the config dir. Checking first means a session that is gone gets the
+// same permanent answer the headless path gives, without opening a window
+// whose only content would be the error.
+function transcriptExists(id) {
+  const root = path.join(relay.configDir(), 'projects');
+  try {
+    for (const dir of fs.readdirSync(root)) {
+      if (fs.existsSync(path.join(root, dir, id + '.jsonl'))) return true;
+    }
+  } catch (err) {
+    // No projects folder at all.
+  }
+  return false;
+}
+
+function readExit(file) {
+  try {
+    const code = parseInt(fs.readFileSync(file, 'utf8').trim(), 10);
+    return Number.isFinite(code) ? code : null;
+  } catch (err) {
+    return null;
+  }
+}
+
+function sleepMs(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+// `start` returns as soon as the window exists; the launcher runs on in it.
+// Pre-quoted arguments go through verbatim, because Node's own quoting is
+// for programs that parse like C, and cmd does not.
+function openWindow(launcher, exitPath, record) {
+  const run = spawnSync('cmd.exe', ['/d', '/c', 'start', '"Claude relay"', '/D', cmdArg(record.launchCwd || record.cwd), cmdArg(launcher)], {
+    encoding: 'utf8',
+    timeout: 30000,
+    windowsHide: true,
+    windowsVerbatimArguments: true,
+  });
+  if (run.status !== 0) throw new Error(((run.stderr || run.stdout || '') + '').trim().split('\n')[0] || 'start exited ' + run.status);
+}
+
+// The same window on macOS and Linux. UNVERIFIED on a real Mac or Linux box:
+// written from the documented behaviour of osascript and the common terminal
+// emulators, with the launcher script itself under test. The shell quoting
+// is the POSIX one: close the quote, escape one, reopen.
+const Q = String.fromCharCode(39);
+function shQuote(text) {
+  return Q + String(text).split(Q).join(Q + String.fromCharCode(92) + Q + Q) + Q;
+}
+
+function launcherScriptPosix(record, config, cli, promptFile, exitPath) {
+  return [
+    '#!/bin/sh',
+    'cd ' + shQuote(record.cwd) + ' || exit 1',
+    'unset CLAUDE_CODE_CHILD_SESSION CLAUDE_CODE_SESSION_ID',
+    shQuote(cli) + ' ' + visibleArgs(record, config, promptFile).map(shQuote).join(' '),
+    'code=$?',
+    'echo "$code" > ' + shQuote(exitPath),
+    'if [ "$code" -ne 0 ]; then',
+    '  echo',
+    '  echo "[usage-limits relay] claude exited with code $code. This window stays open so the message above can be read; the plan is still on disk."',
+    '  read -r _',
+    'fi',
+    '',
+  ].join(String.fromCharCode(10));
+}
+
+function hasCommand(name) {
+  const run = spawnSync('sh', ['-c', 'command -v ' + shQuote(name)], { encoding: 'utf8', timeout: 10000 });
+  return run.status === 0;
+}
+
+function openWindowPosix(launcher) {
+  fs.chmodSync(launcher, 0o755);
+  if (process.platform === 'darwin') {
+    const run = spawnSync('osascript', ['-e', 'tell application "Terminal" to do script ' + JSON.stringify('sh ' + shQuote(launcher))], { encoding: 'utf8', timeout: 30000 });
+    if (run.status !== 0) throw new Error(((run.stderr || run.stdout || '') + '').trim().split(String.fromCharCode(10))[0] || 'osascript exited ' + run.status);
+    return;
+  }
+  if (!process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) throw new Error('no DISPLAY or WAYLAND_DISPLAY: not a graphical session');
+  const terminals = [
+    ['x-terminal-emulator', ['-e', 'sh', launcher]],
+    ['gnome-terminal', ['--', 'sh', launcher]],
+    ['konsole', ['-e', 'sh', launcher]],
+    ['xterm', ['-e', 'sh', launcher]],
+  ];
+  for (const [bin, args] of terminals) {
+    if (!hasCommand(bin)) continue;
+    const child = spawn(bin, args, { detached: true, stdio: 'ignore' });
+    child.unref();
+    return;
+  }
+  throw new Error('no terminal emulator found (tried x-terminal-emulator, gnome-terminal, konsole, xterm)');
+}
+
+// `io` exists so the window path can be tested without a window: open, sleep
+// and now are the three things it does to the world.
+function deliverVisible(record, prompt, config, cli, runs, io) {
+  const ops = Object.assign({ open: process.platform === 'win32' ? openWindow : openWindowPosix, sleep: sleepMs, now: Date.now }, io || null);
+  if (!transcriptExists(record.id)) {
+    return {
+      ok: false,
+      permanent: true,
+      error:
+        'the session ' + String(record.id).slice(0, 8) + ' no longer exists, so there was nothing to resume. ' +
+        'The plan is still on disk: run "claude" in ' + record.cwd + ' and paste it in.',
+    };
+  }
+  const promptFile = wakePromptFile(record.id);
+  const launcher = launcherFile(record.id);
+  const exitPath = exitFile(record.id);
+  try {
+    fs.mkdirSync(relay.configDir(), { recursive: true });
+    fs.writeFileSync(promptFile, String(prompt == null ? '' : prompt) + '\n');
+    fs.writeFileSync(launcher, process.platform === 'win32'
+      ? launcherScript(record, config, cli, promptFile, exitPath)
+      : launcherScriptPosix(record, config, cli, promptFile, exitPath));
+    try {
+      fs.unlinkSync(exitPath);
+    } catch (err) {
+      // None left from last time.
+    }
+  } catch (err) {
+    return { ok: false, error: 'could not write the launcher: ' + err.message };
+  }
+  try {
+    ops.open(launcher, exitPath, record);
+  } catch (err) {
+    appendRun(runs, 'claude --resume (window)', { status: 1, stdout: '', stderr: err.message });
+    return { ok: false, openFailed: true, error: 'could not open a window: ' + err.message };
+  }
+  const started = ops.now();
+  while (ops.now() - started < LAUNCH_GRACE_MS) {
+    ops.sleep(1000);
+    const code = readExit(exitPath);
+    if (code !== null) {
+      const after = Math.round((ops.now() - started) / 1000);
+      appendRun(runs, 'claude --resume (window)', {
+        status: code,
+        stdout: '',
+        stderr: 'exited within ' + after + 's; its output is in the window, which stays open when the exit is not 0',
+      });
+      if (code === 0) return { ok: true, how: 'claude --resume in a window' };
+      return { ok: false, error: 'claude exited ' + code + ' in the window it opened (left open so the message can be read)' };
+    }
+  }
+  appendRun(runs, 'claude --resume (window)', {
+    status: 0,
+    stdout:
+      'still running after ' + Math.round(LAUNCH_GRACE_MS / 1000) + 's: an interactive session in its own window, Remote Control on. ' +
+      'Its output is on screen and in the session transcript, not in this log.',
+    stderr: '',
+  });
+  return { ok: true, how: 'claude --resume in a window, Remote Control on' };
+}
+function deliverClaude(record, prompt, config, cli, runs, io) {
+  // Seen by default. relay show off keeps the headless run, and so does a
+  // machine where no window could be opened (no terminal emulator found).
+  if (config && config.show !== false) {
+    const visible = deliverVisible(record, prompt, config, cli, runs, io);
+    if (!visible.openFailed) return visible;
+  }
   const args = claudeArgs(record, prompt, config, false);
-  const options = spawnOptionsFor(record, config, cli);
+  // stdin, never argv. See claudeArgs for the 7.5 KB note that proved why.
+  const options = Object.assign(spawnOptionsFor(record, config, cli), { input: String(prompt == null ? '' : prompt) });
   const run = appendRun(runs, 'claude --resume', spawnSync(cli, args, options));
   if (run.status === 0) return { ok: true, how: 'claude --resume' };
   const detail = ((run.stderr || run.stdout || '') + '').trim().split('\n')[0];
@@ -221,16 +492,29 @@ function deliverCodex(record, prompt, cli, runs) {
   // Codex keeps interactive sessions on a local app server, and queue is the
   // supported way to put a message into one from outside. If the thread is
   // gone, exec resume does the same work in a fresh process.
-  const queued = spawnSync(cli, ['queue', '--thread', record.id, '--message', prompt], {
-    encoding: 'utf8',
-    cwd: record.cwd,
-    timeout: 60000,
-    windowsHide: true,
-  });
+  // Same wall as the Claude path: Windows caps a command line at 8,191
+  // characters and a continuation can be longer than that. `queue --message`
+  // has no stdin form, so past the safe length it is skipped rather than
+  // attempted - a call that is known to fail is not worth the time it takes to
+  // fail. `exec` reads its prompt from stdin when none is given, so that path
+  // carries the long ones. UNVERIFIED against a live Codex: this is the Claude
+  // fix applied by analogy to the documented exec behaviour, not a measured
+  // run, because measuring it would spend the user's ChatGPT quota.
+  const text = String(prompt == null ? '' : prompt);
+  const fitsArgv = text.length <= 6000;
+  const queued = fitsArgv
+    ? spawnSync(cli, ['queue', '--thread', record.id, '--message', text], {
+        encoding: 'utf8',
+        cwd: record.cwd,
+        timeout: 60000,
+        windowsHide: true,
+      })
+    : { status: 1, stdout: '', stderr: 'continuation is ' + text.length + ' chars, too long for argv; going straight to exec' };
   appendRun(runs, 'codex queue', queued);
   if (queued.status === 0) return { ok: true, how: 'codex queue' };
-  const run = spawnSync(cli, ['exec', 'resume', record.id, prompt, '--skip-git-repo-check'], {
+  const run = spawnSync(cli, ['exec', 'resume', record.id, '--skip-git-repo-check'], {
     encoding: 'utf8',
+    input: text,
     cwd: record.cwd,
     timeout: RESUME_TIMEOUT_MS,
     windowsHide: true,
@@ -245,7 +529,14 @@ function finish(state, record, outcome, detail, now) {
     Object.assign({}, record, { endedAt: now, outcome, detail: detail || null })
   );
   state.history = state.history.slice(-10);
-  state.armed = null;
+  if (outcome === 'resumed') {
+    try {
+      fs.unlinkSync(relay.planFile(record.id));
+    } catch (err) {
+      // No note, or already gone.
+    }
+  }
+  relay.dropRecord(state, record.id);
   relay.write(state);
   relay.note('wake ' + record.id + ': ' + outcome + (detail ? ' - ' + detail : ''), now);
   // Last, deliberately: this deletes the task this process is running under,
@@ -262,6 +553,11 @@ function finish(state, record, outcome, detail, now) {
 // `overrides` exists so the retry path can be tested without spawning a CLI or
 // registering a real scheduled task. Production passes nothing and gets the
 // real functions; only the names listed here can be swapped.
+// The record this wake owns, wherever the state keeps it.
+function mine(held, record) {
+  return relay.armedFor(held, record.id);
+}
+
 async function run(now, argv, overrides) {
   const deps = Object.assign(
     { windowReopened, deliverClaude, deliverCodex, toast, userIsPresent, arm: relay.arm, capabilities: relay.capabilities },
@@ -269,9 +565,12 @@ async function run(now, argv, overrides) {
   );
   const id = argOf(argv, '--id');
   const state = relay.read();
-  const record = state.armed;
-  if (!record) return { outcome: 'nothing-armed' };
-  if (id && record.id !== id) return { outcome: 'superseded' };
+  const record = id ? relay.armedFor(state, id) : state.armed;
+  if (!record) return { outcome: relay.records(state).length ? 'superseded' : 'nothing-armed' };
+  // Marked before anything else, so a wake that dies part-way (the 8:05 PM
+  // one was killed with its console) is told apart from one that never ran.
+  record.wokeAt = now;
+  relay.write(state);
 
   const config = relay.settings(state);
   const capabilities = deps.capabilities();
@@ -299,8 +598,8 @@ async function run(now, argv, overrides) {
     });
     if (again.ok) {
       const held = relay.read();
-      held.armed.attempt = attempt;
-      held.armed.continuation = record.continuation;
+      mine(held, record).attempt = attempt;
+      mine(held, record).continuation = record.continuation;
       relay.write(held);
     }
     relay.note('wake ' + record.id + ': window still at ' + Math.round(reopened.percent) + '%, retry ' + attempt, now);
@@ -339,10 +638,10 @@ async function run(now, argv, overrides) {
       });
       if (again.ok) {
         const held = relay.read();
-        if (held.armed) {
-          held.armed.offlineAttempt = offlineAttempt;
-          held.armed.attempt = record.attempt || 0;
-          held.armed.continuation = record.continuation;
+        if (mine(held, record)) {
+          mine(held, record).offlineAttempt = offlineAttempt;
+          mine(held, record).attempt = record.attempt || 0;
+          mine(held, record).continuation = record.continuation;
           relay.write(held);
         }
         // Said once, on the first miss, then quiet. Twelve toasts through the
@@ -371,7 +670,8 @@ async function run(now, argv, overrides) {
     continuation,
     work: record.work && record.work.todos ? record.work : null,
     thinking: config.thinking !== 'off',
-    voice: voice.card(),
+    voice: config.voice === false ? null : voice.card(),
+    bugcheck: config.bugcheck,
   });
 
   let mode = config.mode;
@@ -399,6 +699,31 @@ async function run(now, argv, overrides) {
 
   deps.toast('Usage limits: resuming', 'Carrying on with ' + (record.project || path.basename(record.cwd)) + ' where the limit stopped it.');
   const runs = [];
+  // The two start-up questions, answered again right before the launch in
+
+  // case anything reset them since arming.
+
+  if (record.host !== 'codex') {
+
+    if (record.launchCwd) {
+      try {
+        fs.mkdirSync(record.launchCwd, { recursive: true });
+      } catch (err) {
+      }
+    }
+    try {
+      const cj = relay.claudeJsonFile();
+      if (fs.existsSync(cj)) fs.copyFileSync(cj, cj + '.bak-usage-limits-wake');
+    } catch (err) {
+    }
+    const pre = relay.preflightPrompts(record.launchCwd || record.cwd, config);
+
+    if (pre.ok && pre.changes.length) relay.note('wake ' + record.id + ': pre-answered ' + pre.changes.join(', '), now);
+
+    else if (!pre.ok) relay.note('wake ' + record.id + ': could not pre-answer the start-up questions: ' + pre.error, now);
+
+  }
+
   const delivered = record.host === host.CODEX
     ? deps.deliverCodex(record, prompt, cli, runs)
     : deps.deliverClaude(record, prompt, config, cli, runs);
@@ -443,8 +768,8 @@ async function run(now, argv, overrides) {
     });
     if (again.ok) {
       const held = relay.read();
-      held.armed.attempt = attempt;
-      held.armed.continuation = record.continuation;
+      mine(held, record).attempt = attempt;
+      mine(held, record).continuation = record.continuation;
       relay.write(held);
       deps.toast(
         'Usage limits: retrying',
@@ -482,11 +807,11 @@ async function run(now, argv, overrides) {
     });
     if (nextWindow.ok) {
       const held = relay.read();
-      if (held.armed) {
-        held.armed.attempt = 0;
-        held.armed.offlineAttempt = 0;
-        held.armed.rearms = rearms + 1;
-        held.armed.continuation = record.continuation;
+      if (mine(held, record)) {
+        mine(held, record).attempt = 0;
+        mine(held, record).offlineAttempt = 0;
+        mine(held, record).rearms = rearms + 1;
+        mine(held, record).continuation = record.continuation;
         relay.write(held);
       }
       deps.toast('Usage limits: could not resume',
@@ -514,4 +839,4 @@ if (require.main === module) {
   );
 }
 
-module.exports = { run, toast, userIsPresent, claudeArgs, deliverClaude, deliverCodex, windowReopened, argOf, appendRun, spawnOptionsFor };
+module.exports = { launcherScriptPosix, shQuote, visibleArgs, launcherScript, pointerPrompt, transcriptExists, wakePromptFile, LAUNCH_GRACE_MS, run, toast, userIsPresent, claudeArgs, deliverClaude, deliverCodex, windowReopened, argOf, appendRun, spawnOptionsFor };