@camaradesuk/git-worktree-tools 1.9.0 → 1.11.0

package/dist/lib/logger.js

@@ -1,475 +1,404 @@
 /**
  * Logging system for git-worktree-tools
  *
- * Provides a singleton logger with:
- * - Multiple log levels (silent, error, warn, info, debug, trace)
- * - Console and file output support
- * - Log file rotation
- * - Timestamps and context
- * - Color support for console output
+ * Consola-based singleton logger with:
+ * - AuditFileReporter: persistent audit log with size-based rotation
+ * - ConditionalStderrReporter: verbose/quiet aware stderr output
+ * - Audit session tracking (command, cwd, branch, exit code, duration)
+ * - DEBUG=newpr deprecation handling
  *
  * Configuration sources (in order of priority):
- * 1. CLI flags (--verbose, --debug, --log-file)
- * 2. Environment variables (GWT_LOG_LEVEL, GWT_LOG_FILE)
- * 3. Config files (logLevel, logFile properties)
+ * 1. CLI flags (--verbose, --quiet, --no-color)
+ * 2. Environment variables (GWT_LOG_LEVEL, DEBUG)
+ * 3. Default (INFO)
  */
 import fs from 'fs';
 import path from 'path';
-import { LogLevel, DEFAULT_LOG_LEVEL, MAX_LOG_FILE_SIZE, MAX_LOG_FILES, getGlobalLogDir, } from './constants.js';
-import { red, yellow, cyan, gray, bold } from './colors.js';
+import { execSync } from 'child_process';
+import { createConsola } from 'consola';
+import { LogLevel, MAX_LOG_FILE_SIZE, MAX_LOG_FILES, getGlobalDataDir } from './constants.js';
+import { setColorEnabled } from './colors.js';
 export { LogLevel };
+// ---------------------------------------------------------------------------
+// Module-level state
+// ---------------------------------------------------------------------------
+/** Whether the DEBUG=newpr deprecation warning has been printed */
+let deprecationWarned = false;
+/** Whether JSON output mode is active */
+let jsonMode = false;
+/** Audit session context for the process exit handler */
+let auditContext = {};
+/** Track whether exit handler has been registered */
+let exitHandlerRegistered = false;
+/** Track whether audit file warning has been issued */
+let auditFileWarned = false;
+/** Reference to the AuditFileReporter for exit-time sync write */
+let activeAuditReporter = null;
+// ---------------------------------------------------------------------------
+// AuditFileReporter
+// ---------------------------------------------------------------------------
 /**
- * Parse log level from string
+ * Writes log entries to a persistent audit file with size-based rotation.
+ * Human-readable text lines by default; JSONL when json mode is active.
  */
-export function parseLogLevel(value) {
-    const normalized = value.toLowerCase().trim();
-    const mapping = {
-        silent: LogLevel.SILENT,
-        error: LogLevel.ERROR,
-        warn: LogLevel.WARN,
-        warning: LogLevel.WARN,
-        info: LogLevel.INFO,
-        debug: LogLevel.DEBUG,
-        trace: LogLevel.TRACE,
-        verbose: LogLevel.DEBUG,
-        '0': LogLevel.SILENT,
-        '1': LogLevel.ERROR,
-        '2': LogLevel.WARN,
-        '3': LogLevel.INFO,
-        '4': LogLevel.DEBUG,
-        '5': LogLevel.TRACE,
-    };
-    return mapping[normalized];
-}
-/**
- * Get log level name
- */
-function getLevelName(level) {
-    const names = {
-        [LogLevel.SILENT]: 'SILENT',
-        [LogLevel.ERROR]: 'ERROR',
-        [LogLevel.WARN]: 'WARN',
-        [LogLevel.INFO]: 'INFO',
-        [LogLevel.DEBUG]: 'DEBUG',
-        [LogLevel.TRACE]: 'TRACE',
-    };
-    return names[level] || 'UNKNOWN';
-}
-/**
- * Format a log message for console output with colors
- */
-function formatConsoleMessage(level, message, timestamp, useColors) {
-    const parts = [];
-    if (timestamp) {
-        parts.push(useColors ? gray(`[${timestamp}]`) : `[${timestamp}]`);
-    }
-    const levelStr = getLevelName(level).padEnd(5);
-    let formattedLevel;
-    let formattedMessage;
-    if (useColors) {
-        switch (level) {
-            case LogLevel.ERROR:
-                formattedLevel = red(bold(levelStr));
-                formattedMessage = red(message);
-                break;
-            case LogLevel.WARN:
-                formattedLevel = yellow(bold(levelStr));
-                formattedMessage = yellow(message);
-                break;
-            case LogLevel.DEBUG:
-            case LogLevel.TRACE:
-                formattedLevel = gray(levelStr);
-                formattedMessage = gray(message);
-                break;
-            default:
-                formattedLevel = cyan(levelStr);
-                formattedMessage = message;
-        }
-    }
-    else {
-        formattedLevel = levelStr;
-        formattedMessage = message;
-    }
-    parts.push(formattedLevel);
-    parts.push(formattedMessage);
-    return parts.join(' ');
-}
-/**
- * Singleton Logger class
- */
-class Logger {
-    static instance = null;
-    level = DEFAULT_LOG_LEVEL;
-    logFile = null;
-    fileStream = null;
-    timestamps = true;
-    colors = true;
-    consoleOutput = true;
-    context = null;
-    initialized = false;
-    constructor() {
-        // Private constructor for singleton
-    }
-    /**
-     * Get the singleton logger instance
-     */
-    static getInstance() {
-        if (!Logger.instance) {
-            Logger.instance = new Logger();
-        }
-        return Logger.instance;
-    }
-    /**
-     * Initialize the logger with configuration
-     * Should be called early in CLI startup
-     */
-    initialize(config = {}) {
-        // Determine log level from multiple sources (priority order)
-        // 1. Explicit config (from CLI flags)
-        // 2. Environment variable
-        // 3. Default
-        if (config.level !== undefined) {
-            this.level = config.level;
-        }
-        else {
-            const envLevel = process.env.GWT_LOG_LEVEL;
-            if (envLevel) {
-                const parsed = parseLogLevel(envLevel);
-                if (parsed !== undefined) {
-                    this.level = parsed;
-                }
-            }
-        }
-        // Determine log file from multiple sources
-        if (config.logFile !== undefined) {
-            this.logFile = config.logFile;
-        }
-        else {
-            const envLogFile = process.env.GWT_LOG_FILE;
-            if (envLogFile) {
-                this.logFile = envLogFile;
-            }
-        }
-        if (config.timestamps !== undefined) {
-            this.timestamps = config.timestamps;
-        }
-        if (config.colors !== undefined) {
-            this.colors = config.colors;
-        }
-        if (config.consoleOutput !== undefined) {
-            this.consoleOutput = config.consoleOutput;
-        }
-        // Set up file logging if configured
-        if (this.logFile) {
-            this.setupFileLogging(this.logFile);
-        }
-        this.initialized = true;
-    }
-    /**
-     * Set up file logging with rotation
-     */
-    setupFileLogging(filePath) {
+class AuditFileReporter {
+    stream = null;
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
         try {
-            // Ensure directory exists
             const dir = path.dirname(filePath);
             fs.mkdirSync(dir, { recursive: true });
-            // Check if rotation is needed
-            if (fs.existsSync(filePath)) {
-                const stats = fs.statSync(filePath);
-                if (stats.size > MAX_LOG_FILE_SIZE) {
-                    this.rotateLogFiles(filePath);
+            rotateIfNeeded(filePath);
+            this.stream = fs.createWriteStream(filePath, { flags: 'a' });
+            this.stream.on('error', (err) => {
+                if (!auditFileWarned) {
+                    auditFileWarned = true;
+                    process.stderr.write(`[gwt] Audit log write error: ${err.message}\n`);
                 }
-            }
-            // Open file stream in append mode
-            this.fileStream = fs.createWriteStream(filePath, { flags: 'a' });
-            this.fileStream.on('error', (err) => {
-                console.error(`Logger: Failed to write to log file: ${err.message}`);
-                this.fileStream = null;
+                this.stream = null;
             });
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`Logger: Failed to set up file logging: ${message}`);
-        }
-    }
-    /**
-     * Rotate log files
-     */
-    rotateLogFiles(filePath) {
-        try {
-            // Shift existing rotated files
-            for (let i = MAX_LOG_FILES - 1; i >= 1; i--) {
-                const older = `${filePath}.${i}`;
-                const newer = i === 1 ? filePath : `${filePath}.${i - 1}`;
-                if (fs.existsSync(newer)) {
-                    if (i === MAX_LOG_FILES - 1 && fs.existsSync(older)) {
-                        fs.unlinkSync(older);
-                    }
-                    fs.renameSync(newer, older);
-                }
+            if (!auditFileWarned) {
+                auditFileWarned = true;
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stderr.write(`[gwt] Failed to open audit log: ${msg}\n`);
             }
         }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`Logger: Failed to rotate log files: ${message}`);
-        }
-    }
-    /**
-     * Set the current context (e.g., command name)
-     */
-    setContext(context) {
-        this.context = context;
     }
-    /**
-     * Set the log level
-     */
-    setLevel(level) {
-        this.level = level;
-    }
-    /**
-     * Get the current log level
-     */
-    getLevel() {
-        return this.level;
-    }
-    /**
-     * Check if a log level is enabled
-     */
-    isLevelEnabled(level) {
-        return level <= this.level;
-    }
-    /**
-     * Check if the logger is in debug mode
-     */
-    isDebug() {
-        return this.level >= LogLevel.DEBUG;
-    }
-    /**
-     * Check if the logger is in trace mode
-     */
-    isTrace() {
-        return this.level >= LogLevel.TRACE;
-    }
-    /**
-     * Internal log method
-     */
-    log(level, message, ...args) {
-        this.logWithContext(level, this.context, message, ...args);
-    }
-    /**
-     * Internal log method with explicit context (thread-safe for child loggers)
-     */
-    logWithContext(level, context, message, ...args) {
-        if (level > this.level) {
+    log(logObj) {
+        if (!this.stream)
             return;
-        }
-        const timestamp = this.timestamps ? new Date().toISOString() : null;
-        const formattedMessage = args.length > 0 ? this.formatMessage(message, args) : message;
-        // Console output
-        if (this.consoleOutput || !this.fileStream) {
-            const consoleMsg = formatConsoleMessage(level, formattedMessage, timestamp, this.colors && process.stdout.isTTY === true);
-            if (level === LogLevel.ERROR) {
-                console.error(consoleMsg);
-            }
-            else if (level === LogLevel.WARN) {
-                console.warn(consoleMsg);
+        try {
+            const timestamp = new Date().toISOString();
+            const levelName = levelToName(logObj.level);
+            const tag = logObj.tag ? ` [${logObj.tag}]` : '';
+            const message = formatLogArgs(logObj.args);
+            if (jsonMode) {
+                const entry = {
+                    timestamp,
+                    level: levelName,
+                    ...(logObj.tag ? { tag: logObj.tag } : {}),
+                    message,
+                };
+                this.stream.write(JSON.stringify(entry) + '\n');
             }
             else {
-                console.log(consoleMsg);
+                this.stream.write(`[${timestamp}] ${levelName}${tag} ${message}\n`);
             }
         }
-        // File output
-        if (this.fileStream) {
-            const entry = {
-                timestamp: timestamp || new Date().toISOString(),
-                level: getLevelName(level),
-                message: formattedMessage,
-            };
-            if (context) {
-                entry.context = context;
-            }
-            if (args.length > 0 && typeof args[0] === 'object') {
-                entry.data = args[0];
-            }
-            this.fileStream.write(JSON.stringify(entry) + '\n');
+        catch {
+            // Swallow write errors silently after first warning
         }
     }
-    /**
-     * Format message with arguments (simple substitution)
-     */
-    formatMessage(message, args) {
-        let result = message;
-        for (const arg of args) {
-            const replacement = typeof arg === 'object' ? JSON.stringify(arg) : String(arg);
-            result = result.replace('%s', replacement);
-            result = result.replace('%d', replacement);
-            result = result.replace('%j', typeof arg === 'object' ? JSON.stringify(arg) : replacement);
-            result = result.replace('%o', typeof arg === 'object' ? JSON.stringify(arg) : replacement);
-        }
-        // Append remaining args if placeholders exhausted
-        const placeholders = (message.match(/%[sdjo]/g) || []).length;
-        if (args.length > placeholders) {
-            const extra = args
-                .slice(placeholders)
-                .map((a) => (typeof a === 'object' ? JSON.stringify(a) : String(a)));
-            result += ' ' + extra.join(' ');
-        }
-        return result;
-    }
-    /**
-     * Log an error message
-     */
-    error(message, ...args) {
-        this.log(LogLevel.ERROR, message, ...args);
-    }
-    /**
-     * Log a warning message
-     */
-    warn(message, ...args) {
-        this.log(LogLevel.WARN, message, ...args);
-    }
-    /**
-     * Log an info message
-     */
-    info(message, ...args) {
-        this.log(LogLevel.INFO, message, ...args);
-    }
-    /**
-     * Log a debug message
-     */
-    debug(message, ...args) {
-        this.log(LogLevel.DEBUG, message, ...args);
-    }
-    /**
-     * Log a trace message
-     */
-    trace(message, ...args) {
-        this.log(LogLevel.TRACE, message, ...args);
-    }
-    /**
-     * Log an error with stack trace
-     */
-    errorWithStack(err, message) {
-        const msg = message ? `${message}: ${err.message}` : err.message;
-        this.error(msg);
-        if (this.level >= LogLevel.DEBUG && err.stack) {
-            this.debug(err.stack);
-        }
-    }
-    /**
-     * Create a child logger with a specific context
-     */
-    child(context) {
-        return new ChildLogger(this, context);
-    }
-    /**
-     * Close the logger (flush file stream)
-     */
     close() {
-        return new Promise((resolve) => {
-            if (this.fileStream) {
-                this.fileStream.end(() => {
-                    this.fileStream = null;
-                    resolve();
-                });
-            }
-            else {
-                resolve();
+        if (this.stream) {
+            const stream = this.stream;
+            this.stream = null;
+            // Close the fd synchronously so callers can immediately delete the file.
+            // On Windows, stream.end()/destroy() close the fd asynchronously, leaving
+            // the file locked until the next tick.
+            const streamInternal = stream;
+            const fd = streamInternal.fd;
+            if (typeof fd === 'number') {
+                // Null out the fd BEFORE closing so destroy() won't try to close it
+                // again (which would risk closing a reused fd number).
+                streamInternal.fd = null;
+                try {
+                    fs.closeSync(fd);
+                }
+                catch {
+                    /* best effort */
+                }
             }
-        });
-    }
-    /**
-     * Get the default log file path
-     */
-    static getDefaultLogFilePath() {
-        return path.join(getGlobalLogDir(), 'wt.log');
-    }
-    /**
-     * Reset the singleton instance (for testing)
-     */
-    static reset() {
-        if (Logger.instance) {
-            Logger.instance.close();
-            Logger.instance = null;
+            stream.removeAllListeners('error');
+            stream.on('error', () => { });
+            stream.destroy();
         }
     }
 }
+// ---------------------------------------------------------------------------
+// ConditionalStderrReporter
+// ---------------------------------------------------------------------------
 /**
- * Child logger with a specific context
- * Uses logWithContext to avoid race conditions with concurrent logging
+ * Writes to stderr based on log level and verbose mode.
+ * WARN and ERROR always print; DEBUG/INFO/TRACE only print when verbose=true.
  */
-class ChildLogger {
-    parent;
-    context;
-    constructor(parent, context) {
-        this.parent = parent;
-        this.context = context;
+class ConditionalStderrReporter {
+    verbose;
+    useColors;
+    constructor(verbose, useColors) {
+        this.verbose = verbose;
+        this.useColors = useColors;
+    }
+    log(logObj) {
+        // Level < 2 means warn (1) or error/fatal (0) — always print
+        // Level >= 2 means info (3), debug (4), trace (5) — only if verbose
+        if (logObj.level >= 2 && !this.verbose) {
+            return;
+        }
+        const levelName = levelToName(logObj.level);
+        const tag = logObj.tag ? ` [${logObj.tag}]` : '';
+        const message = formatLogArgs(logObj.args);
+        let prefix;
+        if (this.useColors) {
+            prefix = colorizeLevel(levelName, logObj.level);
+        }
+        else {
+            prefix = `[${levelName}]`;
+        }
+        process.stderr.write(`${prefix}${tag} ${message}\n`);
     }
-    error(message, ...args) {
-        this.parent.logWithContext(LogLevel.ERROR, this.context, message, ...args);
+}
+// ---------------------------------------------------------------------------
+// Rotation logic
+// ---------------------------------------------------------------------------
+function rotateIfNeeded(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return;
+        const stats = fs.statSync(filePath);
+        if (stats.size <= MAX_LOG_FILE_SIZE)
+            return;
+        // Shift: audit.log.2 deleted, audit.log.1 -> .2, audit.log -> .1
+        for (let i = MAX_LOG_FILES - 1; i >= 1; i--) {
+            const older = `${filePath}.${i}`;
+            const newer = i === 1 ? filePath : `${filePath}.${i - 1}`;
+            if (fs.existsSync(newer)) {
+                if (i === MAX_LOG_FILES - 1 && fs.existsSync(older)) {
+                    fs.unlinkSync(older);
+                }
+                fs.renameSync(newer, older);
+            }
+        }
     }
-    warn(message, ...args) {
-        this.parent.logWithContext(LogLevel.WARN, this.context, message, ...args);
+    catch {
+        // Best-effort rotation — do not crash
     }
-    info(message, ...args) {
-        this.parent.logWithContext(LogLevel.INFO, this.context, message, ...args);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function levelToName(level) {
+    if (level <= 0) {
+        // 0 = error/fatal, negative = silent (shouldn't log)
+        return level === 0 ? 'ERROR' : 'SILENT';
+    }
+    switch (level) {
+        case 1:
+            return 'WARN';
+        case 2:
+            return 'LOG';
+        case 3:
+            return 'INFO';
+        case 4:
+            return 'DEBUG';
+        case 5:
+            return 'TRACE';
+        default:
+            return level > 5 ? 'TRACE' : 'ERROR';
     }
-    debug(message, ...args) {
-        this.parent.logWithContext(LogLevel.DEBUG, this.context, message, ...args);
+}
+function colorizeLevel(name, level) {
+    // ANSI color codes
+    const RED = '\x1b[31m';
+    const YELLOW = '\x1b[33m';
+    const CYAN = '\x1b[36m';
+    const GRAY = '\x1b[90m';
+    const RESET = '\x1b[0m';
+    switch (true) {
+        case level <= 0:
+            return `${RED}[${name}]${RESET}`;
+        case level === 1:
+            return `${YELLOW}[${name}]${RESET}`;
+        case level <= 3:
+            return `${CYAN}[${name}]${RESET}`;
+        default:
+            return `${GRAY}[${name}]${RESET}`;
     }
-    trace(message, ...args) {
-        this.parent.logWithContext(LogLevel.TRACE, this.context, message, ...args);
+}
+function formatLogArgs(args) {
+    return args
+        .map((a) => (typeof a === 'object' && a !== null ? JSON.stringify(a) : String(a)))
+        .join(' ');
+}
+function getCurrentGitBranch() {
+    try {
+        return execSync('git rev-parse --abbrev-ref HEAD', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return 'unknown';
     }
 }
+// ---------------------------------------------------------------------------
+// Logger singleton
+// ---------------------------------------------------------------------------
 /**
- * The singleton logger instance
+ * The singleton consola logger instance.
+ * Starts with empty reporters — call initializeLogger() to configure.
  */
-export const logger = Logger.getInstance();
+export const logger = createConsola({
+    level: 3, // INFO default
+    reporters: [],
+});
 /**
- * Initialize the logger from CLI arguments and config
- * Call this early in CLI entry points
+ * Configure the logger with CLI flags, env vars, and reporters.
+ * Must be called early in CLI startup. Safe to call multiple times
+ * (replaces reporters each time).
  */
-export function initializeLogger(options) {
+export function initializeLogger(options = {}) {
+    // ----------------------------------------------------------
+    // 1. Resolve level: CLI flag > env var > default
+    // ----------------------------------------------------------
     let level;
-    // Priority: CLI flags > env vars > config
     if (options.quiet) {
-        level = LogLevel.SILENT;
+        level = 0; // error only
     }
-    else if (options.debug) {
-        level = LogLevel.DEBUG;
-    }
-    else if (options.verbose !== undefined) {
-        if (typeof options.verbose === 'number') {
-            // -v = DEBUG, -vv = TRACE
-            level = options.verbose >= 2 ? LogLevel.TRACE : LogLevel.DEBUG;
-        }
-        else if (options.verbose) {
-            level = LogLevel.DEBUG;
-        }
+    else if (options.verbose) {
+        level = 4; // debug
     }
     else if (process.env.GWT_LOG_LEVEL) {
-        level = parseLogLevel(process.env.GWT_LOG_LEVEL);
-    }
-    else if (options.configLogLevel) {
-        level =
-            typeof options.configLogLevel === 'string'
-                ? parseLogLevel(options.configLogLevel)
-                : options.configLogLevel;
-    }
-    // Log file priority: CLI flag > env var > config
-    let logFile;
-    if (options.logFile) {
-        logFile = options.logFile;
-    }
-    else if (process.env.GWT_LOG_FILE) {
-        logFile = process.env.GWT_LOG_FILE;
+        const parsed = parseLogLevel(process.env.GWT_LOG_LEVEL);
+        level = parsed !== undefined ? parsed : 3;
+    }
+    else if (process.env.DEBUG === 'newpr' ||
+        process.env.DEBUG === '*' ||
+        process.env.DEBUG === '1') {
+        level = 4; // debug
+        if (!deprecationWarned) {
+            deprecationWarned = true;
+            process.stderr.write('WARNING: DEBUG=newpr is deprecated, use GWT_LOG_LEVEL=debug\n');
+        }
     }
-    else if (options.configLogFile) {
-        logFile = options.configLogFile;
+    else {
+        level = 3; // info (default)
+    }
+    logger.level = level;
+    // ----------------------------------------------------------
+    // 2. Handle color
+    // ----------------------------------------------------------
+    const useColors = !options.noColor && process.env.NO_COLOR === undefined;
+    if (options.noColor) {
+        setColorEnabled(false);
+    }
+    // ----------------------------------------------------------
+    // 3. JSON mode
+    // ----------------------------------------------------------
+    jsonMode = options.json ?? false;
+    // ----------------------------------------------------------
+    // 4. Build reporters
+    // ----------------------------------------------------------
+    const reporters = [];
+    // Audit file reporter (always on)
+    try {
+        const auditPath = path.join(getGlobalDataDir(), 'audit.log');
+        const auditReporter = new AuditFileReporter(auditPath);
+        reporters.push(auditReporter);
+        activeAuditReporter = auditReporter;
+    }
+    catch {
+        // Best effort — continue without audit file
+    }
+    // Stderr reporter
+    const verbose = options.verbose ?? false;
+    reporters.push(new ConditionalStderrReporter(verbose, useColors));
+    logger.setReporters(reporters);
+    // ----------------------------------------------------------
+    // 5. Audit session tracking
+    // ----------------------------------------------------------
+    if (options.commandName) {
+        auditContext.command = options.commandName;
+        auditContext.startTime = Date.now();
+        auditContext.cwd = process.cwd();
+        auditContext.gitBranch = getCurrentGitBranch();
+    }
+    if (!exitHandlerRegistered) {
+        exitHandlerRegistered = true;
+        process.on('exit', (code) => {
+            if (!auditContext.command || !activeAuditReporter)
+                return;
+            const duration = auditContext.startTime ? Date.now() - auditContext.startTime : 0;
+            const entry = {
+                type: 'session',
+                timestamp: new Date().toISOString(),
+                command: auditContext.command,
+                cwd: auditContext.cwd,
+                gitBranch: auditContext.gitBranch,
+                exitCode: code,
+                durationMs: duration,
+            };
+            if (auditContext.worktreePath)
+                entry.worktreePath = auditContext.worktreePath;
+            if (auditContext.prNumber !== undefined)
+                entry.prNumber = auditContext.prNumber;
+            // Must be synchronous — Node.js does not process async after 'exit'
+            try {
+                const logPath = activeAuditReporter.filePath;
+                const line = jsonMode
+                    ? JSON.stringify(entry)
+                    : `[${entry.timestamp}] SESSION command=${entry.command} cwd=${entry.cwd} branch=${entry.gitBranch} exit=${code} duration=${duration}ms`;
+                fs.appendFileSync(logPath, line + '\n');
+            }
+            catch {
+                // Cannot do anything on exit — swallow
+            }
+        });
     }
-    logger.initialize({
-        level,
-        logFile,
-    });
+}
+// ---------------------------------------------------------------------------
+// setAuditContext
+// ---------------------------------------------------------------------------
+/**
+ * Merge additional metadata into the audit context.
+ * Called from CLI handlers to add worktreePath, prNumber, etc.
+ */
+export function setAuditContext(ctx) {
+    Object.assign(auditContext, ctx);
+}
+// ---------------------------------------------------------------------------
+// parseLogLevel
+// ---------------------------------------------------------------------------
+/**
+ * Parse a string log level name to its numeric consola equivalent.
+ * Returns undefined for unrecognized values.
+ */
+export function parseLogLevel(value) {
+    const normalized = value.toLowerCase().trim();
+    const mapping = {
+        silent: -999,
+        error: 0,
+        warn: 1,
+        warning: 1,
+        info: 3,
+        debug: 4,
+        trace: 5,
+        verbose: 4,
+    };
+    return mapping[normalized];
+}
+// ---------------------------------------------------------------------------
+// _resetForTesting
+// ---------------------------------------------------------------------------
+/**
+ * Reset all module-level state for test isolation.
+ * Prefixed with _ to signal internal-only use.
+ */
+export function _resetForTesting() {
+    deprecationWarned = false;
+    jsonMode = false;
+    auditContext = {};
+    auditFileWarned = false;
+    if (activeAuditReporter) {
+        activeAuditReporter.close();
+    }
+    activeAuditReporter = null;
+    // Note: we don't reset exitHandlerRegistered because process.on('exit') handlers
+    // cannot be removed cleanly and we only register once per process.
+    logger.setReporters([]);
+    logger.level = 3; // INFO default
 }
 //# sourceMappingURL=logger.js.map