metame-cli 1.5.19 → 1.5.20

package/index.js

@@ -7,7 +7,8 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { spawn, execSync } = require('child_process');
-const { sleepSync, findProcessesByPattern, icon } = require('./scripts/platform');
+const { sleepSync, findProcessesByPattern, killProcessTree, icon } = require('./scripts/platform');
+const { collectDeployGroups, collectSyntaxCheckFiles } = require('./scripts/deploy-manifest');
 
 // On Windows, resolve .cmd wrapper → actual Node.js entry and spawn node directly.
 // Completely bypasses cmd.exe, eliminating terminal flash.
@@ -254,6 +255,16 @@ function readRunningDaemonPid({ pidFile, lockFile }) {
   return null;
 }
 
+function isPidAlive(pid) {
+  if (!pid || Number.isNaN(pid) || pid === process.pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // --- macOS launchd integration ---
 const LAUNCHD_LABEL = 'com.metame.npm-daemon';
 const LAUNCHD_PLIST = path.join(HOME_DIR, 'Library', 'LaunchAgents', `${LAUNCHD_LABEL}.plist`);
@@ -318,6 +329,99 @@ function launchdIsRunning() {
   } catch { return null; }
 }
 
+function cleanDaemonRuntimeState({ pidFile, lockFile }) {
+  try {
+    if (fs.existsSync(pidFile)) {
+      const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+      if (!isPidAlive(pid)) fs.unlinkSync(pidFile);
+    }
+  } catch {
+    try { fs.unlinkSync(pidFile); } catch { /* ignore */ }
+  }
+  try {
+    if (fs.existsSync(lockFile)) {
+      const lock = JSON.parse(fs.readFileSync(lockFile, 'utf8'));
+      const pid = parseInt(lock && lock.pid, 10);
+      if (!isPidAlive(pid)) fs.unlinkSync(lockFile);
+    }
+  } catch {
+    try { fs.unlinkSync(lockFile); } catch { /* ignore */ }
+  }
+}
+
+function terminateDaemonProcesses({
+  pidFile,
+  lockFile,
+  preservePid = null,
+}) {
+  const targets = new Set();
+  for (const pid of findProcessesByPattern('node.*daemon\\.js')) {
+    if (pid && pid !== process.pid && pid !== preservePid) targets.add(pid);
+  }
+  for (const file of [pidFile, lockFile]) {
+    if (!fs.existsSync(file)) continue;
+    try {
+      const raw = fs.readFileSync(file, 'utf8').trim();
+      const pid = file === pidFile
+        ? parseInt(raw, 10)
+        : parseInt((JSON.parse(raw || '{}') || {}).pid, 10);
+      if (pid && pid !== process.pid && pid !== preservePid && isPidAlive(pid)) targets.add(pid);
+    } catch { /* ignore invalid metadata */ }
+  }
+
+  if (!targets.size) {
+    cleanDaemonRuntimeState({ pidFile, lockFile });
+    return [];
+  }
+
+  for (const pid of targets) killProcessTree(pid, 'SIGTERM');
+  sleepSync(1500);
+  for (const pid of targets) {
+    if (isPidAlive(pid)) killProcessTree(pid, 'SIGKILL');
+  }
+  sleepSync(500);
+  cleanDaemonRuntimeState({ pidFile, lockFile });
+  return [...targets];
+}
+
+function ensureLaunchdDaemonRunning({
+  daemonScript,
+  daemonLog,
+  pidFile,
+  lockFile,
+  restart = false,
+}) {
+  ensureLaunchdPlist({ daemonScript, daemonLog });
+  let launchdPid = launchdIsRunning();
+
+  if (launchdPid) {
+    terminateDaemonProcesses({ pidFile, lockFile, preservePid: launchdPid });
+  } else {
+    terminateDaemonProcesses({ pidFile, lockFile });
+  }
+
+  try {
+    execSync(`launchctl bootstrap gui/$(id -u) ${LAUNCHD_PLIST} 2>/dev/null`);
+  } catch { /* already bootstrapped */ }
+
+  try {
+    execSync(`launchctl kickstart ${restart ? '-k ' : ''}gui/$(id -u)/${LAUNCHD_LABEL}`);
+  } catch {
+    // Recover from a stale/removed launchd service entry.
+    try { execSync(`launchctl bootout gui/$(id -u)/${LAUNCHD_LABEL} 2>/dev/null`); } catch { /* ignore */ }
+    terminateDaemonProcesses({ pidFile, lockFile });
+    execSync(`launchctl bootstrap gui/$(id -u) ${LAUNCHD_PLIST}`);
+    execSync(`launchctl kickstart gui/$(id -u)/${LAUNCHD_LABEL}`);
+  }
+
+  sleepSync(1500);
+  launchdPid = launchdIsRunning();
+  if (!launchdPid) {
+    launchdPid = readRunningDaemonPid({ pidFile, lockFile });
+  }
+  return launchdPid || null;
+}
+
 function requestDaemonRestart({
   reason = 'manual-restart',
   daemonPidFile = path.join(METAME_DIR, 'daemon.pid'),
@@ -374,20 +478,11 @@ function requestDaemonRestart({
 // Auto-deploy bundled scripts to ~/.metame/
 // IMPORTANT: daemon.yaml is USER CONFIG — never overwrite it. Only daemon-default.yaml (template) is synced.
 const scriptsDir = path.join(__dirname, 'scripts');
-// Auto-detect ALL runtime scripts: daemon-*.js + all other non-test, non-utility .js/.yaml/.sh files.
-// This prevents "missing module" crashes when new files are added without updating a manual list.
 const EXCLUDED_SCRIPTS = new Set(['sync-readme.js', 'test_daemon.js', 'daemon.yaml']);
-const BUNDLED_SCRIPTS = (() => {
-  try {
-    return fs.readdirSync(scriptsDir).filter((f) => {
-      if (EXCLUDED_SCRIPTS.has(f)) return false;
-      if (/\.test\.js$/.test(f)) return false;
-      return /\.(js|yaml|sh)$/.test(f);
-    });
-  } catch {
-    return [];
-  }
-})();
+const SCRIPT_DEPLOY_GROUPS = collectDeployGroups(fs, path, scriptsDir, {
+  excludedScripts: EXCLUDED_SCRIPTS,
+  includeNestedDirs: ['core'],
+});
 
 // Protect daemon.yaml: create backup before any sync operation
 const DAEMON_YAML_BACKUP = path.join(METAME_DIR, 'daemon.yaml.bak');
@@ -423,15 +518,14 @@ if (_isInWorktree) {
 // Catches bad merges and careless agent edits BEFORE they can crash the daemon.
 const { execSync: _execSync } = require('child_process');
 const syntaxErrors = [];
-for (const f of BUNDLED_SCRIPTS) {
-  if (!f.endsWith('.js')) continue;
-  const fp = path.join(scriptsDir, f);
+for (const fp of collectSyntaxCheckFiles(path, SCRIPT_DEPLOY_GROUPS)) {
   if (!fs.existsSync(fp)) continue;
   try {
     _execSync(`"${process.execPath}" -c "${fp}"`, { timeout: 5000, stdio: 'pipe', windowsHide: true });
   } catch (e) {
+    const label = path.relative(scriptsDir, fp);
     const msg = (e.stderr ? e.stderr.toString().trim() : e.message).split('\n')[0];
-    syntaxErrors.push(`${f}: ${msg}`);
+    syntaxErrors.push(`${label}: ${msg}`);
   }
 }
 
@@ -441,7 +535,11 @@ if (syntaxErrors.length > 0) {
   for (const err of syntaxErrors) console.error(`  ${err}`);
   console.error('Fix the errors before deploying. Daemon continues running with old code.');
 } else {
-  scriptsUpdated = syncDirFiles(scriptsDir, METAME_DIR, { fileList: BUNDLED_SCRIPTS });
+  scriptsUpdated = SCRIPT_DEPLOY_GROUPS.reduce((updated, group) => {
+    const destDir = group.destSubdir ? path.join(METAME_DIR, group.destSubdir) : METAME_DIR;
+    const changed = syncDirFiles(group.srcDir, destDir, { fileList: group.fileList });
+    return updated || changed;
+  }, false);
   if (scriptsUpdated) {
     console.log(`${icon("pkg")} Scripts synced to ~/.metame/.`);
   }
@@ -454,6 +552,21 @@ const binUpdated = syncDirFiles(path.join(__dirname, 'scripts', 'bin'), path.joi
 // Hooks: Claude Code event hooks (Stop, PostToolUse, etc.)
 const hooksUpdated = syncDirFiles(path.join(__dirname, 'scripts', 'hooks'), path.join(METAME_DIR, 'hooks'));
 
+// Migrate legacy reactive flat paths to per-project directory structure
+try {
+  const { migrate } = require('./scripts/migrate-reactive-paths');
+  const migrationReport = migrate(METAME_DIR);
+  if (migrationReport.migrated.length > 0) {
+    console.log(`${icon("pkg")} Migrated ${migrationReport.migrated.length} reactive file(s) to per-project dirs.`);
+  }
+  if (migrationReport.errors.length > 0) {
+    console.log(`${icon("warn")} Reactive migration had ${migrationReport.errors.length} error(s).`);
+  }
+} catch (e) {
+  // Non-critical: migration failure should not block deploy
+  console.log(`${icon("warn")} Reactive path migration skipped: ${e.message}`);
+}
+
 const daemonCodeUpdated = scriptsUpdated || binUpdated || hooksUpdated;
 const shouldAutoRestartAfterDeploy = (() => {
   const [cmd] = process.argv.slice(2);
@@ -2164,39 +2277,12 @@ WantedBy=default.target
     }
 
     if (process.platform === 'darwin') {
-      // macOS: delegate to launchd for auto-restart and boot persistence
-      // Kill any orphan daemon processes NOT managed by launchd
-      try {
-        const pids = findProcessesByPattern('node.*daemon\\.js');
-        const launchdPid = launchdIsRunning();
-        for (const n of pids) {
-          if (n !== launchdPid) {
-            try { process.kill(n, 'SIGTERM'); } catch { /* */ }
-          }
-        }
-      } catch { /* ignore */ }
-      // Clean stale lock/pid from orphan processes
-      if (fs.existsSync(DAEMON_LOCK)) {
-        try {
-          const lock = JSON.parse(fs.readFileSync(DAEMON_LOCK, 'utf8'));
-          const pid = parseInt(lock && lock.pid, 10);
-          if (pid) { process.kill(pid, 0); } // throws if dead
-        } catch {
-          // Owner is dead — clean stale files
-          try { fs.unlinkSync(DAEMON_PID); } catch { /* */ }
-          try { fs.unlinkSync(DAEMON_LOCK); } catch { /* */ }
-        }
-      }
-      ensureLaunchdPlist({ daemonScript: DAEMON_SCRIPT, daemonLog: DAEMON_LOG });
-      try {
-        execSync(`launchctl bootstrap gui/$(id -u) ${LAUNCHD_PLIST} 2>/dev/null`);
-      } catch { /* already bootstrapped */ }
-      // kickstart ensures the process is actually running now
-      try {
-        execSync(`launchctl kickstart gui/$(id -u)/${LAUNCHD_LABEL}`);
-      } catch { /* already running */ }
-      sleepSync(1500);
-      const pid = launchdIsRunning();
+      const pid = ensureLaunchdDaemonRunning({
+        daemonScript: DAEMON_SCRIPT,
+        daemonLog: DAEMON_LOG,
+        pidFile: DAEMON_PID,
+        lockFile: DAEMON_LOCK,
+      });
       if (pid) {
         console.log(`${icon("ok")} MetaMe daemon started via launchd (PID: ${pid})`);
       } else {
@@ -2241,17 +2327,7 @@ WantedBy=default.target
       try {
         execSync(`launchctl bootout gui/$(id -u)/${LAUNCHD_LABEL} 2>/dev/null`);
       } catch { /* not loaded */ }
-      // Also kill any orphan daemon processes not managed by launchd
-      try {
-        const pids = findProcessesByPattern('node.*daemon\\.js');
-        for (const n of pids) {
-          try { process.kill(n, 'SIGTERM'); } catch { /* */ }
-        }
-        if (pids.length) sleepSync(2000);
-        for (const n of pids) {
-          try { process.kill(n, 'SIGKILL'); } catch { /* already gone */ }
-        }
-      } catch { /* */ }
+      terminateDaemonProcesses({ pidFile: DAEMON_PID, lockFile: DAEMON_LOCK });
       try { fs.unlinkSync(DAEMON_PID); } catch { /* */ }
       try { fs.unlinkSync(DAEMON_LOCK); } catch { /* */ }
       console.log(`${icon("ok")} Daemon stopped. launchd auto-restart disabled.`);
@@ -2295,23 +2371,17 @@ WantedBy=default.target
     }
 
     if (process.platform === 'darwin') {
-      // macOS: use launchctl kickstart -k (kills + restarts in one atomic op)
-      ensureLaunchdPlist({ daemonScript: DAEMON_SCRIPT, daemonLog: DAEMON_LOG });
-      try {
-        execSync(`launchctl bootstrap gui/$(id -u) ${LAUNCHD_PLIST} 2>/dev/null`);
-      } catch { /* already bootstrapped */ }
-      try {
-        execSync(`launchctl kickstart -k gui/$(id -u)/${LAUNCHD_LABEL}`);
-        sleepSync(1500);
-        const pid = launchdIsRunning();
-        if (pid) {
-          console.log(`${icon("ok")} Daemon restarted via launchd (PID: ${pid})`);
-        } else {
-          console.log(`${icon("ok")} Daemon restart requested via launchd...`);
-        }
-      } catch (e) {
-        console.error(`${icon("fail")} launchctl kickstart failed: ${e.message}`);
-        process.exit(1);
+      const pid = ensureLaunchdDaemonRunning({
+        daemonScript: DAEMON_SCRIPT,
+        daemonLog: DAEMON_LOG,
+        pidFile: DAEMON_PID,
+        lockFile: DAEMON_LOCK,
+        restart: true,
+      });
+      if (pid) {
+        console.log(`${icon("ok")} Daemon restarted via launchd (PID: ${pid})`);
+      } else {
+        console.log(`${icon("ok")} Daemon restart requested via launchd...`);
       }
       process.exit(0);
     }
@@ -2369,6 +2439,13 @@ WantedBy=default.target
         }
       } catch { /* lock stale or invalid */ }
     }
+    if (!isRunning && process.platform === 'darwin' && fs.existsSync(LAUNCHD_PLIST)) {
+      const pid = launchdIsRunning();
+      if (pid) {
+        isRunning = true;
+        runningPid = pid;
+      }
+    }
 
     console.log(`${icon("bot")} MetaMe Daemon: ${isRunning ? icon("green") + ' Running' : icon("red") + ' Stopped'}`);
     if (state.started_at) console.log(`   Started: ${state.started_at}`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.5.19",
+    "version": "1.5.20",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -21,7 +21,7 @@
         "test:daemon-status": "node --test scripts/daemon-restart-status.test.js",
         "start": "node index.js",
         "push": "bash scripts/bin/push-clean.sh",
-        "sync:plugin": "node -e \"const fs=require('fs'),path=require('path');const ex=new Set(['sync-readme.js','test_daemon.js','daemon.yaml']);const files=fs.readdirSync('scripts').filter(f=>!ex.has(f)&&!/\\.test\\.js$/.test(f)&&/\\.(js|yaml|sh)$/.test(f));files.forEach(f=>fs.copyFileSync('scripts/'+f,'plugin/scripts/'+f));\" && mkdir -p plugin/scripts/hooks && cp scripts/hooks/*.js plugin/scripts/hooks/ && echo 'Plugin scripts synced'",
+        "sync:plugin": "node scripts/sync-plugin.js",
         "sync:readme": "node scripts/sync-readme.js",
         "restart:daemon": "node index.js stop 2>/dev/null; sleep 1; node index.js start 2>/dev/null || echo '鈿狅笍  Daemon not running or restart failed'",
         "prepublishOnly": "node -e \"const fs=require('fs');['scripts/daemon.yaml','plugin/scripts/daemon.yaml'].forEach(f=>{if(fs.existsSync(f)){const c=fs.readFileSync(f,'utf8');if(/bot_token:\\s*[^n]|app_secret:\\s*[^n]|enabled:\\s*true/.test(c)){console.error('ABORT: Real credentials found in '+f);process.exit(1)}}})\"",

package/scripts/bin/bootstrap-worktree.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+cd "$ROOT"
+
+if ! command -v node >/dev/null 2>&1; then
+  echo "Node.js is required" >&2
+  exit 1
+fi
+
+if [[ -f package-lock.json ]]; then
+  echo "Using npm ci in $(pwd)"
+  npm ci --no-audit --no-fund
+else
+  echo "package-lock.json missing, using npm install in $(pwd)"
+  npm install --no-audit --no-fund
+fi
+
+node -e "require('js-yaml'); require('./scripts/resolve-yaml'); console.log('bootstrap-ok')"

package/scripts/core/audit.js

@@ -0,0 +1,190 @@
+'use strict';
+
+function createAudit(deps) {
+  const {
+    fs,
+    logFile,
+    stateFile,
+    stdout = process.stdout,
+    stderr = process.stderr,
+    usageRetentionDaysDefault = 30,
+  } = deps;
+
+  let logMaxSize = 1048576;
+  let cachedState = null;
+
+  function ensureUsageShape(state) {
+    if (!state.usage || typeof state.usage !== 'object') state.usage = {};
+    if (!state.usage.categories || typeof state.usage.categories !== 'object') state.usage.categories = {};
+    if (!state.usage.daily || typeof state.usage.daily !== 'object') state.usage.daily = {};
+    const keepDays = Number(state.usage.retention_days);
+    state.usage.retention_days = Number.isFinite(keepDays) && keepDays >= 7
+      ? Math.floor(keepDays)
+      : usageRetentionDaysDefault;
+  }
+
+  function ensureStateShape(state) {
+    if (!state || typeof state !== 'object') return {
+      pid: null,
+      budget: { date: null, tokens_used: 0 },
+      tasks: {},
+      sessions: {},
+      started_at: null,
+      usage: { retention_days: usageRetentionDaysDefault, categories: {}, daily: {} },
+    };
+    if (!state.budget || typeof state.budget !== 'object') state.budget = { date: null, tokens_used: 0 };
+    if (typeof state.budget.tokens_used !== 'number') state.budget.tokens_used = Number(state.budget.tokens_used) || 0;
+    if (!Object.prototype.hasOwnProperty.call(state.budget, 'date')) state.budget.date = null;
+    if (!state.tasks || typeof state.tasks !== 'object') state.tasks = {};
+    if (!state.sessions || typeof state.sessions !== 'object') state.sessions = {};
+    ensureUsageShape(state);
+    return state;
+  }
+
+  function pruneDailyUsage(usage, todayIso) {
+    const keepDays = usage.retention_days || usageRetentionDaysDefault;
+    const cutoff = new Date(`${todayIso}T00:00:00.000Z`);
+    cutoff.setUTCDate(cutoff.getUTCDate() - (keepDays - 1));
+    const cutoffIso = cutoff.toISOString().slice(0, 10);
+    for (const day of Object.keys(usage.daily || {})) {
+      if (day < cutoffIso) delete usage.daily[day];
+    }
+  }
+
+  function readStateFromDisk() {
+    try {
+      const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+      return ensureStateShape(state);
+    } catch {
+      return ensureStateShape({
+        pid: null,
+        budget: { date: null, tokens_used: 0 },
+        tasks: {},
+        sessions: {},
+        started_at: null,
+      });
+    }
+  }
+
+  function refreshLogMaxSize(cfg) {
+    logMaxSize = (cfg && cfg.daemon && cfg.daemon.log_max_size) || 1048576;
+  }
+
+  function log(level, msg) {
+    const ts = new Date().toISOString();
+    const line = `[${ts}] [${level}] ${msg}\n`;
+    try {
+      if (fs.existsSync(logFile)) {
+        const stat = fs.statSync(logFile);
+        if (stat.size > logMaxSize) {
+          const bakFile = logFile + '.bak';
+          if (fs.existsSync(bakFile)) fs.unlinkSync(bakFile);
+          fs.renameSync(logFile, bakFile);
+        }
+      }
+      fs.appendFileSync(logFile, line, 'utf8');
+    } catch {
+      stderr.write(line);
+    }
+    if (stdout && !stdout.isTTY && typeof stdout.write === 'function') {
+      stdout.write(line);
+    }
+  }
+
+  function loadState() {
+    if (!cachedState) cachedState = readStateFromDisk();
+    return cachedState;
+  }
+
+  function saveState(state) {
+    const next = ensureStateShape(state);
+    if (cachedState && cachedState !== next) {
+      const current = ensureStateShape(cachedState);
+
+      const currentBudgetDate = String(current.budget.date || '');
+      const nextBudgetDate = String(next.budget.date || '');
+      const currentBudgetTokens = Math.max(0, Math.floor(Number(current.budget.tokens_used) || 0));
+      const nextBudgetTokens = Math.max(0, Math.floor(Number(next.budget.tokens_used) || 0));
+      if (currentBudgetDate && (!nextBudgetDate || currentBudgetDate > nextBudgetDate)) {
+        next.budget.date = currentBudgetDate;
+        next.budget.tokens_used = currentBudgetTokens;
+      } else if (currentBudgetDate && currentBudgetDate === nextBudgetDate) {
+        next.budget.tokens_used = Math.max(currentBudgetTokens, nextBudgetTokens);
+      }
+
+      const currentKeepDays = Number(current.usage.retention_days) || usageRetentionDaysDefault;
+      const nextKeepDays = Number(next.usage.retention_days) || usageRetentionDaysDefault;
+      next.usage.retention_days = Math.max(currentKeepDays, nextKeepDays);
+
+      for (const [category, curMeta] of Object.entries(current.usage.categories || {})) {
+        if (!next.usage.categories[category] || typeof next.usage.categories[category] !== 'object') {
+          next.usage.categories[category] = {};
+        }
+        const curTotal = Math.max(0, Math.floor(Number(curMeta && curMeta.total) || 0));
+        const nextTotal = Math.max(0, Math.floor(Number(next.usage.categories[category].total) || 0));
+        if (curTotal > nextTotal) next.usage.categories[category].total = curTotal;
+
+        const curUpdated = String(curMeta && curMeta.updated_at || '');
+        const nextUpdated = String(next.usage.categories[category].updated_at || '');
+        if (curUpdated && curUpdated > nextUpdated) next.usage.categories[category].updated_at = curUpdated;
+      }
+
+      for (const [day, curDayUsageRaw] of Object.entries(current.usage.daily || {})) {
+        const curDayUsage = (curDayUsageRaw && typeof curDayUsageRaw === 'object') ? curDayUsageRaw : {};
+        if (!next.usage.daily[day] || typeof next.usage.daily[day] !== 'object') {
+          next.usage.daily[day] = {};
+        }
+        const nextDayUsage = next.usage.daily[day];
+        for (const [key, curValue] of Object.entries(curDayUsage)) {
+          const curNum = Math.max(0, Math.floor(Number(curValue) || 0));
+          const nextNum = Math.max(0, Math.floor(Number(nextDayUsage[key]) || 0));
+          if (curNum > nextNum) nextDayUsage[key] = curNum;
+        }
+        const categorySum = Object.entries(nextDayUsage)
+          .filter(([key]) => key !== 'total')
+          .reduce((sum, [, value]) => sum + Math.max(0, Math.floor(Number(value) || 0)), 0);
+        nextDayUsage.total = Math.max(Math.max(0, Math.floor(Number(nextDayUsage.total) || 0)), categorySum);
+      }
+
+      const currentUsageUpdated = String(current.usage.updated_at || '');
+      const nextUsageUpdated = String(next.usage.updated_at || '');
+      if (currentUsageUpdated && currentUsageUpdated > nextUsageUpdated) {
+        next.usage.updated_at = currentUsageUpdated;
+      }
+
+      if (current.sessions && typeof current.sessions === 'object') {
+        if (!next.sessions || typeof next.sessions !== 'object') next.sessions = {};
+        for (const [key, curSession] of Object.entries(current.sessions)) {
+          if (!next.sessions[key]) {
+            next.sessions[key] = curSession;
+          } else {
+            const curActive = Number(curSession && curSession.last_active) || 0;
+            const nextActive = Number(next.sessions[key] && next.sessions[key].last_active) || 0;
+            if (curActive > nextActive) next.sessions[key] = curSession;
+          }
+        }
+      }
+    }
+
+    cachedState = next;
+    try {
+      fs.writeFileSync(stateFile, JSON.stringify(next, null, 2), 'utf8');
+    } catch (e) {
+      log('ERROR', `Failed to save state: ${e.message}`);
+    }
+  }
+
+  return {
+    refreshLogMaxSize,
+    log,
+    loadState,
+    saveState,
+    ensureUsageShape,
+    ensureStateShape,
+    pruneDailyUsage,
+  };
+}
+
+module.exports = {
+  createAudit,
+};