unsnooze 1.12.2 → 1.14.0

package/src/agents/qwen.js

@@ -101,6 +101,8 @@ export default {
   resumeArgs(sessionId) {
     return { args: sessionId ? ['--resume', sessionId] : ['--continue'], messageViaPane: true };
   },
+  // v1: every agent launches the bare TUI and gets the prompt typed once idle.
+  launchArgs(message) { return { args: [], messageViaPane: true }; },
   latestSessionId,
   isForegroundCommand(cmd) {
     return cmd === 'qwen' || cmd === 'node' || cmd === 'unsnooze';

package/src/askpass.js

@@ -0,0 +1,188 @@
+// Password source resolvers for fleet auth. Each is dependency-injected
+// (platform/run/env/isTTY/readSecret) so every OS branch is testable
+// anywhere. The SERVICE/ACCOUNT/VAR *names* may appear on argv; the secret
+// itself never does — it only ever comes back on stdout/stdin.
+import { execFileSync, spawnSync } from 'node:child_process';
+import { writeFileSync, chmodSync, mkdirSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+
+export class AuthError extends Error {
+  constructor(msg) { super(msg); this.name = 'AuthError'; this.needsAuth = true; }
+}
+
+function defaultRun(bin, args, opts) {
+  return execFileSync(bin, args, { encoding: 'utf-8', ...opts });
+}
+
+// Shell-based runner for the `command` source only: entry.cmd is the user's
+// own configured, trusted string (git-credential-helper style, e.g.
+// `credential.helper = !cmd`) — there is no untrusted input crossing this
+// boundary, so shell-execution is safe and lets users write pipelines,
+// quoted args, etc. Node picks /bin/sh on unix, cmd.exe on Windows.
+function defaultShellRun(cmd, opts) {
+  const res = spawnSync(cmd, { shell: true, encoding: 'utf-8', ...opts });
+  if (res.error) throw res.error;
+  // Carry the exit code but NOT the command's stderr: a secret tool that
+  // debug-prints the password to stderr must not leak it into an error
+  // message. resolveCommand builds its message from `.status` alone.
+  if (res.status !== 0) {
+    const err = new Error(`command source exited ${res.status}`);
+    err.status = res.status;
+    throw err;
+  }
+  return res.stdout;
+}
+
+const trimPw = (s) => String(s ?? '').replace(/\r?\n$/, '');
+
+export function resolveEnv(entry, { env = process.env } = {}) {
+  const v = env[entry.env];
+  if (v == null || v === '') throw new AuthError(`env var ${entry.env} is not set`);
+  return trimPw(v);
+}
+
+// entry.cmd is the user's own trusted command (git-credential-helper style)
+// — shell-executed for flexibility (quoting, pipes), not argv-split.
+export function resolveCommand(entry, { run = defaultShellRun } = {}) {
+  const cmd = String(entry.cmd || '').trim();
+  if (!cmd) throw new AuthError('empty command source');
+  let out;
+  try { out = run(cmd, { shell: true }); }
+  catch (e) {
+    // Build the message from the exit code ONLY — never from e.message, which
+    // may embed the command's own stderr (a secret tool debug-printing the
+    // password to stderr would otherwise leak it into `hosts test`/logs).
+    const code = Number.isInteger(e?.status) ? `exit ${e.status}` : 'could not run';
+    throw new AuthError(`command source failed (${code}) — check the --cmd command`);
+  }
+  const pw = trimPw(out);
+  if (!pw) throw new AuthError('command source produced no output');
+  return pw;
+}
+
+// Built-in keychain support is macOS-only (Keychain via `security`). On
+// Windows and Linux there is no safe, dependency-free built-in retrieval
+// path, so callers are pointed at --source command with a platform-native
+// one-liner (pass/secret-tool/powershell).
+export function resolveKeychain(entry, { platform = process.platform, run = defaultRun } = {}) {
+  if (platform === 'darwin') {
+    try {
+      return trimPw(run('security', ['find-generic-password', '-s', entry.service, '-a', entry.account, '-w']));
+    } catch {
+      throw new AuthError(`keychain miss for ${entry.service}/${entry.account}`);
+    }
+  }
+  throw new AuthError(
+    `no built-in keychain on ${platform} — use --source command (e.g. \`pass show\`, \`secret-tool lookup\`, or \`powershell -Command "..."\`)`,
+  );
+}
+
+export async function resolvePrompt(entry, { isTTY = process.stdin.isTTY, readSecret } = {}) {
+  if (!isTTY) throw new AuthError('prompt source needs an interactive terminal — use env/command/keychain for the daemon');
+  return await readSecret(`password for ${entry.dest || 'host'}: `);
+}
+
+export async function resolveSecret(entry, deps = {}) {
+  switch (entry.source) {
+    case 'env': return resolveEnv(entry, deps);
+    case 'command': return resolveCommand(entry, deps);
+    case 'keychain': return resolveKeychain(entry, deps);
+    case 'prompt': return await resolvePrompt(entry, deps);
+    default: throw new AuthError(`unknown source ${entry.source}`);
+  }
+}
+
+// No-echo password read from the controlling terminal. Rejects when stdin is
+// not a TTY (piped/daemon) — the caller must fall back to a stored source.
+// Every rejection is an AuthError (never a bare Error) so resolvePrompt's
+// caller can uniformly treat a failed read as "needs auth", not a crash.
+export function readSecret(prompt, { input = process.stdin, output = process.stderr } = {}) {
+  return new Promise((resolve, reject) => {
+    if (!input.isTTY) return reject(new AuthError('no terminal for prompt'));
+    output.write(prompt);
+    let buf = '';
+    let settled = false;
+    const done = (err, val) => {
+      if (settled) return;
+      settled = true;
+      try { input.setRawMode(false); } catch { /* ignore */ }
+      input.pause();
+      input.removeListener('data', onData);
+      input.removeListener('error', onError);
+      output.write('\n');
+      err ? reject(err) : resolve(val);
+    };
+    const onError = (e) => done(e instanceof AuthError ? e : new AuthError(`cannot read password: ${e.message}`));
+    const onData = (d) => {
+      const s = d.toString('utf8');
+      for (const ch of s) {
+        if (ch === '\n' || ch === '\r' || ch === '\x04') return done(null, buf);
+        if (ch === '\x03') return done(new AuthError('cancelled'));
+        if (ch === '\x7f' || ch === '\b') { buf = buf.slice(0, -1); continue; }
+        buf += ch;
+      }
+    };
+    input.resume();
+    input.setEncoding('utf8');
+    try { input.setRawMode(true); } catch (e) { return reject(new AuthError(`cannot read password: ${e.message}`)); }
+    input.on('data', onData);
+    input.on('error', onError);
+  });
+}
+
+export async function cmdAskpass(args = []) {
+  const host = process.env.UNSNOOZE_ASKPASS_HOST ?? args[0];
+  try {
+    // C1 part 2: dropping BatchMode for password hosts (sshEnvForHost) means
+    // ssh can now reach a yes/no host-key confirmation for an unknown host,
+    // not just a password request. OpenSSH >=8.4 sets
+    // SSH_ASKPASS_PROMPT=confirm for that case. Never hand back the secret
+    // here — fail closed with a hint instead; the user has to `ssh <host>`
+    // once manually to accept the host key before password auth can work.
+    if (process.env.SSH_ASKPASS_PROMPT === 'confirm') {
+      process.stderr.write(`unsnooze _askpass: host key not yet trusted for ${host} — run \`ssh ${host}\` once manually to accept it\n`);
+      return 1;
+    }
+    const { readHosts } = await import('./fleet.js');
+    const entry = readHosts()[host];
+    if (!entry || entry.auth !== 'password') {
+      process.stderr.write(`unsnooze _askpass: no password host ${host}\n`);
+      return 1;
+    }
+    const secret = await resolveSecret(entry, { readSecret });
+    process.stdout.write(secret);   // bare secret, ssh reads first line — nothing else to stdout
+    return 0;
+  } catch (e) {
+    process.stderr.write(`unsnooze _askpass: ${e.message}\n`);
+    return 1;
+  }
+}
+
+// Provision the file SSH_ASKPASS points at (see design §5c). The helper
+// itself reads the host from UNSNOOZE_ASKPASS_HOST (set in the ssh child env
+// by Task 5) because ssh controls the helper's argv — it passes only the
+// prompt text, never the host.
+export function ensureAskpassHelper({ platform = process.platform, stateDir, nodePath = process.execPath, scriptPath }) {
+  mkdirSync(stateDir, { recursive: true });
+  if (platform === 'win32') {
+    // Native ssh.exe needs a real exe; unix-like win ssh (Git/WSL) accepts a script.
+    // The resolution ladder (design §5c) is finalized in Task 7's cross-platform pass;
+    // here we write the unix-style .cmd wrapper used by Git-Bash/WSL and MSYS ssh.
+    const p = join(stateDir, 'askpass.cmd');
+    const tmp = p + `.tmp.${process.pid}`;
+    writeFileSync(tmp, `@echo off\r\n"${nodePath}" "${scriptPath}" _askpass %UNSNOOZE_ASKPASS_HOST%\r\n`);
+    renameSync(tmp, p);   // atomic: never a torn/partial file visible at p
+    return p;
+  }
+  const p = join(stateDir, 'askpass.sh');
+  // Write to a temp file then rename over p — a crash/concurrent read never
+  // observes a partially-written helper. Mode is applied to the tmp file at
+  // creation (writeFileSync's mode option only takes effect on a new file);
+  // chmodSync after the rename additionally corrects a pre-existing p left
+  // with the wrong mode by an older run.
+  const tmp = p + `.tmp.${process.pid}`;
+  writeFileSync(tmp, `#!/bin/sh\nexec "${nodePath}" "${scriptPath}" _askpass "$UNSNOOZE_ASKPASS_HOST"\n`, { mode: 0o700 });
+  renameSync(tmp, p);
+  chmodSync(p, 0o700);
+  return p;
+}

package/src/cli.js

@@ -2,6 +2,7 @@
 
 import { readFileSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
 import { LOG_FILE, MAX_RESUME_ATTEMPTS } from './config.js';
 import { readState, setStatus, updateState } from './state.js';
 import { getAgent } from './agents/index.js';
@@ -11,6 +12,11 @@ import { spawnResumerIfNeeded } from './spawn.js';
 import { getMultiplexer } from './multiplexer.js';
 import { listOwnedSessions, reap, attachHint } from './reap.js';
 import { planFor } from './resumer.js';
+import { queueList } from './prompt-queue.js';
+import {
+  shouldUseTui, formatStatusTui, formatSessionsTui, formatPreviewTui, logoBlock,
+} from './tui.js';
+import { shouldUseDashboard, runDashboard } from './dashboard/run.js';
 
 function fmtCountdown(ms) {
   if (ms <= 0) return 'due now';
@@ -20,6 +26,42 @@ function fmtCountdown(ms) {
   return `${h}h ${m % 60}m`;
 }
 
+// Shared by status's cwd column and prompt.js's queue listings — collapse the
+// home dir prefix to '~' the way most shells display it.
+export function shortenHome(p) {
+  if (typeof p !== 'string' || !p) return p;
+  const home = homedir();
+  if (p === home) return '~';
+  return p.startsWith(`${home}/`) ? `~${p.slice(home.length)}` : p;
+}
+
+// pending/launching are the only non-terminal prompt-queue statuses
+// (delivered/failed/cancelled are terminal — see prompt-queue.js).
+function pendingPromptEntries() {
+  return queueList().filter(e => e.status === 'pending' || e.status === 'launching');
+}
+
+function fmtQueueDue(e, now) {
+  if (Number.isFinite(e.notBefore) && e.notBefore > now) {
+    return `backoff until ${new Date(e.notBefore).toLocaleString()}`;
+  }
+  if (e.mode === 'now') return 'now';
+  if (e.mode === 'at') return new Date(e.atMs).toLocaleString();
+  return 'next reset';
+}
+
+// Printed after the sessions report in the plain-text `unsnooze status` —
+// silent (no section at all) when the queue has nothing pending, so the
+// existing status output is byte-identical for everyone not using the queue.
+function printPromptQueueSection(entries) {
+  if (entries.length === 0) return;
+  const now = Date.now();
+  console.log(`\nqueued prompts: ${entries.length}\n`);
+  for (const e of entries) {
+    console.log(`  ${e.id}  ${(e.agent || 'claude').padEnd(8)} ${fmtQueueDue(e, now).padEnd(28)} ${e.status.padEnd(9)} ${shortenHome(e.cwd)}`);
+  }
+}
+
 
 // Surface how the reset estimate was derived so a silent wrong guess can't hide.
 export function fmtResetProvenance(s) {
@@ -33,15 +75,80 @@ export function fmtResetProvenance(s) {
   return via ? `${s.resetSource}, from ${via}` : s.resetSource;
 }
 
-export async function cmdStatus() {
+export async function cmdStatus(args = []) {
+  if (args.includes('--json')) {
+    const state = readState();
+    const daemonRunning = (() => {
+      if (!state.resumerPid) return false;
+      try { process.kill(state.resumerPid, 0); return true; } catch { return false; }
+    })();
+    console.log(JSON.stringify({
+      version: 1,
+      resumerPid: daemonRunning ? state.resumerPid : null,
+      daemonRunning,
+      paused: !getConfig('autoResume'),
+      sessions: Object.values(state.sessions).map(s => ({
+        key: s.key, sessionId: s.sessionId ?? null, agent: s.agent ?? 'claude',
+        cwd: s.cwd ?? null, status: s.status, limitType: s.limitType ?? null,
+        resetAt: s.resetAt ?? null, resetSource: s.resetSource ?? null,
+        mux: s.mux ?? null, pane: s.pane ?? null, muxSession: s.muxSession ?? null,
+        attempts: s.attempts ?? 0, lastError: s.lastError ?? null,
+        workspaceHold: !!s.workspaceHold,
+      })),
+      promptQueue: queueList(),
+    }, null, 2));
+    return 0;
+  }
+  // Interactive TTY → live dashboard (until q). Pipes stay plain.
+  if (shouldUseDashboard()) return runDashboard({ tab: 'status' });
+
   const state = readState();
   const sessions = Object.values(state.sessions);
   const paused = !getConfig('autoResume');
+  const now = Date.now();
+  const useTui = shouldUseTui();
+
+  async function attachHintFor(s) {
+    if (!s.muxSession) return null;
+    try {
+      const mux = getMultiplexer(s.mux || 'tmux');
+      if (typeof mux.sessionExists === 'function' && await mux.sessionExists(s.muxSession)) {
+        return attachHint(s.mux, s.muxSession) || null;
+      }
+    } catch { /* omit */ }
+    return null;
+  }
+  function contextTokensFor(s) {
+    return getAgent(s.agent).contextTokens?.(s);
+  }
+
+  if (useTui) {
+    // Pre-resolve attach hints (async) for TUI cards.
+    const attachMap = new Map();
+    for (const s of sessions) {
+      const h = await attachHintFor(s);
+      if (h) attachMap.set(s.key, h);
+    }
+    console.log(formatStatusTui({
+      sessions,
+      resumerPid: state.resumerPid,
+      paused,
+      now,
+      fmtCountdown,
+      fmtResetProvenance,
+      approxTokens,
+      contextTokensFor,
+      attachHintFor: s => attachMap.get(s.key) || null,
+      color: true,
+    }));
+    return 0;
+  }
+
   if (sessions.length === 0) {
     console.log(`unsnooze: no tracked sessions.${paused ? '  (PAUSED — auto-resume off)' : ''}`);
+    printPromptQueueSection(pendingPromptEntries());
     return 0;
   }
-  const now = Date.now();
   const pausedNote = paused ? '  PAUSED — auto-resume off (`unsnooze config set autoResume on`)' : '';
   console.log(`unsnooze: ${sessions.length} tracked session(s)  (resumer pid: ${state.resumerPid ?? 'not running'})${pausedNote}\n`);
   for (const s of sessions.sort((a, b) => (a.resetAt || 0) - (b.resetAt || 0))) {
@@ -58,32 +165,24 @@ export async function cmdStatus() {
     const hold = s.workspaceHold
       ? ` · held: ${s.holdReason ?? '?'} — resume-now to wake`
       : '';
-    // The price of waking: estimated context tokens the API re-reads cold.
     let ctx = '';
     if (s.status === 'stopped') {
       try {
-        const t = getAgent(s.agent).contextTokens?.(s);
+        const t = contextTokensFor(s);
         if (t != null) ctx = ` · ctx ${approxTokens(t)} tok`;
       } catch { /* estimate unavailable — omit */ }
     }
-    // Attach hint when the mux session the record points at is still live.
     let attach = '';
-    if (s.muxSession) {
-      try {
-        const mux = getMultiplexer(s.mux || 'tmux');
-        if (typeof mux.sessionExists === 'function' && await mux.sessionExists(s.muxSession)) {
-          const hint = attachHint(s.mux, s.muxSession);
-          if (hint) attach = ` · attach: ${hint}`;
-        }
-      } catch { /* mux unavailable — omit */ }
-    }
+    const hint = await attachHintFor(s);
+    if (hint) attach = ` · attach: ${hint}`;
     console.log(`  [${s.status.toUpperCase().padEnd(9)}] ${id}  ${(s.agent || 'claude').padEnd(6)} ${s.limitType?.padEnd(7) ?? 'unknown'} ${s.cwd}`);
     console.log(`              mux ${s.mux ?? '-'} · pane ${pane} · session ${s.muxSession ?? '-'} · via ${origin} · resets ${reset} · attempts ${s.attempts ?? 0}/${MAX_RESUME_ATTEMPTS}${s.lastError ? ` · last error: ${s.lastError}` : ''}${msg}${ctx}${hold}${attach}`);
   }
+  printPromptQueueSection(pendingPromptEntries());
   return 0;
 }
 
-function selectKeys(state, idOrAll, statuses = ['stopped']) {
+export function selectKeys(state, idOrAll, statuses = ['stopped']) {
   const candidates = Object.values(state.sessions).filter(s => statuses.includes(s.status));
   if (idOrAll === '--all' || idOrAll === undefined) return candidates.map(s => s.key);
   const match = candidates.filter(s => s.key.startsWith(idOrAll) || (s.sessionId || '').startsWith(idOrAll));
@@ -107,6 +206,16 @@ export async function cmdResumeNow(idOrAll) {
       } catch { /* repo gone or git unhappy — proceed anyway */ }
     }
   }
+  markResumeNow(keys);
+  console.log(`unsnooze: marked ${keys.length} session(s) due now; resumer dispatched.`);
+  return 0;
+}
+
+// Shared core: mark sessions due now + manual (bypasses autoResume off and
+// workspace/context guards), clear any hold, dispatch the resumer. Used by
+// local `resume-now` and (future) remote-trigger fan-out — keep this the
+// single place that owns the mutation semantics.
+export function markResumeNow(keys) {
   updateState(s => {
     for (const key of keys) {
       if (s.sessions[key]) {
@@ -118,8 +227,7 @@ export async function cmdResumeNow(idOrAll) {
     }
   });
   spawnResumerIfNeeded();
-  console.log(`unsnooze: marked ${keys.length} session(s) due now; resumer dispatched.`);
-  return 0;
+  return keys;
 }
 
 export function cmdCancel(idOrAll) {
@@ -228,7 +336,6 @@ export async function cmdPreview(rest = [], {
       print(idOrAll ? `unsnooze preview: no session matching "${idOrAll}".` : 'unsnooze preview: no tracked sessions.');
       return 0;
     }
-    print('unsnooze preview — what WOULD happen right now (nothing is sent)\n');
     const VERBS = {
       inject: p => `would TYPE the wake message into pane ${p.target?.pane}`,
       'drive-menu': p => `would SELECT "Stop and wait for limit to reset" in pane ${p.target?.pane}`,
@@ -245,6 +352,9 @@ export async function cmdPreview(rest = [], {
       none: () => 'nothing to do',
     };
     let actionable = false;
+    const tuiEntries = [];
+    const useTui = shouldUseTui() && print === console.log;
+    if (!useTui) print('unsnooze preview — what WOULD happen right now (nothing is sent)\n');
     for (const rec of records.sort((x, y) => (x.resetAt || 0) - (y.resetAt || 0))) {
       let plan;
       try {
@@ -254,20 +364,29 @@ export async function cmdPreview(rest = [], {
           now,
         });
       } catch (err) {
-        print(`  ${rec.key.slice(0, 12)}: preview failed: ${err.message}`);
+        if (useTui) tuiEntries.push({ status: rec.status, id: rec.key.slice(0, 12), agent: rec.agent, cwd: rec.cwd, verb: `preview failed: ${err.message}`, gates: [] });
+        else print(`  ${rec.key.slice(0, 12)}: preview failed: ${err.message}`);
         continue;
       }
       const id = rec.sessionId ? rec.sessionId.slice(0, 8) : '(no id)';
-      print(`  [${(rec.status || '?').toUpperCase().padEnd(9)}] ${id}  ${(rec.agent || 'claude').padEnd(6)} ${rec.cwd || ''}`);
-      print(`              ${(VERBS[plan.action] || (() => plan.action))(plan)}`);
-      for (const g of plan.gates) print(`              · ${g}`);
+      const verb = (VERBS[plan.action] || (() => plan.action))(plan);
+      let message = null;
       if (plan.message && ['inject', 'reopen'].includes(plan.action)) {
-        const m = plan.message.length > 140 ? `${plan.message.slice(0, 140)}…` : plan.message;
-        print(`              message: "${m.replace(/\n+/g, ' ⏎ ')}"`);
+        message = plan.message.length > 140 ? `${plan.message.slice(0, 140)}…` : plan.message;
+        message = message.replace(/\n+/g, ' ⏎ ');
+      }
+      if (useTui) {
+        tuiEntries.push({ status: rec.status, id, agent: rec.agent, cwd: rec.cwd, verb, gates: plan.gates || [], message });
+      } else {
+        print(`  [${(rec.status || '?').toUpperCase().padEnd(9)}] ${id}  ${(rec.agent || 'claude').padEnd(6)} ${rec.cwd || ''}`);
+        print(`              ${verb}`);
+        for (const g of plan.gates) print(`              · ${g}`);
+        if (message) print(`              message: "${message}"`);
       }
       if (['inject', 'drive-menu', 'reopen'].includes(plan.action)) actionable = true;
     }
-    print('\nNothing was typed, opened, or modified. `unsnooze resume-now <id>` wakes a session immediately.');
+    if (useTui) print(formatPreviewTui(tuiEntries, { color: true }));
+    else print('\nNothing was typed, opened, or modified. `unsnooze resume-now <id>` wakes a session immediately.');
     return actionable ? 2 : 0;
   } catch (err) {
     console.error(`unsnooze preview: ${err.message}`);
@@ -277,7 +396,12 @@ export async function cmdPreview(rest = [], {
 
 // `unsnooze sessions` — list unsnooze-owned mux sessions with panes + records.
 export async function cmdSessions() {
+  if (shouldUseDashboard()) return runDashboard({ tab: 'sessions' });
   const owned = await listOwnedSessions();
+  if (shouldUseTui()) {
+    console.log(formatSessionsTui(owned, { color: true }));
+    return 0;
+  }
   if (owned.length === 0) {
     console.log('unsnooze: no unsnooze-owned mux sessions found.');
     return 0;

package/src/config.js

@@ -12,14 +12,29 @@ export const LOCK_DIR = join(STATE_DIR, 'state.lock');
 export const LOG_FILE = join(STATE_DIR, 'unsnooze.log');
 export const EVENTS_DIR = join(STATE_DIR, 'events');
 export const RESUMER_LOCK = join(STATE_DIR, 'resumer.lock');
+// High-frequency burn accumulator + warn-dedup (daemon single-writer).
+export const USAGE_FILE = join(STATE_DIR, 'usage.json');
 
 export const CLAUDE_DIR = process.env.UNSNOOZE_CLAUDE_DIR || join(homedir(), '.claude');
 export const CLAUDE_SETTINGS = join(CLAUDE_DIR, 'settings.json');
 export const CODEX_DIR = process.env.UNSNOOZE_CODEX_DIR || join(homedir(), '.codex');
+// Opt-in statusline shim drop dir for exact Claude rate_limits.
+export const USAGE_STATUSLINE_DIR = join(CLAUDE_DIR, 'unsnooze');
 
 // Transcript/rollout watcher (GUI detection channel)
 export const WATCH_OFFSETS_FILE = join(STATE_DIR, 'watch-offsets.json');
 
+// Usage forecast (1.13)
+export const USAGE_BURN_LOOKBACK_MS = envInt('UNSNOOZE_USAGE_BURN_LOOKBACK_MS', 60 * 60_000);
+export const USAGE_BURN_MIN_COVERAGE_MS = envInt('UNSNOOZE_USAGE_BURN_MIN_MS', 10 * 60_000);
+export const USAGE_IDLE_GAP_MS = envInt('UNSNOOZE_USAGE_IDLE_GAP_MS', 5 * 60_000);
+export const USAGE_WINDOW_IDLE_MS = envInt('UNSNOOZE_USAGE_WINDOW_IDLE_MS', 5 * 3_600_000);
+export const USAGE_CALIBRATION_RING = envInt('UNSNOOZE_USAGE_CAL_RING', 20);
+export const USAGE_CALIBRATION_MEDIAN_N = envInt('UNSNOOZE_USAGE_CAL_N', 5);
+// Time-to-wall warn tiers (minutes); comma-separated, not a config-file key.
+export const USAGE_ETA_WARN_MIN = (process.env.UNSNOOZE_USAGE_ETA_WARN_MIN || '30,10')
+  .split(',').map(Number).filter(n => Number.isFinite(n) && n > 0);
+
 // Interactive launcher base session name. The daemon never CREATES this name
 // (see RESUME_SESSION_NAME); it may only join it when already live.
 export const MUX_SESSION_NAME = process.env.UNSNOOZE_SESSION_NAME