@wbern/cc-ping 1.3.1 → 1.4.0

package/README.md

@@ -37,10 +37,11 @@ npm install -g @wbern/cc-ping   # also works
 
 ## Setup
 
-Discover accounts from `~/.claude-accounts/`, then verify they have valid credentials:
+Discover accounts from `~` (or a custom directory), then verify they have valid credentials:
 
 ```bash
-cc-ping scan              # auto-discover accounts
+cc-ping scan              # auto-discover accounts from ~
+cc-ping scan /path/to/dir # scan a specific directory
 cc-ping check             # verify credentials are valid
 cc-ping list              # show configured accounts
 ```
@@ -98,7 +99,7 @@ Show which account has its quota window resetting soonest — useful for knowing
 
 ### `cc-ping scan`
 
-Auto-discover accounts from `~/.claude-accounts/`. Each subdirectory with a `claude_user.json` is detected as an account. Duplicate identities (same `accountUuid` across directories) are flagged.
+Auto-discover Claude Code accounts. Scans `~` by default, or pass a directory to scan. Each subdirectory containing a `.claude.json` is detected as an account. Duplicate identities (same `accountUuid` across directories) are flagged.
 
 ### `cc-ping check`
 
@@ -141,6 +142,7 @@ cc-ping daemon stop                    # graceful shutdown
 | Flag | Default | Description |
 |------|---------|-------------|
 | `--interval <duration>` | `300m` | Time between ping cycles |
+| `--smart-schedule <on\|off>` | `on` | Time pings based on your usage patterns |
 | `--notify` | `false` | Desktop notification when new windows open |
 | `--bell` | `false` | Terminal bell on failure |
 | `--quiet` | `true` | Suppress per-account output in logs |
@@ -148,12 +150,52 @@ cc-ping daemon stop                    # graceful shutdown
 The daemon is smart about what it pings:
 
 - **Skips active windows** — accounts with a quota window still running are skipped to avoid wasting pings
+- **Retries failures** — if any accounts fail to ping, the daemon retries only the failed ones before sleeping
 - **Detects system sleep** — if the machine wakes from sleep and a ping cycle is overdue, the daemon notices and factors the delay into notifications
 - **Singleton enforcement** — only one daemon runs at a time, verified by PID and process name
-- **Graceful shutdown** — `daemon stop` writes a sentinel file and waits for a clean exit before force-killing
+- **Graceful shutdown** — `daemon stop` writes a sentinel file and waits up to 60s for a clean exit before force-killing
 
 Logs are written to `~/.config/cc-ping/daemon.log`.
 
+### Smart scheduling
+
+By default, the daemon analyzes your Claude Code usage history to time pings optimally. The goal: your 5-hour quota window expires right when you're most active, not while you're asleep.
+
+```
+Your typical day:
+
+      12am      6am       12pm      6pm       12am
+        |        |    ________|________  |        |
+        .  .  .  .  . |  coding time  |  .  .  .  .
+                            ^
+                       peak activity
+
+Fixed interval -- ping fires whenever the timer says:
+
+        [======= 5h window =======]
+       12am                       5am
+                                   ^ expires while you sleep
+
+Smart scheduling -- ping timed so window expires at peak:
+
+                      [======= 5h window =======]
+                     8am                        1pm
+                                                 ^ expires while you code!
+```
+
+**How it works:**
+
+1. Reads `<configDir>/history.jsonl` from each account's config directory (Claude Code's prompt timestamps)
+2. Builds an hour-of-day histogram from the last 14 days
+3. Finds the weighted midpoint of your activity
+4. Schedules pings at `midpoint - 5h` so the window expires at your peak
+
+**Defer zone:** When smart scheduling is active, pings that would fire in the 5 hours before the optimal time are deferred. Pings outside this zone proceed normally for continuous coverage.
+
+**Fallback:** If an account has fewer than 7 days of history or a flat usage pattern (no clear peak), smart scheduling is skipped and the fixed interval is used instead.
+
+To disable: `cc-ping daemon start --smart-schedule off`
+
 ### System service (survive reboots)
 
 `daemon start` runs as a detached process that won't survive a reboot. Use `daemon install` to register as a system service that starts automatically on login:
@@ -216,7 +258,7 @@ Key design choices:
 - **Arithmetic prompts** — random math questions minimize token usage (~150 input tokens, ~10 output). Templates and operands are randomized to avoid cache hits across pings.
 - **Tools disabled** — `--tools ""` prevents the model from doing anything beyond answering the question.
 - **Single turn** — `--max-turns 1` ensures one request-response cycle, no follow-ups.
-- **30s timeout** — pings that take longer are killed.
+- **30s timeout with hard kill** — pings that take longer are sent SIGKILL. A backstop timer force-resolves the promise even if the child process doesn't exit cleanly.
 - **Cost tracking** — each ping records its USD cost and token usage so you can audit spend.
 
 After a successful ping, the account's last-ping timestamp is saved to `~/.config/cc-ping/state.json`. The 5-hour quota window is calculated from this timestamp — commands like `status`, `suggest`, and the daemon all use it to determine window state.

package/dist/cli.js

@@ -290,9 +290,9 @@ function sendNotification(title, body, opts) {
   const exec = opts?.exec ?? defaultExecFile;
   const cmd = buildNotifyCommand(title, body, platform, { sound: opts?.sound });
   if (!cmd) return Promise.resolve(false);
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     exec(cmd[0], cmd[1], (error) => {
-      resolve(!error);
+      resolve2(!error);
     });
   });
 }
@@ -386,7 +386,8 @@ function formatExecError(error) {
 }
 function pingOne(account) {
   const start = Date.now();
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
+    let resolved = false;
     const child = execFile(
       "claude",
       [
@@ -401,9 +402,13 @@ function pingOne(account) {
       ],
       {
         env: { ...process.env, CLAUDE_CONFIG_DIR: account.configDir },
-        timeout: 3e4
+        timeout: PING_TIMEOUT_MS,
+        killSignal: "SIGKILL"
       },
       (error, stdout) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(hardKillTimer);
         const claudeResponse = parseClaudeResponse(stdout) ?? void 0;
         const isError = claudeResponse?.is_error === true;
         let errorMsg;
@@ -416,7 +421,7 @@ function pingOne(account) {
         } else if (isError) {
           errorMsg = claudeResponse?.subtype;
         }
-        resolve({
+        resolve2({
           handle: account.handle,
           success: !error && !isError,
           durationMs: Date.now() - start,
@@ -425,6 +430,21 @@ function pingOne(account) {
         });
       }
     );
+    const hardKillTimer = setTimeout(() => {
+      if (resolved) return;
+      resolved = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      resolve2({
+        handle: account.handle,
+        success: false,
+        durationMs: Date.now() - start,
+        error: "timed out"
+      });
+    }, PING_TIMEOUT_MS + KILL_GRACE_MS);
+    hardKillTimer.unref();
     child.stdin?.end();
   });
 }
@@ -438,11 +458,14 @@ async function pingAccounts(accounts, options = {}) {
   }
   return results;
 }
+var PING_TIMEOUT_MS, KILL_GRACE_MS;
 var init_ping = __esm({
   "src/ping.ts"() {
     "use strict";
     init_parse();
     init_prompt();
+    PING_TIMEOUT_MS = 3e4;
+    KILL_GRACE_MS = 5e3;
   }
 });
 
@@ -465,7 +488,7 @@ async function runPing(accounts, options) {
     }
   }
   logger.log(`Pinging ${accounts.length} account(s)...`);
-  const sleep = options._sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const sleep = options._sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
   let results;
   if (options.staggerMs && options.staggerMs > 0 && accounts.length > 1) {
     results = [];
@@ -517,10 +540,10 @@ async function runPing(accounts, options) {
     ringBell();
   }
   if (failed > 0 && options.notify) {
-    const failedHandles = results.filter((r) => !r.success).map((r) => r.handle);
+    const failedHandles2 = results.filter((r) => !r.success).map((r) => r.handle);
     await sendNotification(
       "cc-ping: ping failure",
-      `${failed} account(s) failed: ${failedHandles.join(", ")}`
+      `${failed} account(s) failed: ${failedHandles2.join(", ")}`
     );
   }
   if (options.notify) {
@@ -533,6 +556,7 @@ async function runPing(accounts, options) {
       await sendNotification("cc-ping: new window", body, { sound: true });
     }
   }
+  const failedHandles = results.filter((r) => !r.success).map((r) => r.handle);
   if (options.json) {
     const jsonResults = results.map((r) => ({
       handle: r.handle,
@@ -541,11 +565,11 @@ async function runPing(accounts, options) {
       error: r.error
     }));
     stdout(JSON.stringify(jsonResults, null, 2));
-    return failed > 0 ? 1 : 0;
+    return { exitCode: failed > 0 ? 1 : 0, failedHandles };
   }
   if (failed > 0) {
     logger.error(`${failed}/${results.length} failed`);
-    return 1;
+    return { exitCode: 1, failedHandles };
   }
   logger.log(`
 All ${results.length} accounts pinged successfully`);
@@ -558,7 +582,7 @@ All ${results.length} accounts pinged successfully`);
       );
     }
   }
-  return 0;
+  return { exitCode: 0, failedHandles: [] };
 }
 var init_run_ping = __esm({
   "src/run-ping.ts"() {
@@ -573,6 +597,101 @@ var init_run_ping = __esm({
   }
 });
 
+// src/schedule.ts
+var schedule_exports = {};
+__export(schedule_exports, {
+  buildHourHistogram: () => buildHourHistogram,
+  findOptimalPingHour: () => findOptimalPingHour,
+  getAccountSchedule: () => getAccountSchedule,
+  parseSmartSchedule: () => parseSmartSchedule,
+  readAccountSchedule: () => readAccountSchedule,
+  shouldDefer: () => shouldDefer
+});
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
+function buildHourHistogram(timestamps) {
+  const bins = new Array(24).fill(0);
+  for (const ts of timestamps) {
+    bins[ts.getUTCHours()]++;
+  }
+  return bins;
+}
+function findOptimalPingHour(histogram) {
+  const total = histogram.reduce((sum, v) => sum + v, 0);
+  if (total === 0) return -1;
+  const HOUR_TO_RAD = 2 * Math.PI / 24;
+  let sinSum = 0;
+  let cosSum = 0;
+  for (let h = 0; h < 24; h++) {
+    const angle = h * HOUR_TO_RAD;
+    sinSum += histogram[h] * Math.sin(angle);
+    cosSum += histogram[h] * Math.cos(angle);
+  }
+  const meanAngle = Math.atan2(sinSum, cosSum);
+  const midpoint = Math.round((meanAngle / HOUR_TO_RAD + 24) % 24);
+  return (midpoint - QUOTA_WINDOW_HOURS + 24) % 24;
+}
+function shouldDefer(now, optimalPingHour) {
+  const currentHour = now.getUTCHours();
+  const zoneStart = (optimalPingHour - QUOTA_WINDOW_HOURS + 24) % 24;
+  const inZone = zoneStart < optimalPingHour ? currentHour >= zoneStart && currentHour < optimalPingHour : currentHour >= zoneStart || currentHour < optimalPingHour;
+  if (inZone) {
+    return { defer: true, deferUntilUtcHour: optimalPingHour };
+  }
+  return { defer: false };
+}
+function getAccountSchedule(historyLines, now = /* @__PURE__ */ new Date()) {
+  const cutoff = now.getTime() - HISTORY_WINDOW_MS;
+  const timestamps = [];
+  const daysSeen = /* @__PURE__ */ new Set();
+  for (const line of historyLines) {
+    try {
+      const entry = JSON.parse(line);
+      if (typeof entry.timestamp !== "number") continue;
+      if (entry.timestamp < cutoff) continue;
+      const date = new Date(entry.timestamp);
+      timestamps.push(date);
+      daysSeen.add(date.toISOString().slice(0, 10));
+    } catch {
+    }
+  }
+  if (daysSeen.size < MIN_DAYS) return null;
+  const histogram = buildHourHistogram(timestamps);
+  const total = histogram.reduce((sum, v) => sum + v, 0);
+  const avg = total / 24;
+  const max = Math.max(...histogram);
+  if (max <= avg * 1.5) return null;
+  const optimalPingHour = findOptimalPingHour(histogram);
+  if (optimalPingHour === -1) return null;
+  return { optimalPingHour, histogram };
+}
+function readAccountSchedule(configDir, now = /* @__PURE__ */ new Date()) {
+  const historyPath = join6(configDir, "history.jsonl");
+  if (!existsSync5(historyPath)) return null;
+  const content = readFileSync5(historyPath, "utf-8");
+  const lines = content.split("\n").filter((l) => l.trim());
+  return getAccountSchedule(lines, now);
+}
+function parseSmartSchedule(value) {
+  const lower = value.toLowerCase();
+  if (TRUTHY.has(lower)) return true;
+  if (FALSY.has(lower)) return false;
+  throw new Error(
+    `Invalid smart-schedule value: "${value}". Use true/false, on/off, or 1/0`
+  );
+}
+var QUOTA_WINDOW_HOURS, MIN_DAYS, HISTORY_WINDOW_MS, TRUTHY, FALSY;
+var init_schedule = __esm({
+  "src/schedule.ts"() {
+    "use strict";
+    QUOTA_WINDOW_HOURS = 5;
+    MIN_DAYS = 7;
+    HISTORY_WINDOW_MS = 14 * 24 * 60 * 60 * 1e3;
+    TRUTHY = /* @__PURE__ */ new Set(["true", "on", "1"]);
+    FALSY = /* @__PURE__ */ new Set(["false", "off", "0"]);
+  }
+});
+
 // src/daemon.ts
 var daemon_exports = {};
 __export(daemon_exports, {
@@ -593,23 +712,23 @@ __export(daemon_exports, {
 });
 import { execSync, spawn } from "child_process";
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   closeSync as fsCloseSync,
   openSync as fsOpenSync,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   unlinkSync,
   writeFileSync as writeFileSync3
 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 function daemonPidPath() {
-  return join6(resolveConfigDir(), "daemon.json");
+  return join7(resolveConfigDir(), "daemon.json");
 }
 function daemonLogPath() {
-  return join6(resolveConfigDir(), "daemon.log");
+  return join7(resolveConfigDir(), "daemon.log");
 }
 function daemonStopPath() {
-  return join6(resolveConfigDir(), "daemon.stop");
+  return join7(resolveConfigDir(), "daemon.stop");
 }
 function writeDaemonState(state) {
   const configDir = resolveConfigDir();
@@ -619,9 +738,9 @@ function writeDaemonState(state) {
 }
 function readDaemonState() {
   const pidPath = daemonPidPath();
-  if (!existsSync5(pidPath)) return null;
+  if (!existsSync6(pidPath)) return null;
   try {
-    const raw = readFileSync5(pidPath, "utf-8");
+    const raw = readFileSync6(pidPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -629,7 +748,7 @@ function readDaemonState() {
 }
 function removeDaemonState() {
   const pidPath = daemonPidPath();
-  if (!existsSync5(pidPath)) return false;
+  if (!existsSync6(pidPath)) return false;
   unlinkSync(pidPath);
   return true;
 }
@@ -703,11 +822,25 @@ async function daemonLoop(intervalMs, options, deps) {
   let wakeDelayMs;
   while (!deps.shouldStop()) {
     const allAccounts = deps.listAccounts();
-    const accounts = deps.isWindowActive ? allAccounts.filter((a) => !deps.isWindowActive(a.handle)) : allAccounts;
+    let accounts = deps.isWindowActive ? allAccounts.filter((a) => !deps.isWindowActive(a.handle)) : allAccounts;
     const skipped = allAccounts.length - accounts.length;
     if (skipped > 0) {
       deps.log(`Skipping ${skipped} account(s) with active window`);
     }
+    if (deps.shouldDeferPing) {
+      const deferResults = /* @__PURE__ */ new Map();
+      for (const a of accounts) {
+        deferResults.set(
+          a.handle,
+          deps.shouldDeferPing(a.handle, a.configDir).defer
+        );
+      }
+      const deferredCount = [...deferResults.values()].filter(Boolean).length;
+      if (deferredCount > 0) {
+        accounts = accounts.filter((a) => !deferResults.get(a.handle));
+        deps.log(`Deferring ${deferredCount} account(s) (smart scheduling)`);
+      }
+    }
     if (accounts.length === 0) {
       deps.log(
         allAccounts.length === 0 ? "No accounts configured, waiting..." : "All accounts have active windows, waiting..."
@@ -716,13 +849,26 @@ async function daemonLoop(intervalMs, options, deps) {
       deps.log(
         `[${(/* @__PURE__ */ new Date()).toISOString()}] Pinging ${accounts.length} account(s)...`
       );
-      await deps.runPing(accounts, {
+      const pingOpts = {
         parallel: false,
         quiet: options.quiet ?? true,
         bell: options.bell,
         notify: options.notify,
         wakeDelayMs
-      });
+      };
+      const { failedHandles } = await deps.runPing(accounts, pingOpts);
+      if (failedHandles.length > 0 && !deps.shouldStop()) {
+        const retryAccounts = accounts.filter(
+          (a) => failedHandles.includes(a.handle)
+        );
+        if (retryAccounts.length > 0) {
+          deps.log(`Retrying ${retryAccounts.length} account(s)...`);
+          const retry = await deps.runPing(retryAccounts, pingOpts);
+          if (retry.failedHandles.length > 0) {
+            deps.log(`Retry failed for: ${retry.failedHandles.join(", ")}`);
+          }
+        }
+      }
       deps.updateState?.({ lastPingAt: (/* @__PURE__ */ new Date()).toISOString() });
     }
     if (deps.shouldStop()) break;
@@ -766,6 +912,7 @@ function startDaemon(options, deps) {
   if (options.quiet) args.push("--quiet");
   if (options.bell) args.push("--bell");
   if (options.notify) args.push("--notify");
+  if (options.smartSchedule === false) args.push("--smart-schedule", "off");
   const child = _spawn(process.execPath, [process.argv[1], ...args], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
@@ -798,9 +945,9 @@ async function stopDaemon(deps) {
   const _removeStopFile = deps?.removeStopFile ?? /* c8 ignore next 4 -- production default */
   (() => {
     const stopPath = daemonStopPath();
-    if (existsSync5(stopPath)) unlinkSync(stopPath);
+    if (existsSync6(stopPath)) unlinkSync(stopPath);
   });
-  const _sleep = deps?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const _sleep = deps?.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
   const _kill = deps?.kill ?? /* c8 ignore next 7 -- production default */
   ((pid2) => {
     if (process.platform === "win32") {
@@ -834,9 +981,9 @@ async function stopDaemon(deps) {
 }
 async function runDaemon(intervalMs, options, deps) {
   const stopPath = daemonStopPath();
-  if (existsSync5(stopPath)) unlinkSync(stopPath);
+  if (existsSync6(stopPath)) unlinkSync(stopPath);
   const cleanup = () => {
-    if (existsSync5(stopPath)) unlinkSync(stopPath);
+    if (existsSync6(stopPath)) unlinkSync(stopPath);
     removeDaemonState();
   };
   const onSigterm = () => {
@@ -866,13 +1013,36 @@ async function runDaemonWithDefaults(intervalMs, options) {
   const { runPing: runPing2 } = await Promise.resolve().then(() => (init_run_ping(), run_ping_exports));
   const { listAccounts: listAccounts2 } = await Promise.resolve().then(() => (init_config(), config_exports));
   const { getWindowReset: getWindowReset2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+  const smartScheduleEnabled = options.smartSchedule !== false;
+  let shouldDeferPing;
+  if (smartScheduleEnabled) {
+    const { readAccountSchedule: readAccountSchedule2, shouldDefer: shouldDefer2 } = await Promise.resolve().then(() => (init_schedule(), schedule_exports));
+    for (const account of listAccounts2()) {
+      const schedule = readAccountSchedule2(account.configDir);
+      if (schedule) {
+        console.log(
+          `Smart schedule: ${account.handle} \u2192 optimal ping at ${schedule.optimalPingHour}:00 UTC`
+        );
+      } else {
+        console.log(
+          `Smart schedule: ${account.handle} \u2192 insufficient history, using fixed interval`
+        );
+      }
+    }
+    shouldDeferPing = (_handle, configDir) => {
+      const schedule = readAccountSchedule2(configDir);
+      if (!schedule) return { defer: false };
+      return shouldDefer2(/* @__PURE__ */ new Date(), schedule.optimalPingHour);
+    };
+  }
   await runDaemon(intervalMs, options, {
     runPing: runPing2,
     listAccounts: listAccounts2,
-    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-    shouldStop: () => existsSync5(stopPath),
+    sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
+    shouldStop: () => existsSync6(stopPath),
     log: (msg) => console.log(msg),
     isWindowActive: (handle) => getWindowReset2(handle) !== null,
+    shouldDeferPing,
     updateState: (patch) => {
       const current = readDaemonState();
       if (current) writeDaemonState({ ...current, ...patch });
@@ -889,7 +1059,7 @@ var init_daemon = __esm({
     init_paths();
     init_state();
     GRACEFUL_POLL_MS = 500;
-    GRACEFUL_POLL_ATTEMPTS = 20;
+    GRACEFUL_POLL_ATTEMPTS = 120;
     POST_KILL_DELAY_MS = 1e3;
   }
 });
@@ -913,7 +1083,7 @@ import {
   writeFileSync as nodeWriteFileSync
 } from "fs";
 import { homedir as nodeHomedir } from "os";
-import { dirname, join as join9 } from "path";
+import { dirname, join as join10 } from "path";
 function resolveExecutable(deps) {
   try {
     const path = deps.execSync("which cc-ping", {
@@ -942,10 +1112,12 @@ function generateLaunchdPlist(options, execInfo, configDir) {
   if (options.quiet) programArgs.push("--quiet");
   if (options.bell) programArgs.push("--bell");
   if (options.notify) programArgs.push("--notify");
+  if (options.smartSchedule === false)
+    programArgs.push("--smart-schedule", "off");
   const allArgs = [execInfo.executable, ...programArgs];
   const argsXml = allArgs.map((a) => `      <string>${escapeXml(a)}</string>`).join("\n");
-  const logPath = join9(
-    configDir || join9(nodeHomedir(), ".config", "cc-ping"),
+  const logPath = join10(
+    configDir || join10(nodeHomedir(), ".config", "cc-ping"),
     "daemon.log"
   );
   let envSection = "";
@@ -994,6 +1166,8 @@ function generateSystemdUnit(options, execInfo, configDir) {
   if (options.quiet) programArgs.push("--quiet");
   if (options.bell) programArgs.push("--bell");
   if (options.notify) programArgs.push("--notify");
+  if (options.smartSchedule === false)
+    programArgs.push("--smart-schedule", "off");
   const execStart = [execInfo.executable, ...programArgs].map((a) => a.includes(" ") ? `"${a}"` : a).join(" ");
   let envLine = "";
   if (configDir) {
@@ -1016,9 +1190,9 @@ WantedBy=default.target
 function servicePath(platform, home) {
   switch (platform) {
     case "darwin":
-      return join9(home, "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+      return join10(home, "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
     case "linux":
-      return join9(
+      return join10(
         home,
         ".config",
         "systemd",
@@ -1164,7 +1338,7 @@ var init_service = __esm({
 });
 
 // src/cli.ts
-import { basename } from "path";
+import { basename, resolve } from "path";
 import { Command } from "commander";
 
 // src/check.ts
@@ -1429,12 +1603,12 @@ init_daemon();
 init_config();
 
 // src/identity.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { join as join8 } from "path";
 function readAccountIdentity(configDir) {
   let raw;
   try {
-    raw = readFileSync6(join7(configDir, ".claude.json"), "utf-8");
+    raw = readFileSync7(join8(configDir, ".claude.json"), "utf-8");
   } catch {
     return null;
   }
@@ -1625,21 +1799,24 @@ init_paths();
 init_run_ping();
 
 // src/scan.ts
-import { existsSync as existsSync6, readdirSync, statSync as statSync2 } from "fs";
+import { existsSync as existsSync7, readdirSync, statSync as statSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join8 } from "path";
-var ACCOUNTS_DIR = join8(homedir2(), ".claude-accounts");
-function scanAccounts() {
-  if (!existsSync6(ACCOUNTS_DIR)) return [];
-  return readdirSync(ACCOUNTS_DIR).filter((name) => {
-    const full = join8(ACCOUNTS_DIR, name);
-    return statSync2(full).isDirectory() && !name.startsWith(".");
+import { join as join9 } from "path";
+function scanAccounts(dir) {
+  const accountsDir = dir ?? homedir2();
+  if (!existsSync7(accountsDir)) return [];
+  return readdirSync(accountsDir).filter((name) => {
+    const full = join9(accountsDir, name);
+    return statSync2(full).isDirectory() && !name.startsWith(".") && existsSync7(join9(full, ".claude.json"));
   }).map((name) => ({
     handle: name,
-    configDir: join8(ACCOUNTS_DIR, name)
+    configDir: join9(accountsDir, name)
   }));
 }
 
+// src/cli.ts
+init_schedule();
+
 // src/stagger.ts
 init_state();
 function calculateStagger(accountCount, windowMs = QUOTA_WINDOW_MS) {
@@ -1691,7 +1868,7 @@ function suggestAccount(accounts, now = /* @__PURE__ */ new Date()) {
 }
 
 // src/cli.ts
-var program = new Command().name("cc-ping").description("Ping Claude Code sessions to trigger quota windows early").version("1.3.1").option(
+var program = new Command().name("cc-ping").description("Ping Claude Code sessions to trigger quota windows early").version("1.4.0").option(
   "--config <path>",
   "Path to config directory (default: ~/.config/cc-ping, env: CC_PING_CONFIG)"
 ).hook("preAction", (thisCommand) => {
@@ -1724,7 +1901,7 @@ program.command("ping").description("Ping configured accounts to start quota win
     process.exit(0);
   }
   const staggerMs = opts.stagger ? parseStagger(opts.stagger, targets.length) : void 0;
-  const exitCode = await runPing(targets, {
+  const { exitCode } = await runPing(targets, {
     parallel: opts.parallel,
     quiet: opts.quiet,
     json: opts.json,
@@ -1757,10 +1934,11 @@ program.command("check").description(
     process.exit(1);
   }
 });
-program.command("scan").description("Auto-discover accounts from ~/.claude-accounts/").option("--dry-run", "Show what would be added without saving", false).action((opts) => {
-  const found = scanAccounts();
+program.command("scan").description("Auto-discover Claude Code accounts (scans ~ by default)").argument("[dir]", "Directory to scan (default: ~)").option("--dry-run", "Show what would be added without saving", false).action((dir, opts) => {
+  const scanDir = dir ? resolve(dir) : void 0;
+  const found = scanAccounts(scanDir);
   if (found.length === 0) {
-    console.log("No accounts found in ~/.claude-accounts/");
+    console.log(`No accounts found in ${scanDir ?? "~"}`);
     return;
   }
   console.log(`Found ${found.length} account(s):`);
@@ -1897,12 +2075,20 @@ var daemon = program.command("daemon").description("Run auto-ping on a schedule"
 daemon.command("start").description("Start the daemon process").option(
   "--interval <minutes>",
   "Ping interval in minutes (default: 300 = 5h quota window)"
-).option("-q, --quiet", "Suppress ping output", false).option("--bell", "Ring terminal bell on ping failure", false).option("--notify", "Send desktop notification on ping failure", false).action(async (opts) => {
+).option("-q, --quiet", "Suppress ping output", false).option("--bell", "Ring terminal bell on ping failure", false).option("--notify", "Send desktop notification on ping failure", false).option(
+  "--smart-schedule <on|off>",
+  "Time pings based on usage patterns (default: on)"
+).action(async (opts) => {
+  let smartSchedule;
+  if (opts.smartSchedule !== void 0) {
+    smartSchedule = parseSmartSchedule(opts.smartSchedule);
+  }
   const result = startDaemon({
     interval: opts.interval,
     quiet: opts.quiet,
     bell: opts.bell,
-    notify: opts.notify
+    notify: opts.notify,
+    smartSchedule
   });
   if (!result.success) {
     console.error(result.error);
@@ -1991,13 +2177,21 @@ daemon.command("status").description("Show daemon status").option("--json", "Out
 daemon.command("install").description("Install daemon as a system service (launchd/systemd)").option(
   "--interval <minutes>",
   "Ping interval in minutes (default: 300 = 5h quota window)"
-).option("-q, --quiet", "Suppress ping output", false).option("--bell", "Ring terminal bell on ping failure", false).option("--notify", "Send desktop notification on ping failure", false).action(async (opts) => {
+).option("-q, --quiet", "Suppress ping output", false).option("--bell", "Ring terminal bell on ping failure", false).option("--notify", "Send desktop notification on ping failure", false).option(
+  "--smart-schedule <on|off>",
+  "Time pings based on usage patterns (default: on)"
+).action(async (opts) => {
+  let smartSchedule;
+  if (opts.smartSchedule !== void 0) {
+    smartSchedule = parseSmartSchedule(opts.smartSchedule);
+  }
   const { installService: installService2 } = await Promise.resolve().then(() => (init_service(), service_exports));
   const result = await installService2({
     interval: opts.interval,
     quiet: opts.quiet,
     bell: opts.bell,
-    notify: opts.notify
+    notify: opts.notify,
+    smartSchedule
   });
   if (!result.success) {
     console.error(result.error);
@@ -2017,12 +2211,16 @@ daemon.command("uninstall").description("Remove daemon system service").action(a
   }
   console.log(`Service removed: ${result.servicePath}`);
 });
-daemon.command("_run", { hidden: true }).option("--interval-ms <ms>", "Ping interval in milliseconds").option("-q, --quiet", "Suppress ping output", false).option("--bell", "Ring terminal bell on ping failure", false).option("--notify", "Send desktop notification on ping failure", false).action(async (opts) => {
+daemon.command("_run", { hidden: true }).option("--interval-ms <ms>", "Ping interval in milliseconds").option("-q, --quiet", "Suppress ping output", false).option("--bell", "Ring terminal bell on ping failure", false).option("--notify", "Send desktop notification on ping failure", false).option("--smart-schedule <on|off>", "Smart scheduling (default: on)").action(async (opts) => {
   const intervalMs = Number(opts.intervalMs);
   if (!intervalMs || intervalMs <= 0) {
     console.error("Invalid --interval-ms");
     process.exit(1);
   }
+  let smartSchedule;
+  if (opts.smartSchedule !== void 0) {
+    smartSchedule = parseSmartSchedule(opts.smartSchedule);
+  }
   if (!readDaemonState()) {
     const { resolveConfigDir: resolveConfigDir2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
     writeDaemonState({
@@ -2035,7 +2233,8 @@ daemon.command("_run", { hidden: true }).option("--interval-ms <ms>", "Ping inte
   await runDaemonWithDefaults(intervalMs, {
     quiet: opts.quiet,
     bell: opts.bell,
-    notify: opts.notify
+    notify: opts.notify,
+    smartSchedule
   });
 });
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wbern/cc-ping",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Ping Claude Code sessions to trigger quota windows early across multiple accounts",
   "type": "module",
   "bin": {