@grunnverk/core 1.0.0

package/dist/index.js

@@ -0,0 +1,3227 @@
+import { ExitError, createStorage, incrementPatchVersion, validateVersionString, convertToReleaseVersion, incrementPrereleaseVersion, UserCancellationError, CommandError } from '@grunnverk/shared';
+export { calculateTargetVersion, convertToReleaseVersion, deepMerge, incrementMajorVersion, incrementMinorVersion, incrementPatchVersion, incrementPrereleaseVersion, stringifyJSON, validateVersionString } from '@grunnverk/shared';
+import winston from 'winston';
+import { Writable } from 'stream';
+import * as fs from 'fs';
+import { statSync } from 'fs';
+import * as path from 'path';
+import path__default from 'path';
+import * as os from 'os';
+import os__default from 'os';
+import { run } from '@grunnverk/git-tools';
+import { glob } from 'glob';
+import { STANDARD_CHOICES, SecureTempFile, cleanupTempFile, createSecureTempFile, editContentInEditor, getLLMFeedbackInEditor, getUserChoice, getUserTextInput, requireTTY } from '@grunnverk/ai-service';
+export { STANDARD_CHOICES, SecureTempFile, cleanupTempFile, createSecureTempFile, editContentInEditor, getLLMFeedbackInEditor, getUserChoice, getUserTextInput, requireTTY } from '@grunnverk/ai-service';
+import { execSync } from 'child_process';
+import { z } from 'zod';
+
+const VERSION = '__VERSION__ (__GIT_BRANCH__/__GIT_COMMIT__ __GIT_TAGS__ __GIT_COMMIT_DATE__) __SYSTEM_INFO__';
+const PROGRAM_NAME = 'kodrdriv';
+const DEFAULT_CHARACTER_ENCODING = 'utf-8';
+const DEFAULT_BINARY_TO_TEXT_ENCODING = 'base64';
+const DEFAULT_DIFF = true;
+const DEFAULT_LOG = false;
+const DEFAULT_OVERRIDES = false;
+const DATE_FORMAT_MONTH_DAY = 'MM-DD';
+const DATE_FORMAT_YEAR = 'YYYY';
+const DATE_FORMAT_YEAR_MONTH = 'YYYY-MM';
+const DATE_FORMAT_YEAR_MONTH_DAY = 'YYYY-MM-DD';
+const DATE_FORMAT_YEAR_MONTH_DAY_SLASH = 'YYYY/MM/DD';
+const DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES = 'YYYY-MM-DD-HHmm';
+const DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS = 'YYYY-MM-DD-HHmmss';
+const DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS = 'YYYY-MM-DD-HHmmss.SSS';
+const DATE_FORMAT_SHORT_TIMESTAMP = 'YYMMdd-HHmm';
+const DATE_FORMAT_MONTH = 'MM';
+const DATE_FORMAT_DAY = 'DD';
+const DATE_FORMAT_HOURS = 'HHmm';
+const DATE_FORMAT_MINUTES = 'mm';
+const DATE_FORMAT_SECONDS = 'ss';
+const DATE_FORMAT_MILLISECONDS = 'SSS';
+const DEFAULT_VERBOSE = false;
+const DEFAULT_DRY_RUN = false;
+const DEFAULT_DEBUG = false;
+const DEFAULT_MODEL = 'gpt-4o-mini';
+const DEFAULT_MODEL_STRONG = 'gpt-4o';
+const DEFAULT_OPENAI_REASONING = 'low';
+const DEFAULT_OPENAI_MAX_OUTPUT_TOKENS = 10000;
+const DEFAULT_OUTPUT_DIRECTORY = 'output/kodrdriv';
+// Buffer size for git commands that may produce large output (like git log)
+const DEFAULT_GIT_COMMAND_MAX_BUFFER = 50 * 1024 * 1024; // 50MB
+const DEFAULT_CONTEXT_DIRECTORIES = [];
+const DEFAULT_CONFIG_DIR = '.kodrdriv';
+const DEFAULT_PREFERENCES_DIRECTORY = path__default.join(os__default.homedir(), '.kodrdriv');
+const DEFAULT_FROM_COMMIT_ALIAS = 'main';
+const DEFAULT_TO_COMMIT_ALIAS = 'HEAD';
+const DEFAULT_ADD = false;
+const DEFAULT_CACHED = false;
+const DEFAULT_SENDIT_MODE = false;
+const DEFAULT_INTERACTIVE_MODE = false;
+const DEFAULT_AMEND_MODE = false;
+// CRITICAL: Keep this low (3-5) to prevent log context contamination.
+// The LLM tends to pattern-match against recent commits instead of describing
+// the actual diff when it sees too much commit history. Set to 0 to disable.
+const DEFAULT_MESSAGE_LIMIT = 3;
+const DEFAULT_MAX_DIFF_BYTES = 20480; // 20KB limit per file
+const DEFAULT_MERGE_METHOD = 'squash';
+const DEFAULT_EXCLUDED_PATTERNS = [
+    'node_modules',
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lockb',
+    'composer.lock',
+    'Cargo.lock',
+    'Gemfile.lock',
+    'dist',
+    'build',
+    'out',
+    '.next',
+    '.nuxt',
+    'coverage',
+    '.vscode',
+    '.idea',
+    '.DS_Store',
+    '.git',
+    '.gitignore',
+    'logs',
+    'tmp',
+    '.cache',
+    '*.log',
+    '.env',
+    '.env.*',
+    '*.pem',
+    '*.crt',
+    '*.key',
+    '*.sqlite',
+    '*.db',
+    '*.zip',
+    '*.tar',
+    '*.gz',
+    '*.exe',
+    '*.bin'
+];
+const COMMAND_COMMIT = 'commit';
+const COMMAND_AUDIO_COMMIT = 'audio-commit';
+const COMMAND_SELECT_AUDIO = 'select-audio';
+const COMMAND_RELEASE = 'release';
+const COMMAND_REVIEW = 'review';
+const COMMAND_AUDIO_REVIEW = 'audio-review';
+const COMMAND_PUBLISH = 'publish';
+const COMMAND_TREE = 'tree';
+const COMMAND_LINK = 'link';
+const COMMAND_UNLINK = 'unlink';
+const COMMAND_CLEAN = 'clean';
+const COMMAND_PRECOMMIT = 'precommit';
+const COMMAND_DEVELOPMENT = 'development';
+const COMMAND_VERSIONS = 'versions';
+const COMMAND_UPDATES = 'updates';
+const COMMAND_CHECK_CONFIG = 'check-config';
+const COMMAND_INIT_CONFIG = 'init-config';
+const ALLOWED_COMMANDS = [
+    COMMAND_COMMIT,
+    COMMAND_AUDIO_COMMIT,
+    COMMAND_SELECT_AUDIO,
+    COMMAND_RELEASE,
+    COMMAND_REVIEW,
+    COMMAND_AUDIO_REVIEW,
+    COMMAND_PUBLISH,
+    COMMAND_TREE,
+    COMMAND_LINK,
+    COMMAND_UNLINK,
+    COMMAND_CLEAN,
+    COMMAND_PRECOMMIT,
+    COMMAND_DEVELOPMENT,
+    COMMAND_VERSIONS,
+    COMMAND_UPDATES
+];
+const DEFAULT_COMMAND = COMMAND_COMMIT;
+const DEFAULT_INSTRUCTIONS_DIR = `instructions`;
+const DEFAULT_PERSONA_DIR = `personas`;
+const DEFAULT_INSTRUCTIONS_COMMIT_FILE = `${DEFAULT_INSTRUCTIONS_DIR}/commit.md`;
+const DEFAULT_INSTRUCTIONS_RELEASE_FILE = `${DEFAULT_INSTRUCTIONS_DIR}/release.md`;
+const DEFAULT_INSTRUCTIONS_REVIEW_FILE = `${DEFAULT_INSTRUCTIONS_DIR}/review.md`;
+const DEFAULT_PERSONA_RELEASER_FILE = `${DEFAULT_PERSONA_DIR}/releaser.md`;
+const DEFAULT_PERSONA_YOU_FILE = `${DEFAULT_PERSONA_DIR}/you.md`;
+// Default instructions for each persona
+const DEFAULT_INSTRUCTIONS_MAP = {
+    [COMMAND_COMMIT]: DEFAULT_INSTRUCTIONS_COMMIT_FILE,
+    [COMMAND_AUDIO_COMMIT]: DEFAULT_INSTRUCTIONS_COMMIT_FILE,
+    [COMMAND_RELEASE]: DEFAULT_INSTRUCTIONS_RELEASE_FILE,
+    [COMMAND_REVIEW]: DEFAULT_INSTRUCTIONS_REVIEW_FILE,
+    [COMMAND_AUDIO_REVIEW]: DEFAULT_INSTRUCTIONS_REVIEW_FILE
+};
+// Default personas for each command
+const DEFAULT_PERSONA_MAP = {
+    [COMMAND_COMMIT]: DEFAULT_PERSONA_YOU_FILE,
+    [COMMAND_AUDIO_COMMIT]: DEFAULT_PERSONA_YOU_FILE,
+    [COMMAND_RELEASE]: DEFAULT_PERSONA_RELEASER_FILE,
+    [COMMAND_REVIEW]: DEFAULT_PERSONA_YOU_FILE,
+    [COMMAND_AUDIO_REVIEW]: DEFAULT_PERSONA_YOU_FILE
+};
+// Used by child process to create paths
+const DEFAULT_PATH_SEPARATOR = '/';
+// Used by util/general for file filtering
+const DEFAULT_IGNORE_PATTERNS = [
+    'node_modules/**',
+    '**/*.log',
+    '.git/**',
+    'dist/**',
+    'build/**',
+    'coverage/**',
+    'output/**',
+    '.DS_Store',
+    '*.tmp',
+    '*.cache',
+    '**/.kodrdriv-*.json'
+];
+// Used by util/storage for directory names
+const DEFAULT_DIRECTORY_PREFIX = '.kodrdriv';
+// Used by other commands but not exposed in CLI
+const INTERNAL_DEFAULT_OUTPUT_FILE = 'output.txt';
+const INTERNAL_DATETIME_FORMAT = 'YYYY-MM-DD_HH-mm-ss';
+// Define defaults in one place
+const KODRDRIV_DEFAULTS = {
+    dryRun: DEFAULT_DRY_RUN,
+    verbose: DEFAULT_VERBOSE,
+    debug: DEFAULT_DEBUG,
+    overrides: DEFAULT_OVERRIDES,
+    model: DEFAULT_MODEL,
+    openaiReasoning: DEFAULT_OPENAI_REASONING,
+    openaiMaxOutputTokens: DEFAULT_OPENAI_MAX_OUTPUT_TOKENS,
+    contextDirectories: DEFAULT_CONTEXT_DIRECTORIES,
+    commandName: DEFAULT_COMMAND,
+    configDirectory: DEFAULT_CONFIG_DIR,
+    outputDirectory: DEFAULT_OUTPUT_DIRECTORY,
+    preferencesDirectory: DEFAULT_PREFERENCES_DIRECTORY,
+    commit: {
+        add: DEFAULT_ADD,
+        cached: DEFAULT_CACHED,
+        sendit: DEFAULT_SENDIT_MODE,
+        interactive: DEFAULT_INTERACTIVE_MODE,
+        amend: DEFAULT_AMEND_MODE,
+        messageLimit: DEFAULT_MESSAGE_LIMIT,
+        skipFileCheck: false,
+        maxDiffBytes: DEFAULT_MAX_DIFF_BYTES,
+        contextFiles: undefined,
+        openaiReasoning: DEFAULT_OPENAI_REASONING,
+        openaiMaxOutputTokens: DEFAULT_OPENAI_MAX_OUTPUT_TOKENS
+    },
+    release: {
+        from: DEFAULT_FROM_COMMIT_ALIAS,
+        to: DEFAULT_TO_COMMIT_ALIAS,
+        messageLimit: DEFAULT_MESSAGE_LIMIT,
+        interactive: DEFAULT_INTERACTIVE_MODE,
+        maxDiffBytes: DEFAULT_MAX_DIFF_BYTES,
+        contextFiles: undefined,
+        noMilestones: false,
+        openaiReasoning: DEFAULT_OPENAI_REASONING,
+        openaiMaxOutputTokens: DEFAULT_OPENAI_MAX_OUTPUT_TOKENS
+    },
+    audioCommit: {
+        maxRecordingTime: 300,
+        audioDevice: undefined,
+        openaiReasoning: DEFAULT_OPENAI_REASONING,
+        openaiMaxOutputTokens: DEFAULT_OPENAI_MAX_OUTPUT_TOKENS
+    },
+    review: {
+        includeCommitHistory: true,
+        includeRecentDiffs: true,
+        includeReleaseNotes: false,
+        includeGithubIssues: true,
+        commitHistoryLimit: 10,
+        diffHistoryLimit: 5,
+        releaseNotesLimit: 3,
+        githubIssuesLimit: 20,
+        sendit: DEFAULT_SENDIT_MODE,
+        openaiReasoning: DEFAULT_OPENAI_REASONING,
+        openaiMaxOutputTokens: DEFAULT_OPENAI_MAX_OUTPUT_TOKENS
+    },
+    audioReview: {
+        includeCommitHistory: true,
+        includeRecentDiffs: true,
+        includeReleaseNotes: false,
+        includeGithubIssues: true,
+        commitHistoryLimit: 10,
+        diffHistoryLimit: 5,
+        releaseNotesLimit: 3,
+        githubIssuesLimit: 20,
+        sendit: DEFAULT_SENDIT_MODE,
+        maxRecordingTime: 300,
+        audioDevice: undefined,
+        directory: undefined,
+        openaiReasoning: DEFAULT_OPENAI_REASONING,
+        openaiMaxOutputTokens: DEFAULT_OPENAI_MAX_OUTPUT_TOKENS
+    },
+    publish: {
+        mergeMethod: DEFAULT_MERGE_METHOD,
+        from: DEFAULT_FROM_COMMIT_ALIAS,
+        targetVersion: 'patch',
+        interactive: DEFAULT_INTERACTIVE_MODE,
+        requiredEnvVars: [
+            'GITHUB_TOKEN',
+            'OPENAI_API_KEY'
+        ],
+        linkWorkspacePackages: true,
+        unlinkWorkspacePackages: true,
+        sendit: DEFAULT_SENDIT_MODE,
+        targetBranch: 'main',
+        noMilestones: false,
+        checksTimeout: 3600000,
+        releaseWorkflowsTimeout: 1800000
+    },
+    link: {
+        scopeRoots: {},
+        dryRun: false,
+        packageArgument: undefined,
+        externals: []
+    },
+    unlink: {
+        scopeRoots: {},
+        workspaceFile: undefined,
+        dryRun: false,
+        cleanNodeModules: false,
+        packageArgument: undefined,
+        externals: []
+    },
+    tree: {
+        directories: undefined,
+        exclude: undefined,
+        startFrom: undefined,
+        stopAt: undefined,
+        cmd: undefined,
+        builtInCommand: undefined,
+        continue: false,
+        packageArgument: undefined,
+        cleanNodeModules: false,
+        externals: []
+    },
+    development: {
+        targetVersion: 'patch',
+        noMilestones: false
+    },
+    versions: {
+        subcommand: undefined,
+        directories: undefined
+    },
+    updates: {
+        scope: undefined,
+        directories: undefined
+    },
+    excludedPatterns: DEFAULT_EXCLUDED_PATTERNS,
+    branches: {
+        working: {
+            targetBranch: 'main',
+            developmentBranch: true,
+            version: {
+                type: 'prerelease',
+                increment: true,
+                incrementLevel: 'patch',
+                tag: 'dev'
+            }
+        },
+        main: {
+            version: {
+                type: 'release'
+            }
+        }
+    }
+};
+
+const constants = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    ALLOWED_COMMANDS,
+    COMMAND_AUDIO_COMMIT,
+    COMMAND_AUDIO_REVIEW,
+    COMMAND_CHECK_CONFIG,
+    COMMAND_CLEAN,
+    COMMAND_COMMIT,
+    COMMAND_DEVELOPMENT,
+    COMMAND_INIT_CONFIG,
+    COMMAND_LINK,
+    COMMAND_PRECOMMIT,
+    COMMAND_PUBLISH,
+    COMMAND_RELEASE,
+    COMMAND_REVIEW,
+    COMMAND_SELECT_AUDIO,
+    COMMAND_TREE,
+    COMMAND_UNLINK,
+    COMMAND_UPDATES,
+    COMMAND_VERSIONS,
+    DATE_FORMAT_DAY,
+    DATE_FORMAT_HOURS,
+    DATE_FORMAT_MILLISECONDS,
+    DATE_FORMAT_MINUTES,
+    DATE_FORMAT_MONTH,
+    DATE_FORMAT_MONTH_DAY,
+    DATE_FORMAT_SECONDS,
+    DATE_FORMAT_SHORT_TIMESTAMP,
+    DATE_FORMAT_YEAR,
+    DATE_FORMAT_YEAR_MONTH,
+    DATE_FORMAT_YEAR_MONTH_DAY,
+    DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES,
+    DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS,
+    DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS,
+    DATE_FORMAT_YEAR_MONTH_DAY_SLASH,
+    DEFAULT_ADD,
+    DEFAULT_AMEND_MODE,
+    DEFAULT_BINARY_TO_TEXT_ENCODING,
+    DEFAULT_CACHED,
+    DEFAULT_CHARACTER_ENCODING,
+    DEFAULT_COMMAND,
+    DEFAULT_CONFIG_DIR,
+    DEFAULT_CONTEXT_DIRECTORIES,
+    DEFAULT_DEBUG,
+    DEFAULT_DIFF,
+    DEFAULT_DIRECTORY_PREFIX,
+    DEFAULT_DRY_RUN,
+    DEFAULT_EXCLUDED_PATTERNS,
+    DEFAULT_FROM_COMMIT_ALIAS,
+    DEFAULT_GIT_COMMAND_MAX_BUFFER,
+    DEFAULT_IGNORE_PATTERNS,
+    DEFAULT_INSTRUCTIONS_COMMIT_FILE,
+    DEFAULT_INSTRUCTIONS_DIR,
+    DEFAULT_INSTRUCTIONS_MAP,
+    DEFAULT_INSTRUCTIONS_RELEASE_FILE,
+    DEFAULT_INSTRUCTIONS_REVIEW_FILE,
+    DEFAULT_INTERACTIVE_MODE,
+    DEFAULT_LOG,
+    DEFAULT_MAX_DIFF_BYTES,
+    DEFAULT_MERGE_METHOD,
+    DEFAULT_MESSAGE_LIMIT,
+    DEFAULT_MODEL,
+    DEFAULT_MODEL_STRONG,
+    DEFAULT_OPENAI_MAX_OUTPUT_TOKENS,
+    DEFAULT_OPENAI_REASONING,
+    DEFAULT_OUTPUT_DIRECTORY,
+    DEFAULT_OVERRIDES,
+    DEFAULT_PATH_SEPARATOR,
+    DEFAULT_PERSONA_DIR,
+    DEFAULT_PERSONA_MAP,
+    DEFAULT_PERSONA_RELEASER_FILE,
+    DEFAULT_PERSONA_YOU_FILE,
+    DEFAULT_PREFERENCES_DIRECTORY,
+    DEFAULT_SENDIT_MODE,
+    DEFAULT_TO_COMMIT_ALIAS,
+    DEFAULT_VERBOSE,
+    INTERNAL_DATETIME_FORMAT,
+    INTERNAL_DEFAULT_OUTPUT_FILE,
+    KODRDRIV_DEFAULTS,
+    PROGRAM_NAME,
+    VERSION
+}, Symbol.toStringTag, { value: 'Module' }));
+
+// Track if debug directory has been ensured for this session
+let debugDirectoryEnsured = false;
+const ensureDebugDirectory = ()=>{
+    if (debugDirectoryEnsured) return;
+    const debugDir = path__default.join(DEFAULT_OUTPUT_DIRECTORY, 'debug');
+    try {
+        fs.mkdirSync(debugDir, {
+            recursive: true
+        });
+        debugDirectoryEnsured = true;
+    } catch (error) {
+        // Only log to console if not in MCP server mode (MCP mode requires clean stdout)
+        if (process.env.KODRDRIV_MCP_SERVER !== 'true') {
+            // eslint-disable-next-line no-console
+            console.error(`Failed to create debug directory ${debugDir}:`, error);
+        }
+    }
+};
+const generateDebugLogFilename = ()=>{
+    const now = new Date();
+    const timestamp = now.toISOString().replace(/[-:]/g, '').replace(/\./g, '').replace('T', '-').replace('Z', '');
+    return `${timestamp}-debug.log`;
+};
+const createTransports = (level)=>{
+    const transports = [];
+    // When running as MCP server, NEVER add console transports as they interfere with the protocol
+    // All output must go through log capture mechanism instead
+    const isMcpServer = process.env.KODRDRIV_MCP_SERVER === 'true';
+    if (isMcpServer) {
+        // In MCP mode, add a silent Memory transport to prevent winston from logging transport errors
+        // Winston complains when there are no transports, so we add a silent one
+        // The log capture transport will be added separately via installLogCapture
+        // Use a no-op stream that discards all output
+        const silentStream = new Writable({
+            write (_chunk, _encoding, callback) {
+                // Silent - discard all output, log capture handles actual logging
+                callback();
+            },
+            // Suppress any errors from the stream itself
+            destroy: function(_err, callback) {
+                callback();
+            }
+        });
+        // Suppress winston transport errors by catching them
+        const silentTransport = new winston.transports.Stream({
+            stream: silentStream,
+            silent: true
+        });
+        // Override error handling on the transport to prevent winston from logging to stderr
+        silentTransport.on('error', ()=>{
+        // Silently ignore transport errors - don't output to stderr
+        });
+        transports.push(silentTransport);
+    } else {
+        // Add console transport for info level and above (only when NOT in MCP mode)
+        if (level === 'info') {
+            transports.push(new winston.transports.Console({
+                format: winston.format.combine(winston.format.colorize(), winston.format.printf(({ level, message, dryRun })=>{
+                    const dryRunPrefix = dryRun ? '🔍 DRY RUN: ' : '';
+                    // For info level messages, don't show the level prefix
+                    if (level.includes('info')) {
+                        return `${dryRunPrefix}${String(message)}`;
+                    }
+                    // For warn, error, etc., show the level prefix
+                    return `${level}: ${dryRunPrefix}${String(message)}`;
+                }))
+            }));
+        } else {
+            // For debug/verbose levels, add console transport that shows info and above
+            transports.push(new winston.transports.Console({
+                level: 'info',
+                format: winston.format.combine(winston.format.colorize(), winston.format.printf(({ timestamp, level, message, dryRun, ...meta })=>{
+                    // For info level messages, use simpler format without timestamp
+                    if (level.includes('info')) {
+                        const dryRunPrefix = dryRun ? '🔍 DRY RUN: ' : '';
+                        return `${dryRunPrefix}${String(message)}`;
+                    }
+                    // Filter out winston internal metadata
+                    const filteredMeta = Object.keys(meta).reduce((acc, key)=>{
+                        if (![
+                            'level',
+                            'message',
+                            'timestamp',
+                            'dryRun',
+                            'service',
+                            'splat',
+                            'Symbol(level)',
+                            'Symbol(message)'
+                        ].includes(key)) {
+                            acc[key] = meta[key];
+                        }
+                        return acc;
+                    }, {});
+                    const metaStr = Object.keys(filteredMeta).length ? ` ${JSON.stringify(filteredMeta, null, 2)}` : '';
+                    const dryRunPrefix = dryRun ? '🔍 DRY RUN: ' : '';
+                    return `${timestamp} ${level}: ${dryRunPrefix}${String(message)}${metaStr}`;
+                }))
+            }));
+        }
+    }
+    // Add file transport for debug levels (debug and silly)
+    if (level === 'debug' || level === 'silly') {
+        ensureDebugDirectory();
+        const debugLogPath = path__default.join(DEFAULT_OUTPUT_DIRECTORY, 'debug', generateDebugLogFilename());
+        transports.push(new winston.transports.File({
+            filename: debugLogPath,
+            level: 'debug',
+            format: winston.format.combine(winston.format.timestamp({
+                format: DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS
+            }), winston.format.errors({
+                stack: true
+            }), winston.format.splat(), winston.format.printf(({ timestamp, level, message, service, ...meta })=>{
+                // Filter out winston internal metadata and properly format remaining meta
+                const filteredMeta = Object.keys(meta).reduce((acc, key)=>{
+                    // Skip internal winston fields
+                    if (![
+                        'level',
+                        'message',
+                        'timestamp',
+                        'splat',
+                        'Symbol(level)',
+                        'Symbol(message)'
+                    ].includes(key)) {
+                        acc[key] = meta[key];
+                    }
+                    return acc;
+                }, {});
+                const metaStr = Object.keys(filteredMeta).length ? ` ${JSON.stringify(filteredMeta, null, 2)}` : '';
+                const serviceStr = service ? ` [${service}]` : '';
+                return `${timestamp}${serviceStr} ${level}: ${message}${metaStr}`;
+            }))
+        }));
+    }
+    return transports;
+};
+const createFormat = (level)=>{
+    const baseFormats = [
+        winston.format.errors({
+            stack: true
+        }),
+        winston.format.splat()
+    ];
+    if (level === 'info') {
+        return winston.format.combine(...baseFormats, winston.format.printf(({ message, dryRun, ..._meta })=>{
+            // Auto-format dry-run messages
+            if (dryRun) {
+                return `🔍 DRY RUN: ${message}`;
+            }
+            return String(message);
+        }));
+    }
+    return winston.format.combine(winston.format.timestamp({
+        format: DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS
+    }), ...baseFormats, winston.format.printf(({ timestamp, level, message, dryRun, ...meta })=>{
+        // Filter out winston internal metadata
+        const filteredMeta = Object.keys(meta).reduce((acc, key)=>{
+            if (![
+                'level',
+                'message',
+                'timestamp',
+                'dryRun',
+                'service',
+                'splat',
+                'Symbol(level)',
+                'Symbol(message)'
+            ].includes(key)) {
+                acc[key] = meta[key];
+            }
+            return acc;
+        }, {});
+        const metaStr = Object.keys(filteredMeta).length ? ` ${JSON.stringify(filteredMeta, null, 2)}` : '';
+        const dryRunPrefix = dryRun ? '🔍 DRY RUN: ' : '';
+        return `${timestamp} ${level}: ${dryRunPrefix}${String(message)}${metaStr}`;
+    }));
+};
+// Create the logger instance once
+const logger = winston.createLogger({
+    level: 'info',
+    format: createFormat('info'),
+    defaultMeta: {
+        service: PROGRAM_NAME
+    },
+    transports: createTransports('info'),
+    // Suppress winston's own error handling in MCP mode to prevent stderr pollution
+    exceptionHandlers: process.env.KODRDRIV_MCP_SERVER === 'true' ? [] : undefined,
+    rejectionHandlers: process.env.KODRDRIV_MCP_SERVER === 'true' ? [] : undefined,
+    // Prevent winston from logging transport errors to stderr
+    handleExceptions: false,
+    handleRejections: false
+});
+const setLogLevel = (level)=>{
+    // Reconfigure the existing logger instead of creating a new one
+    const isMcpServer = process.env.KODRDRIV_MCP_SERVER === 'true';
+    logger.configure({
+        level,
+        format: createFormat(level),
+        defaultMeta: {
+            service: PROGRAM_NAME
+        },
+        transports: createTransports(level),
+        // Suppress winston's own error handling in MCP mode to prevent stderr pollution
+        exceptionHandlers: isMcpServer ? [] : undefined,
+        rejectionHandlers: isMcpServer ? [] : undefined,
+        // Prevent winston from logging transport errors to stderr
+        handleExceptions: false,
+        handleRejections: false
+    });
+};
+const getLogger = ()=>logger;
+/**
+ * Get a logger that automatically formats messages for dry-run mode
+ */ const getDryRunLogger = (isDryRun)=>{
+    if (!isDryRun) {
+        return logger;
+    }
+    // Return a wrapper that adds dry-run context to all log calls
+    return {
+        info: (message, ...args)=>logger.info(message, {
+                dryRun: true
+            }, ...args),
+        warn: (message, ...args)=>logger.warn(message, {
+                dryRun: true
+            }, ...args),
+        error: (message, ...args)=>logger.error(message, {
+                dryRun: true
+            }, ...args),
+        debug: (message, ...args)=>logger.debug(message, {
+                dryRun: true
+            }, ...args),
+        verbose: (message, ...args)=>logger.verbose(message, {
+                dryRun: true
+            }, ...args),
+        silly: (message, ...args)=>logger.silly(message, {
+                dryRun: true
+            }, ...args)
+    };
+};
+
+const logging = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    getDryRunLogger,
+    getLogger,
+    setLogLevel
+}, Symbol.toStringTag, { value: 'Module' }));
+
+// Enhanced exclusion patterns specifically for review context
+// These focus on excluding large files, binaries, and content that doesn't help with issue analysis
+const getReviewExcludedPatterns = (basePatterns)=>{
+    const reviewSpecificExclusions = [
+        // Lock files and dependency files (often massive)
+        "*lock*",
+        "*.lock",
+        "package-lock.json",
+        "yarn.lock",
+        "bun.lockb",
+        "composer.lock",
+        "Cargo.lock",
+        "Gemfile.lock",
+        "Pipfile.lock",
+        "poetry.lock",
+        // Image files (binary and large)
+        "*.png",
+        "*.jpg",
+        "*.jpeg",
+        "*.gif",
+        "*.bmp",
+        "*.tiff",
+        "*.webp",
+        "*.svg",
+        "*.ico",
+        "*.icns",
+        // Video and audio files
+        "*.mp4",
+        "*.avi",
+        "*.mov",
+        "*.wmv",
+        "*.flv",
+        "*.mp3",
+        "*.wav",
+        "*.flac",
+        // Archives and compressed files
+        "*.zip",
+        "*.tar",
+        "*.tar.gz",
+        "*.tgz",
+        "*.rar",
+        "*.7z",
+        "*.bz2",
+        "*.xz",
+        // Binary executables and libraries
+        "*.exe",
+        "*.dll",
+        "*.so",
+        "*.dylib",
+        "*.bin",
+        "*.app",
+        // Database files
+        "*.db",
+        "*.sqlite",
+        "*.sqlite3",
+        "*.mdb",
+        // Large generated files
+        "*.map",
+        "*.min.js",
+        "*.min.css",
+        "bundle.*",
+        "vendor.*",
+        // Documentation that's often large
+        "*.pdf",
+        "*.doc",
+        "*.docx",
+        "*.ppt",
+        "*.pptx",
+        // IDE and OS generated files
+        ".DS_Store",
+        "Thumbs.db",
+        "*.swp",
+        "*.tmp",
+        // Certificate and key files
+        "*.pem",
+        "*.crt",
+        "*.key",
+        "*.p12",
+        "*.pfx",
+        // Large config/data files that are often auto-generated
+        "tsconfig.tsbuildinfo",
+        "*.cache",
+        ".eslintcache"
+    ];
+    // Combine base patterns with review specific exclusions, removing duplicates
+    const combinedPatterns = [
+        ...new Set([
+            ...basePatterns,
+            ...reviewSpecificExclusions
+        ])
+    ];
+    return combinedPatterns;
+};
+// Check if there are changes to critical files that are normally excluded
+const hasCriticalExcludedChanges = async ()=>{
+    const logger = getLogger();
+    const criticalPatterns = [
+        'package-lock.json',
+        'yarn.lock',
+        'bun.lockb',
+        '.gitignore',
+        '.env.example'
+    ];
+    try {
+        // Check for unstaged changes to critical files
+        const { stdout } = await run('git status --porcelain');
+        const changedFiles = stdout.split('\n').filter((line)=>line.trim()).map((line)=>line.substring(3).trim()); // Remove status prefix
+        const criticalFiles = changedFiles.filter((file)=>criticalPatterns.some((pattern)=>file === pattern || file.endsWith(`/${pattern}`)));
+        logger.debug('Found %d critical excluded files with changes: %s', criticalFiles.length, criticalFiles.join(', '));
+        return {
+            hasChanges: criticalFiles.length > 0,
+            files: criticalFiles
+        };
+    } catch (error) {
+        logger.debug('Error checking for critical excluded changes: %s', error.message);
+        return {
+            hasChanges: false,
+            files: []
+        };
+    }
+};
+// Get minimal excluded patterns that still includes critical files
+const getMinimalExcludedPatterns = (basePatterns)=>{
+    const criticalPatterns = [
+        'package-lock.json',
+        'yarn.lock',
+        'bun.lockb',
+        '.gitignore',
+        '.env.example'
+    ];
+    // Filter out critical patterns from base patterns
+    return basePatterns.filter((pattern)=>!criticalPatterns.some((critical)=>pattern === critical || pattern.includes(critical)));
+};
+// Function to truncate overly large diff content while preserving structure
+const truncateLargeDiff = (diffContent, maxLength = 5000)=>{
+    if (diffContent.length <= maxLength) {
+        return diffContent;
+    }
+    const lines = diffContent.split('\n');
+    const truncatedLines = [];
+    let currentLength = 0;
+    let truncated = false;
+    for (const line of lines){
+        if (currentLength + line.length + 1 > maxLength) {
+            truncated = true;
+            break;
+        }
+        truncatedLines.push(line);
+        currentLength += line.length + 1; // +1 for newline
+    }
+    if (truncated) {
+        truncatedLines.push('');
+        truncatedLines.push(`... [TRUNCATED: Original diff was ${diffContent.length} characters, showing first ${currentLength}] ...`);
+    }
+    return truncatedLines.join('\n');
+};
+// Smart diff truncation that identifies and handles large files individually
+const truncateDiffByFiles = (diffContent, maxDiffBytes)=>{
+    if (diffContent.length <= maxDiffBytes) {
+        return diffContent;
+    }
+    const lines = diffContent.split('\n');
+    const result = [];
+    let currentFile = [];
+    let currentFileHeader = '';
+    let totalSize = 0;
+    let filesOmitted = 0;
+    for (const line of lines){
+        // Check if this is a file header (starts with diff --git)
+        if (line.startsWith('diff --git ')) {
+            // Process the previous file if it exists
+            if (currentFile.length > 0) {
+                const fileContent = currentFile.join('\n');
+                const fileSizeBytes = Buffer.byteLength(fileContent, 'utf8');
+                if (fileSizeBytes > maxDiffBytes) {
+                    // This single file is too large, replace with a summary
+                    result.push(currentFileHeader);
+                    result.push(`... [CHANGE OMITTED: File too large (${fileSizeBytes} bytes > ${maxDiffBytes} limit)] ...`);
+                    result.push('');
+                    filesOmitted++;
+                } else if (totalSize + fileSizeBytes > maxDiffBytes * 10) {
+                    // Adding this file would make total too large
+                    result.push(currentFileHeader);
+                    result.push(`... [CHANGE OMITTED: Would exceed total size limit] ...`);
+                    result.push('');
+                    filesOmitted++;
+                } else {
+                    // File is acceptable size
+                    result.push(...currentFile);
+                    totalSize += fileSizeBytes;
+                }
+            }
+            // Start new file
+            currentFileHeader = line;
+            currentFile = [
+                line
+            ];
+        } else {
+            // Add line to current file
+            currentFile.push(line);
+        }
+    }
+    // Handle the last file
+    if (currentFile.length > 0) {
+        const fileContent = currentFile.join('\n');
+        const fileSizeBytes = Buffer.byteLength(fileContent, 'utf8');
+        if (fileSizeBytes > maxDiffBytes) {
+            result.push(currentFileHeader);
+            result.push(`... [CHANGE OMITTED: File too large (${fileSizeBytes} bytes > ${maxDiffBytes} limit)] ...`);
+            result.push('');
+            filesOmitted++;
+        } else if (totalSize + fileSizeBytes > maxDiffBytes * 10) {
+            result.push(currentFileHeader);
+            result.push(`... [CHANGE OMITTED: Would exceed total size limit] ...`);
+            result.push('');
+            filesOmitted++;
+        } else {
+            result.push(...currentFile);
+            totalSize += fileSizeBytes;
+        }
+    }
+    const finalResult = result.join('\n');
+    if (filesOmitted > 0) {
+        return finalResult + `\n\n[SUMMARY: ${filesOmitted} files omitted due to size limits. Original diff: ${diffContent.length} bytes, processed diff: ${finalResult.length} bytes]`;
+    }
+    return finalResult;
+};
+const create$2 = async (options)=>{
+    const logger = getLogger();
+    async function get() {
+        try {
+            logger.verbose('Gathering change information from Git');
+            try {
+                logger.debug('Executing git diff');
+                const excludeString = options.excludedPatterns.map((p)=>`':(exclude)${p}'`).join(' ');
+                let range = '';
+                if (options.from && options.to) {
+                    range = `${options.from}..${options.to}`;
+                } else if (options.from) {
+                    range = `${options.from}`;
+                } else if (options.to) {
+                    range = `${options.to}`;
+                }
+                let command = '';
+                if (options.cached) {
+                    command = `git diff --cached${range ? ' ' + range : ''} -- . ${excludeString}`;
+                } else {
+                    command = `git diff${range ? ' ' + range : ''} -- . ${excludeString}`;
+                }
+                const { stdout, stderr } = await run(command, {
+                    maxBuffer: DEFAULT_GIT_COMMAND_MAX_BUFFER
+                });
+                if (stderr) {
+                    logger.warn('GIT_DIFF_STDERR: Git diff produced stderr output | Stderr: %s | Impact: May indicate warnings', stderr);
+                }
+                logger.debug('Git diff output: %s', stdout);
+                // Apply intelligent diff truncation if maxDiffBytes is specified
+                if (options.maxDiffBytes && stdout.length > 0) {
+                    const originalSize = Buffer.byteLength(stdout, 'utf8');
+                    const truncatedDiff = truncateDiffByFiles(stdout, options.maxDiffBytes);
+                    const newSize = Buffer.byteLength(truncatedDiff, 'utf8');
+                    if (originalSize !== newSize) {
+                        logger.info('DIFF_TRUNCATED: Applied diff size truncation | Original: %d bytes | Truncated: %d bytes | Limit: %d bytes | Reason: Size exceeds limit', originalSize, newSize, options.maxDiffBytes);
+                    }
+                    return truncatedDiff;
+                }
+                return stdout;
+            } catch (error) {
+                logger.error('GIT_DIFF_FAILED: Failed to execute git diff command | Error: %s | Impact: Cannot gather change information', error.message);
+                throw error;
+            }
+        } catch (error) {
+            logger.error('DIFF_GATHER_ERROR: Error during change gathering phase | Error: %s | Stack: %s | Impact: Cannot collect diff', error.message, error.stack);
+            throw new ExitError('Error occurred during gather change phase');
+        }
+    }
+    return {
+        get
+    };
+};
+const hasStagedChanges = async ()=>{
+    const logger = getLogger();
+    try {
+        logger.debug('Checking for staged changes');
+        // Suppress error logging since exit code 1 is expected when there are staged changes
+        const { stderr } = await run('git diff --cached --quiet', {
+            suppressErrorLogging: true
+        });
+        if (stderr) {
+            logger.warn('GIT_DIFF_STDERR: Git diff produced stderr output | Stderr: %s | Impact: May indicate warnings', stderr);
+        }
+        // If there are staged changes, git diff --cached --quiet will return non-zero
+        // So if we get here without an error, there are no staged changes
+        return false;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (error) {
+        // If we get an error, it means there are staged changes (exit code 1 is expected behavior)
+        return true;
+    }
+};
+// High-level function to get recent diffs formatted for review context
+const getRecentDiffsForReview = async (options)=>{
+    const logger = getLogger();
+    const diffLimit = options.limit || 5;
+    // Get enhanced exclusion patterns for review context
+    const reviewExcluded = getReviewExcludedPatterns(options.baseExcludedPatterns);
+    logger.debug('Using %d exclusion patterns for diff context (including %d review specific)', reviewExcluded.length, reviewExcluded.length - options.baseExcludedPatterns.length);
+    logger.debug('Sample exclusions: %s', reviewExcluded.slice(0, 10).join(', ') + (reviewExcluded.length > 10 ? '...' : ''));
+    const diffSections = [];
+    // Get recent commits and their diffs
+    for(let i = 0; i < diffLimit; i++){
+        try {
+            const diffRange = i === 0 ? 'HEAD~1' : `HEAD~${i + 1}..HEAD~${i}`;
+            const diff = await create$2({
+                from: `HEAD~${i + 1}`,
+                to: `HEAD~${i}`,
+                excludedPatterns: reviewExcluded
+            });
+            const diffContent = await diff.get();
+            if (diffContent.trim()) {
+                const truncatedDiff = truncateLargeDiff(diffContent);
+                diffSections.push(`[Recent Diff ${i + 1} (${diffRange})]\n${truncatedDiff}`);
+                if (truncatedDiff.length < diffContent.length) {
+                    logger.debug('Added diff %d to context (%d characters, truncated from %d)', i + 1, truncatedDiff.length, diffContent.length);
+                } else {
+                    logger.debug('Added diff %d to context (%d characters)', i + 1, diffContent.length);
+                }
+            } else {
+                logger.debug('Diff %d was empty after exclusions', i + 1);
+            }
+        } catch (error) {
+            logger.debug('Could not fetch diff %d: %s', i + 1, error.message);
+            break; // Stop if we can't fetch more diffs
+        }
+    }
+    return diffSections.length > 0 ? '\n\n' + diffSections.join('\n\n') : '';
+};
+
+const diff = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    create: create$2,
+    getMinimalExcludedPatterns,
+    getRecentDiffsForReview,
+    getReviewExcludedPatterns,
+    hasCriticalExcludedChanges,
+    hasStagedChanges,
+    truncateDiffByFiles,
+    truncateLargeDiff
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const create$1 = async (options)=>{
+    const logger = getLogger();
+    async function get() {
+        try {
+            logger.verbose('Gathering change information from Git');
+            try {
+                logger.debug('Executing git log');
+                // Build git log range
+                let range = '';
+                let extraArgs = '';
+                // If currentBranchOnly, show only commits unique to HEAD vs. to-branch (or main/master if not provided)
+                if (options.currentBranchOnly) {
+                    const toBranch = options.to || 'main'; // Default to 'main' if not provided
+                    range = `${toBranch}..HEAD`;
+                } else if (options.from && options.to) {
+                    range = `${options.from}..${options.to}`;
+                } else if (options.from) {
+                    range = `${options.from}`;
+                } else if (options.to) {
+                    range = `${options.to}`;
+                } // else, no range: show all
+                if (options.limit && options.limit > 0) {
+                    extraArgs += ` -n ${options.limit}`;
+                }
+                const gitLogCmd = `git log${range ? ' ' + range : ''}${extraArgs}`;
+                logger.debug('Git log command: %s', gitLogCmd);
+                const { stdout, stderr } = await run(gitLogCmd, {
+                    maxBuffer: DEFAULT_GIT_COMMAND_MAX_BUFFER
+                });
+                if (stderr) {
+                    logger.warn('GIT_LOG_STDERR: Git log produced stderr output | Stderr: %s | Impact: May indicate warnings', stderr);
+                }
+                logger.debug('Git log output: %s', stdout);
+                return stdout;
+            } catch (error) {
+                // Check if this is an empty repository (no commits) scenario
+                const errorMessage = error.message || '';
+                const isEmptyRepo = errorMessage.includes('does not have any commits yet') || errorMessage.includes('bad default revision') || errorMessage.includes('unknown revision or path not in the working tree') || errorMessage.includes('ambiguous argument \'HEAD\'');
+                if (isEmptyRepo) {
+                    logger.debug('Empty repository detected (no commits): %s', errorMessage);
+                    logger.verbose('No git history available, returning empty log context');
+                    return ''; // Return empty string for empty repositories
+                }
+                logger.error('GIT_LOG_FAILED: Failed to execute git log command | Error: %s | Impact: Cannot gather commit history', error.message);
+                throw error;
+            }
+        } catch (error) {
+            // Check again at the outer level in case the error wasn't caught by the inner try-catch
+            const errorMessage = error.message || '';
+            const isEmptyRepo = errorMessage.includes('does not have any commits yet') || errorMessage.includes('bad default revision') || errorMessage.includes('unknown revision or path not in the working tree') || errorMessage.includes('ambiguous argument \'HEAD\'');
+            if (isEmptyRepo) {
+                logger.debug('Empty repository detected at outer level: %s', errorMessage);
+                logger.verbose('No git history available, returning empty log context');
+                return ''; // Return empty string for empty repositories
+            }
+            logger.error('LOG_GATHER_ERROR: Error during change gathering phase | Error: %s | Stack: %s | Impact: Cannot collect log', error.message, error.stack);
+            throw new ExitError('Error occurred during gather change phase');
+        }
+    }
+    return {
+        get
+    };
+};
+
+const log = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    create: create$1
+}, Symbol.toStringTag, { value: 'Module' }));
+
+// Convert excluded patterns to glob patterns for file filtering
+const convertToGlobPatterns = (excludedPatterns)=>{
+    return excludedPatterns.map((pattern)=>{
+        // Convert simple patterns to glob patterns
+        if (!pattern.includes('*') && !pattern.includes('/')) {
+            // Simple name like 'node_modules' -> '**/node_modules/**'
+            return `**/${pattern}/**`;
+        }
+        if (pattern.includes('*')) {
+            // Already a glob pattern, ensure it starts with **/ for recursive matching
+            return pattern.startsWith('**/') ? pattern : `**/${pattern}`;
+        }
+        if (pattern.endsWith('/')) {
+            // Directory pattern like 'dist/' -> '**/dist/**'
+            return `**/${pattern}**`;
+        }
+        // File pattern like '.env' -> '**/.env'
+        return `**/${pattern}`;
+    });
+};
+// Check if a file path matches any excluded pattern
+const isFileExcluded = (filePath, excludedPatterns)=>{
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    for (const pattern of excludedPatterns){
+        if (pattern.includes('*')) {
+            // Use minimatch-style matching for glob patterns
+            const regex = new RegExp(pattern.replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*').replace(/\?/g, '[^/]'));
+            if (regex.test(normalizedPath)) {
+                return true;
+            }
+        } else {
+            // Simple string matching
+            if (normalizedPath.includes(pattern) || normalizedPath.endsWith(pattern) || normalizedPath.split('/').includes(pattern)) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+// Get file content with size limit
+const getFileContent = async (filePath, storage, maxSize = 10240)=>{
+    const logger = getLogger();
+    try {
+        if (!await storage.isFileReadable(filePath)) {
+            return null;
+        }
+        // Read file content
+        const content = await storage.readFile(filePath, 'utf-8');
+        const sizeBytes = Buffer.byteLength(content, 'utf-8');
+        if (sizeBytes > maxSize) {
+            // Truncate large files
+            const truncatedContent = content.substring(0, Math.floor(maxSize * 0.8));
+            return `${truncatedContent}\n\n... [TRUNCATED: File was ${sizeBytes} bytes, showing first ${truncatedContent.length} characters] ...`;
+        }
+        return content;
+    } catch (error) {
+        logger.debug('Failed to read file %s: %s', filePath, error.message);
+        return null;
+    }
+};
+const create = async (options)=>{
+    const logger = getLogger();
+    const storage = createStorage();
+    const maxTotalBytes = options.maxTotalBytes || 100 * 1024; // 100KB default
+    const workingDir = options.workingDirectory || process.cwd();
+    async function get() {
+        try {
+            logger.verbose('Collecting file content from working directory for commit analysis');
+            // Find all files in the working directory, excluding common patterns
+            const globPatterns = [
+                '**/*',
+                '!**/node_modules/**',
+                '!**/.git/**',
+                '!**/dist/**',
+                '!**/build/**',
+                '!**/coverage/**',
+                '!**/*.log',
+                '!**/tmp/**',
+                '!**/.cache/**'
+            ];
+            // Add user-specified exclusions
+            const additionalExclusions = convertToGlobPatterns(options.excludedPatterns);
+            for (const exclusion of additionalExclusions){
+                if (!exclusion.startsWith('!')) {
+                    globPatterns.push(`!${exclusion}`);
+                }
+            }
+            logger.debug('Using glob patterns: %s', globPatterns.join(', '));
+            const files = await glob(globPatterns, {
+                cwd: workingDir,
+                nodir: true,
+                dot: false // Exclude hidden files by default
+            });
+            logger.debug('Found %d files to analyze', files.length);
+            const fileContents = [];
+            let totalBytes = 0;
+            let filesProcessed = 0;
+            let filesSkipped = 0;
+            // Sort files by likely importance (source files first)
+            const sortedFiles = files.sort((a, b)=>{
+                const getFileImportance = (file)=>{
+                    const ext = path__default.extname(file).toLowerCase();
+                    const name = path__default.basename(file).toLowerCase();
+                    // High importance: main source files
+                    if ([
+                        'package.json',
+                        'tsconfig.json',
+                        'webpack.config.js',
+                        'vite.config.ts'
+                    ].includes(name)) return 1;
+                    if ([
+                        '.ts',
+                        '.tsx',
+                        '.js',
+                        '.jsx',
+                        '.py',
+                        '.rs',
+                        '.go',
+                        '.java',
+                        '.cpp',
+                        '.c',
+                        '.h'
+                    ].includes(ext)) return 2;
+                    if ([
+                        '.md',
+                        '.txt',
+                        '.yml',
+                        '.yaml',
+                        '.json'
+                    ].includes(ext)) return 3;
+                    if ([
+                        '.css',
+                        '.scss',
+                        '.sass',
+                        '.less',
+                        '.html'
+                    ].includes(ext)) return 4;
+                    return 5; // Lower importance
+                };
+                return getFileImportance(a) - getFileImportance(b);
+            });
+            for (const file of sortedFiles){
+                const fullPath = path__default.join(workingDir, file);
+                // Double-check exclusions
+                if (isFileExcluded(file, options.excludedPatterns)) {
+                    filesSkipped++;
+                    continue;
+                }
+                const content = await getFileContent(fullPath, storage);
+                if (content === null) {
+                    filesSkipped++;
+                    continue;
+                }
+                const contentSize = Buffer.byteLength(content, 'utf-8');
+                // Check if adding this file would exceed our total limit
+                if (totalBytes + contentSize > maxTotalBytes && filesProcessed > 0) {
+                    logger.debug('Reached size limit (%d bytes), stopping at %d files', maxTotalBytes, filesProcessed);
+                    break;
+                }
+                fileContents.push(`=== ${file} ===\n${content}\n`);
+                totalBytes += contentSize;
+                filesProcessed++;
+                logger.debug('Added file %s (%d bytes, total: %d bytes)', file, contentSize, totalBytes);
+            }
+            logger.info('FILES_COLLECTED: Collected file content successfully | Files Collected: %d | Total Bytes: %d | Files Skipped: %d | Status: completed', filesProcessed, totalBytes, filesSkipped);
+            if (fileContents.length === 0) {
+                return 'No readable files found in working directory.';
+            }
+            const result = fileContents.join('\n');
+            // Add summary header
+            const summary = `File Content Analysis (${filesProcessed} files, ${totalBytes} bytes)\n` + `Working Directory: ${workingDir}\n` + `Files Processed: ${filesProcessed}, Files Skipped: ${filesSkipped}\n\n` + result;
+            return summary;
+        } catch (error) {
+            logger.error('FILES_COLLECTION_ERROR: Error during file content collection | Error: %s | Stack: %s | Impact: Cannot collect file content', error.message, error.stack);
+            throw new Error('Error occurred during file content collection');
+        }
+    }
+    return {
+        get
+    };
+};
+
+const files = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    create
+}, Symbol.toStringTag, { value: 'Module' }));
+
+/**
+ * Get version from a specific branch's package.json
+ */ const getVersionFromBranch = async (branchName)=>{
+    const { runSecure, validateGitRef, safeJsonParse, validatePackageJson } = await import('@grunnverk/git-tools');
+    try {
+        // Validate branch name to prevent injection
+        if (!validateGitRef(branchName)) {
+            throw new Error(`Invalid branch name: ${branchName}`);
+        }
+        // Cast to any to avoid type mismatch with node_modules version
+        const { stdout } = await runSecure('git', [
+            'show',
+            `${branchName}:package.json`
+        ], {
+            suppressErrorLogging: true
+        });
+        const packageJson = safeJsonParse(stdout, 'package.json');
+        const validated = validatePackageJson(packageJson, 'package.json');
+        return validated.version;
+    } catch  {
+        // Return null if we can't get the version (branch may not exist or no package.json)
+        return null;
+    }
+};
+/**
+ * Calculate target version based on branch configuration
+ * SEMANTICS: The version config specifies what version should be ON the target branch
+ */ const calculateBranchDependentVersion = async (currentVersion, currentBranch, branchesConfig, targetBranch)=>{
+    const { getLogger } = await Promise.resolve().then(() => logging);
+    const logger = getLogger();
+    // Look up the source branch to find the target branch
+    if (!branchesConfig || !branchesConfig[currentBranch]) {
+        // Use default configuration from constants
+        const { KODRDRIV_DEFAULTS } = await Promise.resolve().then(() => constants);
+        const defaultConfig = KODRDRIV_DEFAULTS.branches;
+        if (defaultConfig && defaultConfig[currentBranch]) {
+            const sourceConfig = defaultConfig[currentBranch];
+            const finalTargetBranch = sourceConfig.targetBranch || targetBranch || 'main';
+            // Look at target branch's version config to determine what version it should have
+            const targetConfig = defaultConfig[finalTargetBranch];
+            logger.info(`VERSION_BRANCH_DEFAULT: Using default branch configuration | Source Branch: ${currentBranch} | Target Branch: ${finalTargetBranch} | Source: default config`);
+            if (!(targetConfig === null || targetConfig === void 0 ? void 0 : targetConfig.version)) {
+                const defaultVersion = incrementPatchVersion(currentVersion);
+                logger.debug(`No version config for target branch '${finalTargetBranch}', using default increment`);
+                return {
+                    version: defaultVersion,
+                    targetBranch: finalTargetBranch
+                };
+            }
+            return calculateVersionFromTargetConfig(currentVersion, finalTargetBranch, targetConfig.version, logger);
+        }
+        // No config at all, use traditional defaults
+        const defaultTargetBranch = targetBranch || 'main';
+        const defaultVersion = incrementPatchVersion(currentVersion);
+        logger.debug(`No branch-specific config found for '${currentBranch}', using defaults`);
+        return {
+            version: defaultVersion,
+            targetBranch: defaultTargetBranch
+        };
+    }
+    const sourceConfig = branchesConfig[currentBranch];
+    const finalTargetBranch = sourceConfig.targetBranch || targetBranch || 'main';
+    // Look at target branch's version config to determine what version it should have
+    const targetConfig = branchesConfig[finalTargetBranch];
+    logger.info(`VERSION_BRANCH_DEPENDENT: Using branch-dependent targeting | Source Branch: ${currentBranch} | Target Branch: ${finalTargetBranch} | Source: branch config`);
+    if (!(targetConfig === null || targetConfig === void 0 ? void 0 : targetConfig.version)) {
+        // No version config for target, use default increment
+        const defaultVersion = incrementPatchVersion(currentVersion);
+        logger.debug(`No version config for target branch '${finalTargetBranch}', using default increment`);
+        return {
+            version: defaultVersion,
+            targetBranch: finalTargetBranch
+        };
+    }
+    return calculateVersionFromTargetConfig(currentVersion, finalTargetBranch, targetConfig.version, logger);
+};
+/**
+ * Calculate version based on target branch configuration
+ */ const calculateVersionFromTargetConfig = async (currentVersion, targetBranch, versionConfig, logger)=>{
+    if (versionConfig.type === 'release') {
+        // Convert to release version (remove prerelease tags)
+        const releaseVersion = convertToReleaseVersion(currentVersion);
+        logger.info(`VERSION_RELEASE_CONVERSION: Converting prerelease to release version | Current: ${currentVersion} | Release: ${releaseVersion} | Action: Remove prerelease tag`);
+        return {
+            version: releaseVersion,
+            targetBranch
+        };
+    } else if (versionConfig.type === 'prerelease') {
+        if (!versionConfig.tag) {
+            throw new Error(`Prerelease version type requires a tag in branch configuration`);
+        }
+        const tag = versionConfig.tag;
+        if (versionConfig.increment) {
+            // Check if there's already a version with this tag in the target branch
+            const targetBranchVersion = await getVersionFromBranch(targetBranch);
+            if (targetBranchVersion) {
+                // Use the target branch version as the base and increment
+                const newVersion = incrementPrereleaseVersion(targetBranchVersion, tag);
+                logger.info(`VERSION_PRERELEASE_INCREMENT: Incrementing prerelease version | Current: ${targetBranchVersion} | New: ${newVersion} | Action: Increment prerelease number`);
+                return {
+                    version: newVersion,
+                    targetBranch
+                };
+            } else {
+                // No version in target branch, use current version as base
+                const newVersion = incrementPrereleaseVersion(currentVersion, tag);
+                logger.info(`VERSION_PRERELEASE_CREATE: Creating new prerelease version | Current: ${currentVersion} | New: ${newVersion} | Action: Add prerelease tag`);
+                return {
+                    version: newVersion,
+                    targetBranch
+                };
+            }
+        } else {
+            // Just add/change the prerelease tag without incrementing
+            const baseVersion = convertToReleaseVersion(currentVersion);
+            const newVersion = `${baseVersion}-${tag}.0`;
+            logger.info(`VERSION_PRERELEASE_TAG: Setting prerelease tag | Current: ${currentVersion} | New: ${newVersion} | Tag: ${versionConfig.tag}`);
+            return {
+                version: newVersion,
+                targetBranch
+            };
+        }
+    }
+    throw new Error(`Invalid version type: ${versionConfig.type}`);
+};
+/**
+ * Find the development branch from branches configuration
+ * Returns the branch marked with developmentBranch: true
+ */ const findDevelopmentBranch = (branchesConfig)=>{
+    if (!branchesConfig || typeof branchesConfig !== 'object') {
+        return null;
+    }
+    for (const [branchName, branchConfig] of Object.entries(branchesConfig)){
+        if (branchConfig && typeof branchConfig === 'object' && branchConfig.developmentBranch === true) {
+            return branchName;
+        }
+    }
+    return null;
+};
+/**
+ * Check if two prerelease versions have the same tag
+ * Examples:
+ * - haveSamePrereleaseTag("1.2.3-dev.0", "1.2.3-dev.5") => true
+ * - haveSamePrereleaseTag("1.2.3-dev.0", "1.2.3-test.0") => false
+ * - haveSamePrereleaseTag("1.2.3", "1.2.3-dev.0") => false
+ */ const haveSamePrereleaseTag = (version1, version2)=>{
+    const extractTag = (version)=>{
+        const cleanVersion = version.startsWith('v') ? version.slice(1) : version;
+        const parts = cleanVersion.split('.');
+        if (parts.length < 3) return null;
+        const patchAndPrerelease = parts.slice(2).join('.');
+        const patchComponents = patchAndPrerelease.split('-');
+        if (patchComponents.length > 1) {
+            const prereleaseString = patchComponents.slice(1).join('-');
+            const prereleaseComponents = prereleaseString.split('.');
+            return prereleaseComponents[0] || null;
+        }
+        return null;
+    };
+    const tag1 = extractTag(version1);
+    const tag2 = extractTag(version2);
+    return tag1 !== null && tag2 !== null && tag1 === tag2;
+};
+const checkIfTagExists = async (tagName)=>{
+    const { runSecure, validateGitRef } = await import('@grunnverk/git-tools');
+    try {
+        // Validate tag name to prevent injection
+        if (!validateGitRef(tagName)) {
+            throw new Error(`Invalid tag name: ${tagName}`);
+        }
+        const { stdout } = await runSecure('git', [
+            'tag',
+            '-l',
+            tagName
+        ]);
+        return stdout.trim() === tagName;
+    } catch  {
+        // If git command fails, assume tag doesn't exist
+        return false;
+    }
+};
+const confirmVersionInteractively = async (currentVersion, proposedVersion, targetVersionInput)=>{
+    const { getUserChoice, getUserTextInput, requireTTY } = await Promise.resolve().then(() => interactive);
+    const { getLogger } = await Promise.resolve().then(() => logging);
+    requireTTY('Interactive version confirmation requires a terminal.');
+    const logger = getLogger();
+    logger.info(`\nVERSION_CONFIRMATION: Version confirmation required | Current: ${currentVersion} | Proposed: ${proposedVersion}`);
+    logger.info(`VERSION_CURRENT: Current package version | Version: ${currentVersion}`);
+    logger.info(`VERSION_PROPOSED: Proposed new version | Version: ${proposedVersion}`);
+    if (targetVersionInput) {
+        logger.info(`VERSION_TARGET_INPUT: Target version provided | Input: ${targetVersionInput}`);
+    }
+    const choices = [
+        {
+            key: 'c',
+            label: `Confirm ${proposedVersion}`
+        },
+        {
+            key: 'e',
+            label: 'Enter custom version'
+        },
+        {
+            key: 'a',
+            label: 'Abort publish'
+        }
+    ];
+    const choice = await getUserChoice('\n🤔 Confirm the version for this release:', choices);
+    switch(choice){
+        case 'c':
+            return proposedVersion;
+        case 'e':
+            {
+                const customVersion = await getUserTextInput('\n📝 Enter the version number (e.g., "4.30.0"):');
+                if (!validateVersionString(customVersion)) {
+                    throw new Error(`Invalid version format: ${customVersion}. Expected format: "x.y.z"`);
+                }
+                const cleanCustomVersion = customVersion.startsWith('v') ? customVersion.slice(1) : customVersion;
+                logger.info(`VERSION_CUSTOM_SELECTED: Using custom version from user input | Version: ${cleanCustomVersion} | Source: interactive input`);
+                return cleanCustomVersion;
+            }
+        case 'a':
+            throw new Error('Release aborted by user');
+        default:
+            throw new Error(`Unexpected choice: ${choice}`);
+    }
+};
+const getOutputPath = (outputDirectory, filename)=>{
+    return path__default.join(outputDirectory, filename);
+};
+const getTimestampedFilename = (baseName, extension = '.json')=>{
+    const now = new Date();
+    // Format as YYMMdd-HHmm (e.g., 250701-1030)
+    const yy = now.getFullYear().toString().slice(-2);
+    const mm = (now.getMonth() + 1).toString().padStart(2, '0');
+    const dd = now.getDate().toString().padStart(2, '0');
+    const hh = now.getHours().toString().padStart(2, '0');
+    const min = now.getMinutes().toString().padStart(2, '0');
+    const timestamp = `${yy}${mm}${dd}-${hh}${min}`;
+    return `${timestamp}-${baseName}${extension}`;
+};
+const getTimestampedRequestFilename = (baseName)=>{
+    return getTimestampedFilename(baseName, '.request.json');
+};
+const getTimestampedResponseFilename = (baseName)=>{
+    return getTimestampedFilename(baseName, '.response.json');
+};
+const getTimestampedCommitFilename = ()=>{
+    return getTimestampedFilename('commit-message', '.md');
+};
+const getTimestampedReleaseNotesFilename = ()=>{
+    return getTimestampedFilename('release-notes', '.md');
+};
+const getTimestampedAudioFilename = ()=>{
+    return getTimestampedFilename('audio-recording', '.wav');
+};
+const getTimestampedTranscriptFilename = ()=>{
+    return getTimestampedFilename('audio-transcript', '.md');
+};
+const getTimestampedReviewFilename = ()=>{
+    return getTimestampedFilename('review-analysis', '.md');
+};
+const getTimestampedReviewNotesFilename = ()=>{
+    return getTimestampedFilename('review-notes', '.md');
+};
+const getTimestampedArchivedAudioFilename = (originalExtension = '.wav')=>{
+    return getTimestampedFilename('review-audio', originalExtension);
+};
+const getTimestampedArchivedTranscriptFilename = ()=>{
+    return getTimestampedFilename('review-transcript', '.md');
+};
+// archiveAudio function moved to @grunnverk/audio-tools
+/**
+ * Query npm registry for published version of a package
+ * Returns null if package is not published or on error
+ */ const getNpmPublishedVersion = async (packageName)=>{
+    const logger = getLogger();
+    try {
+        const { runSecure } = await import('@grunnverk/git-tools');
+        // Use npm view to get the latest published version
+        // --json flag ensures parseable output
+        const { stdout } = await runSecure('npm', [
+            'view',
+            packageName,
+            'version',
+            '--json'
+        ]);
+        if (!stdout || stdout.trim() === '') {
+            logger.verbose(`Package ${packageName} not found on npm registry`);
+            return null;
+        }
+        // npm view returns just the version string for a single version
+        const version = stdout.trim().replace(/^["']|["']$/g, ''); // Remove quotes if present
+        logger.verbose(`Found ${packageName}@${version} on npm registry`);
+        return version;
+    } catch (error) {
+        // Package not found or network error
+        logger.verbose(`Could not query npm for ${packageName}: ${error.message}`);
+        return null;
+    }
+};
+/**
+ * Check if a package version already exists on npm registry
+ */ const isVersionPublishedOnNpm = async (packageName, version)=>{
+    const logger = getLogger();
+    try {
+        const { runSecure } = await import('@grunnverk/git-tools');
+        // Use npm view to check for specific version
+        const { stdout } = await runSecure('npm', [
+            'view',
+            `${packageName}@${version}`,
+            'version',
+            '--json'
+        ]);
+        if (!stdout || stdout.trim() === '') {
+            logger.verbose(`Version ${packageName}@${version} not found on npm registry`);
+            return false;
+        }
+        logger.verbose(`Version ${packageName}@${version} exists on npm registry`);
+        return true;
+    } catch (error) {
+        // Version not found
+        logger.verbose(`Version ${packageName}@${version} not published: ${error.message}`);
+        return false;
+    }
+};
+/**
+ * Get detailed info about a tag including the version it points to
+ */ const getTagInfo = async (tagName)=>{
+    try {
+        const { runSecure, validateGitRef } = await import('@grunnverk/git-tools');
+        if (!validateGitRef(tagName)) {
+            throw new Error(`Invalid tag name: ${tagName}`);
+        }
+        // Check if tag exists
+        const { stdout: tagList } = await runSecure('git', [
+            'tag',
+            '-l',
+            tagName
+        ]);
+        if (tagList.trim() !== tagName) {
+            return {
+                exists: false
+            };
+        }
+        // Get the commit the tag points to
+        const { stdout: commit } = await runSecure('git', [
+            'rev-list',
+            '-n',
+            '1',
+            tagName
+        ]);
+        // Extract version from tag name (assumes format like v1.2.3 or working/v1.2.3)
+        const versionMatch = tagName.match(/v?(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?)/);
+        const version = versionMatch ? versionMatch[1] : undefined;
+        return {
+            exists: true,
+            commit: commit.trim(),
+            version
+        };
+    } catch  {
+        return null;
+    }
+};
+/**
+ * Check if a version is a development/prerelease version (has prerelease tag)
+ */ const isDevelopmentVersion = (version)=>{
+    // Development versions have prerelease tags: 1.2.3-dev.0, 1.2.3-alpha.1, etc.
+    return version.includes('-');
+};
+/**
+ * Check if a version is a release version (no prerelease tag)
+ */ const isReleaseVersion = (version)=>{
+    // Release versions are X.Y.Z without any suffix
+    return /^\d+\.\d+\.\d+$/.test(version);
+};
+/**
+ * Get expected version pattern for a branch
+ */ const getExpectedVersionPattern = (branchName)=>{
+    // Development/working branches should have prerelease versions
+    const devBranchPatterns = /^(working|development|dev|feature\/|wip\/)/i;
+    if (devBranchPatterns.test(branchName)) {
+        return {
+            pattern: /^\d+\.\d+\.\d+-[a-zA-Z0-9.-]+$/,
+            description: 'X.Y.Z-<tag> (e.g., 1.2.3-dev.0)',
+            isDevelopment: true
+        };
+    }
+    // Main/master/production branches should have release versions
+    const releaseBranchPatterns = /^(main|master|production|release\/)/i;
+    if (releaseBranchPatterns.test(branchName)) {
+        return {
+            pattern: /^\d+\.\d+\.\d+$/,
+            description: 'X.Y.Z (e.g., 1.2.3)',
+            isDevelopment: false
+        };
+    }
+    // For other branches, allow both but prefer release versions
+    return {
+        pattern: /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/,
+        description: 'X.Y.Z or X.Y.Z-<tag>',
+        isDevelopment: false
+    };
+};
+/**
+ * Validate version against branch expectations
+ */ const validateVersionForBranch = (version, branchName)=>{
+    const expected = getExpectedVersionPattern(branchName);
+    if (!expected.pattern.test(version)) {
+        return {
+            valid: false,
+            issue: `Invalid version format for branch '${branchName}'`,
+            fix: `Version should match ${expected.description}`
+        };
+    }
+    const isDevVersion = isDevelopmentVersion(version);
+    // Development branches should have development versions
+    if (expected.isDevelopment && !isDevVersion) {
+        return {
+            valid: false,
+            issue: `Release version on development branch '${branchName}'`,
+            fix: 'Run kodrdriv development to update to development version'
+        };
+    }
+    // Release branches should NOT have development versions
+    if (!expected.isDevelopment && branchName.match(/^(main|master|production|release\/)/) && isDevVersion) {
+        return {
+            valid: false,
+            issue: `Development version on release branch '${branchName}'`,
+            fix: 'Do not commit development versions to release branches'
+        };
+    }
+    return {
+        valid: true
+    };
+};
+
+/**
+ * Generic LLM improvement function that can be configured for different content types
+ *
+ * This is kodrdriv-specific orchestration logic that combines multiple ai-service
+ * primitives into a higher-level workflow.
+ *
+ * @param currentContent The current content to improve
+ * @param runConfig Runtime configuration
+ * @param promptConfig Prompt configuration
+ * @param promptContext Prompt context
+ * @param outputDirectory Output directory for debug files
+ * @param improvementConfig Configuration for this specific improvement type
+ * @returns Promise resolving to the improved content
+ */ async function improveContentWithLLM(currentContent, runConfig, promptConfig, promptContext, outputDirectory, improvementConfig) {
+    const logger = getDryRunLogger(false);
+    logger.info(`INTERACTIVE_LLM_IMPROVING: Requesting LLM to improve content | Content Type: ${improvementConfig.contentType} | Service: AI | Purpose: Enhance quality`);
+    // Create the improved prompt using the provided function
+    const improvedPromptResult = await improvementConfig.createImprovedPrompt(promptConfig, currentContent, promptContext);
+    // Call the LLM with the improved prompt
+    const improvedResponse = await improvementConfig.callLLM(improvedPromptResult, runConfig, outputDirectory);
+    // Process the response if a processor is provided
+    const finalResult = improvementConfig.processResponse ? improvementConfig.processResponse(improvedResponse) : improvedResponse;
+    logger.info(`INTERACTIVE_LLM_IMPROVED: LLM provided improved content | Content Type: ${improvementConfig.contentType} | Status: enhanced`);
+    return finalResult;
+}
+
+const interactive = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    STANDARD_CHOICES,
+    SecureTempFile,
+    cleanupTempFile,
+    createSecureTempFile,
+    editContentInEditor,
+    getLLMFeedbackInEditor,
+    getUserChoice,
+    getUserTextInput,
+    improveContentWithLLM,
+    requireTTY
+}, Symbol.toStringTag, { value: 'Module' }));
+
+/**
+ * Compile stop-context configuration into efficient filter rules
+ */ function compileFilters(config) {
+    var _config_caseSensitive;
+    const filters = [];
+    const replacement = config.replacement || '[REDACTED]';
+    const caseSensitive = (_config_caseSensitive = config.caseSensitive) !== null && _config_caseSensitive !== void 0 ? _config_caseSensitive : false;
+    // Compile literal string filters
+    if (config.strings && config.strings.length > 0) {
+        for (const str of config.strings){
+            filters.push({
+                type: 'string',
+                value: str,
+                replacement,
+                caseSensitive
+            });
+        }
+    }
+    // Compile regex pattern filters
+    if (config.patterns && config.patterns.length > 0) {
+        for (const pattern of config.patterns){
+            try {
+                const flags = pattern.flags || (caseSensitive ? 'g' : 'gi');
+                const regex = new RegExp(pattern.regex, flags);
+                filters.push({
+                    type: 'pattern',
+                    value: regex,
+                    replacement,
+                    caseSensitive
+                });
+            } catch (error) {
+                const logger = getLogger();
+                logger.warn(`STOP_CONTEXT_INVALID_PATTERN: Failed to compile regex pattern | Pattern: ${pattern.regex} | Error: ${error instanceof Error ? error.message : String(error)} | Action: Skipping pattern`);
+            }
+        }
+    }
+    return filters;
+}
+/**
+ * Apply a single filter to text and track matches
+ */ function applyFilter(text, filter, matches) {
+    if (filter.type === 'string') {
+        const searchStr = filter.value;
+        const flags = filter.caseSensitive ? 'g' : 'gi';
+        const regex = new RegExp(escapeRegExp(searchStr), flags);
+        let match;
+        while((match = regex.exec(text)) !== null){
+            matches.push({
+                type: 'string',
+                matched: match[0],
+                position: match.index,
+                replacement: filter.replacement
+            });
+        }
+        return text.replace(regex, filter.replacement);
+    } else {
+        // Pattern filter
+        const regex = filter.value;
+        let match;
+        // Reset regex lastIndex to ensure we start from beginning
+        regex.lastIndex = 0;
+        while((match = regex.exec(text)) !== null){
+            matches.push({
+                type: 'pattern',
+                matched: match[0],
+                position: match.index,
+                replacement: filter.replacement
+            });
+        }
+        // Reset regex lastIndex again before replace
+        regex.lastIndex = 0;
+        return text.replace(regex, filter.replacement);
+    }
+}
+/**
+ * Escape special regex characters in a string
+ */ function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Filter content based on stop-context configuration
+ *
+ * @param text - The text to filter
+ * @param config - The stop-context configuration
+ * @returns FilterResult with filtered text and metadata
+ */ function filterContent(text, config) {
+    const logger = getLogger();
+    // If no config or disabled, return original text
+    if (!config || config.enabled === false) {
+        return {
+            filtered: text,
+            originalLength: text.length,
+            filteredLength: text.length,
+            matchCount: 0,
+            matches: []
+        };
+    }
+    const filters = compileFilters(config);
+    // If no filters configured, return original text
+    if (filters.length === 0) {
+        return {
+            filtered: text,
+            originalLength: text.length,
+            filteredLength: text.length,
+            matchCount: 0,
+            matches: []
+        };
+    }
+    let filtered = text;
+    const allMatches = [];
+    // Apply each filter in sequence
+    for (const filter of filters){
+        filtered = applyFilter(filtered, filter, allMatches);
+    }
+    const result = {
+        filtered,
+        originalLength: text.length,
+        filteredLength: filtered.length,
+        matchCount: allMatches.length,
+        matches: allMatches
+    };
+    // Log warning if filters were applied and warnOnFilter is enabled
+    if (config.warnOnFilter !== false && allMatches.length > 0) {
+        logger.warn(`STOP_CONTEXT_FILTERED: Sensitive content filtered from generated text | Matches: ${allMatches.length} | Original Length: ${text.length} | Filtered Length: ${filtered.length} | Action: Review filtered content`);
+        // Log verbose details if logger level is verbose or debug
+        if (logger.level === 'verbose' || logger.level === 'debug') {
+            logger.verbose('STOP_CONTEXT_DETAILS: Filter details:');
+            const stringMatches = allMatches.filter((m)=>m.type === 'string').length;
+            const patternMatches = allMatches.filter((m)=>m.type === 'pattern').length;
+            logger.verbose(`  - String matches: ${stringMatches}`);
+            logger.verbose(`  - Pattern matches: ${patternMatches}`);
+            logger.verbose(`  - Character change: ${text.length - filtered.length} characters removed`);
+        }
+    }
+    // Warn if too much content was filtered
+    const percentFiltered = (text.length - filtered.length) / text.length * 100;
+    if (percentFiltered > 50) {
+        logger.warn(`STOP_CONTEXT_HIGH_FILTER: High percentage of content filtered | Percentage: ${percentFiltered.toFixed(1)}% | Impact: Generated content may be incomplete | Action: Review stop-context configuration`);
+    }
+    return result;
+}
+/**
+ * Check if stop-context filtering is enabled in config
+ */ function isStopContextEnabled(config) {
+    if (!config) {
+        return false;
+    }
+    const hasFilters = config.strings && config.strings.length > 0 || config.patterns && config.patterns.length > 0;
+    return Boolean(config.enabled !== false && hasFilters);
+}
+
+function _define_property$4(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * File-based lock for cross-process synchronization
+ * Uses atomic file operations to coordinate across multiple Node processes
+ */ class FileLock {
+    /**
+     * Acquire the file lock with exponential backoff retry
+     */ async lock() {
+        let attempts = 0;
+        let currentDelay = this.retryDelay;
+        while(attempts < this.maxRetries){
+            try {
+                // Try to create lock file atomically with 'wx' flag (fails if exists)
+                const lockData = {
+                    pid: process.pid,
+                    timestamp: Date.now(),
+                    hostname: os.hostname()
+                };
+                // Check if lock file exists and is stale
+                if (fs.existsSync(this.lockPath)) {
+                    const lockContent = fs.readFileSync(this.lockPath, 'utf-8');
+                    try {
+                        const existingLock = JSON.parse(lockContent);
+                        const lockAge = Date.now() - existingLock.timestamp;
+                        // If lock is stale, try to remove it
+                        if (lockAge > this.lockTimeout) {
+                            this.logger.debug(`Removing stale lock file (age: ${lockAge}ms, pid: ${existingLock.pid})`);
+                            try {
+                                fs.unlinkSync(this.lockPath);
+                            } catch  {
+                            // Lock might have been removed by another process, continue
+                            }
+                        }
+                    } catch  {
+                        // Invalid lock file, try to remove it
+                        try {
+                            fs.unlinkSync(this.lockPath);
+                        } catch  {
+                        // Ignore errors
+                        }
+                    }
+                }
+                // Try to acquire lock
+                fs.writeFileSync(this.lockPath, JSON.stringify(lockData, null, 2), {
+                    flag: 'wx'
+                });
+                this.lockAcquired = true;
+                if (attempts > 0) {
+                    this.logger.debug(`Acquired file lock after ${attempts} attempts: ${this.lockPath}`);
+                }
+                return;
+            } catch (error) {
+                if (error.code === 'EEXIST') {
+                    // Lock file exists, retry with backoff
+                    attempts++;
+                    if (attempts === 1 || attempts % 10 === 0) {
+                        this.logger.verbose(`Waiting for file lock (attempt ${attempts}/${this.maxRetries}): ${this.lockPath}`);
+                    }
+                    await new Promise((resolve)=>setTimeout(resolve, currentDelay));
+                    // Exponential backoff
+                    currentDelay = Math.min(currentDelay * 1.5, this.maxRetryDelay);
+                } else {
+                    // Unexpected error
+                    throw new Error(`Failed to acquire file lock ${this.lockPath}: ${error.message}`);
+                }
+            }
+        }
+        throw new Error(`Failed to acquire file lock after ${this.maxRetries} attempts: ${this.lockPath}`);
+    }
+    /**
+     * Release the file lock
+     */ unlock() {
+        if (!this.lockAcquired) {
+            return;
+        }
+        try {
+            if (fs.existsSync(this.lockPath)) {
+                fs.unlinkSync(this.lockPath);
+            }
+            this.lockAcquired = false;
+            this.logger.silly(`Released file lock: ${this.lockPath}`);
+        } catch (error) {
+            // Lock file might have been removed by another process or stale lock cleanup
+            this.logger.debug(`Error releasing file lock ${this.lockPath}: ${error.message}`);
+            this.lockAcquired = false;
+        }
+    }
+    /**
+     * Check if this instance currently holds the lock
+     */ isLocked() {
+        return this.lockAcquired;
+    }
+    constructor(lockPath){
+        _define_property$4(this, "lockPath", void 0);
+        _define_property$4(this, "lockAcquired", false);
+        _define_property$4(this, "maxRetries", 100); // Maximum number of lock attempts
+        _define_property$4(this, "retryDelay", 100); // Initial retry delay in ms
+        _define_property$4(this, "maxRetryDelay", 2000); // Maximum retry delay in ms
+        _define_property$4(this, "lockTimeout", 30000); // Consider lock stale after 30 seconds
+        _define_property$4(this, "logger", getLogger());
+        this.lockPath = lockPath;
+    }
+}
+/**
+ * Manages file-based locks for git repositories (cross-process safe)
+ */ class RepositoryFileLockManager {
+    /**
+     * Get or create a file lock for a specific git repository
+     * @param repoPath Path to the git repository root
+     * @returns FileLock for this repository
+     */ getRepositoryLock(repoPath) {
+        const normalizedPath = path.resolve(repoPath);
+        if (!this.locks.has(normalizedPath)) {
+            // Resolve the actual .git directory (handles both regular repos and submodules)
+            const gitDirPath = this.resolveGitDirectory(normalizedPath);
+            const lockPath = path.join(gitDirPath, 'kodrdriv.lock');
+            this.logger.debug(`Creating file lock for repository: ${normalizedPath} at ${lockPath}`);
+            this.locks.set(normalizedPath, new FileLock(lockPath));
+            // Register cleanup handler on first lock creation
+            if (!this.cleanupRegistered) {
+                this.registerCleanupHandlers();
+                this.cleanupRegistered = true;
+            }
+        }
+        return this.locks.get(normalizedPath);
+    }
+    /**
+     * Resolve the actual .git directory path, handling both regular repos and submodules
+     * @param repoPath Path to the repository root
+     * @returns Path to the actual .git directory
+     */ resolveGitDirectory(repoPath) {
+        const gitPath = path.join(repoPath, '.git');
+        try {
+            const stat = fs.statSync(gitPath);
+            if (stat.isDirectory()) {
+                // Regular git repository
+                return gitPath;
+            } else if (stat.isFile()) {
+                // Git submodule - .git is a file with format: gitdir: <path>
+                const gitFileContent = fs.readFileSync(gitPath, 'utf-8').trim();
+                const match = gitFileContent.match(/^gitdir:\s*(.+)$/);
+                if (match && match[1]) {
+                    // Resolve the gitdir path (it's relative to the repo path)
+                    const gitDirPath = path.resolve(repoPath, match[1]);
+                    this.logger.debug(`Resolved submodule gitdir: ${gitDirPath}`);
+                    // Ensure the git directory exists
+                    if (!fs.existsSync(gitDirPath)) {
+                        throw new Error(`Submodule git directory does not exist: ${gitDirPath}`);
+                    }
+                    return gitDirPath;
+                }
+                throw new Error(`Invalid .git file format in ${gitPath}: ${gitFileContent}`);
+            }
+        } catch (error) {
+            // Check if error is from statSync (file doesn't exist)
+            if (error.code === 'ENOENT') {
+                throw new Error(`No .git directory or file found in ${repoPath}`);
+            }
+            throw new Error(`Failed to resolve git directory for ${repoPath}: ${error.message}`);
+        }
+        throw new Error(`No .git directory or file found in ${repoPath}`);
+    }
+    /**
+     * Register cleanup handlers to release locks on process exit
+     */ registerCleanupHandlers() {
+        const cleanup = ()=>{
+            this.destroy();
+        };
+        // Handle various exit scenarios
+        process.on('exit', cleanup);
+        process.on('SIGINT', ()=>{
+            cleanup();
+            process.exit(130); // Standard exit code for SIGINT
+        });
+        process.on('SIGTERM', ()=>{
+            cleanup();
+            process.exit(143); // Standard exit code for SIGTERM
+        });
+        process.on('uncaughtException', (error)=>{
+            this.logger.error('FILELOCK_UNCAUGHT_EXCEPTION: Uncaught exception detected, cleaning up locks | Error: ' + error + ' | Action: Release all locks');
+            cleanup();
+            process.exit(1);
+        });
+    }
+    /**
+     * Execute a git operation with repository-level file locking
+     * @param repoPath Path to the git repository root
+     * @param operation The async operation to execute under lock
+     * @param operationName Optional name for logging
+     * @returns Result of the operation
+     */ async withGitLock(repoPath, operation, operationName) {
+        const lock = this.getRepositoryLock(repoPath);
+        const startWait = Date.now();
+        this.logger.silly(`Acquiring file lock for ${repoPath}${operationName ? ` for: ${operationName}` : ''}`);
+        await lock.lock();
+        const waitTime = Date.now() - startWait;
+        if (waitTime > 100) {
+            this.logger.debug(`Acquired file lock for ${repoPath} after ${waitTime}ms${operationName ? ` for: ${operationName}` : ''}`);
+        }
+        try {
+            return await operation();
+        } finally{
+            lock.unlock();
+        }
+    }
+    /**
+     * Clean up all locks
+     */ destroy() {
+        this.logger.debug(`Cleaning up ${this.locks.size} file lock(s)`);
+        for (const lock of this.locks.values()){
+            lock.unlock();
+        }
+        this.locks.clear();
+    }
+    constructor(){
+        _define_property$4(this, "locks", new Map());
+        _define_property$4(this, "logger", getLogger());
+        _define_property$4(this, "cleanupRegistered", false);
+    }
+}
+
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Manages per-repository locks for git operations (cross-process safe)
+ * Prevents concurrent git operations in the same repository (which cause .git/index.lock conflicts)
+ * while still allowing parallel operations across different repositories
+ *
+ * Uses file-based locks to coordinate across multiple processes (e.g., parallel tree execution)
+ */ class RepositoryMutexManager {
+    /**
+     * Execute a git operation with repository-level locking
+     * @param packagePath Path to the package (will find its git repo root)
+     * @param operation The async operation to execute under lock
+     * @param operationName Optional name for logging
+     * @returns Result of the operation
+     */ async withGitLock(packagePath, operation, operationName) {
+        const repoPath = getGitRepositoryRoot(packagePath);
+        if (!repoPath) {
+            // Not in a git repository, execute without lock
+            this.logger.debug(`No git repository found for ${packagePath}, executing without lock`);
+            return await operation();
+        }
+        return await this.lockManager.withGitLock(repoPath, operation, operationName);
+    }
+    /**
+     * Destroy all locks and clean up resources
+     */ destroy() {
+        this.lockManager.destroy();
+    }
+    constructor(){
+        _define_property$3(this, "lockManager", void 0);
+        _define_property$3(this, "logger", getLogger());
+        this.lockManager = new RepositoryFileLockManager();
+    }
+}
+/**
+ * Find the git repository root for a given path
+ * Walks up the directory tree until it finds a .git directory
+ * @param startPath Starting path (can be a file or directory)
+ * @returns Absolute path to git repository root, or null if not in a git repo
+ */ function getGitRepositoryRoot(startPath) {
+    let currentPath = path.resolve(startPath);
+    // If startPath is a file, start from its directory
+    try {
+        const stats = statSync(currentPath);
+        if (stats.isFile()) {
+            currentPath = path.dirname(currentPath);
+        }
+    } catch  {
+    // If stat fails, assume it's a directory and continue
+    }
+    // First try using git command as it's the most reliable
+    try {
+        const root = execSync('git rev-parse --show-toplevel', {
+            cwd: currentPath,
+            stdio: [
+                'ignore',
+                'pipe',
+                'ignore'
+            ],
+            encoding: 'utf-8'
+        }).trim();
+        return root;
+    } catch  {
+        // Fallback to manual walk-up if git command fails (e.g. git not in path or other issues)
+        const root = path.parse(currentPath).root;
+        while(currentPath !== root){
+            const gitPath = path.join(currentPath, '.git');
+            try {
+                const stats = statSync(gitPath);
+                if (stats.isDirectory() || stats.isFile()) {
+                    // Found .git (can be directory or file for submodules)
+                    return currentPath;
+                }
+            } catch  {
+            // .git doesn't exist at this level, continue up
+            }
+            // Move up one directory
+            const parentPath = path.dirname(currentPath);
+            if (parentPath === currentPath) {
+                break;
+            }
+            currentPath = parentPath;
+        }
+    }
+    return null;
+}
+/**
+ * Check if a path is within a git repository
+ * @param checkPath Path to check
+ * @returns true if path is in a git repository
+ */ function isInGitRepository(checkPath) {
+    // If it's not a directory that exists, it's not in a git repository
+    try {
+        const stats = statSync(checkPath);
+        if (!stats.isDirectory()) {
+            return false;
+        }
+    } catch  {
+        return false;
+    }
+    // Try using git command first
+    try {
+        execSync('git rev-parse --is-inside-work-tree', {
+            cwd: checkPath,
+            stdio: [
+                'ignore',
+                'ignore',
+                'ignore'
+            ]
+        });
+        return true;
+    } catch  {
+        // If git command fails, it's definitely not a git repo according to git
+        return false;
+    }
+}
+/**
+ * Check if two paths are in the same git repository
+ * @param path1 First path
+ * @param path2 Second path
+ * @returns true if both paths are in the same git repository
+ */ function areInSameRepository(path1, path2) {
+    const repo1 = getGitRepositoryRoot(path1);
+    const repo2 = getGitRepositoryRoot(path2);
+    if (!repo1 || !repo2) {
+        return false;
+    }
+    return repo1 === repo2;
+}
+// Global singleton instance
+let globalGitMutexManager = null;
+/**
+ * Get the global git mutex manager instance
+ * Creates one if it doesn't exist
+ */ function getGitMutexManager() {
+    if (!globalGitMutexManager) {
+        globalGitMutexManager = new RepositoryMutexManager();
+    }
+    return globalGitMutexManager;
+}
+/**
+ * Destroy the global git mutex manager
+ * Should be called when shutting down or during cleanup
+ */ function destroyGitMutexManager() {
+    if (globalGitMutexManager) {
+        globalGitMutexManager.destroy();
+        globalGitMutexManager = null;
+    }
+}
+/**
+ * Helper function to wrap git operations with automatic locking
+ * Uses the global git mutex manager
+ *
+ * @example
+ * await runGitWithLock(packagePath, async () => {
+ *     await run('git add package.json');
+ *     await run('git commit -m "Update version"');
+ * }, 'version bump commit');
+ */ async function runGitWithLock(packagePath, operation, operationName) {
+    const manager = getGitMutexManager();
+    return await manager.withGitLock(packagePath, operation, operationName);
+}
+
+/**
+ * Adapter for converting kodrdriv Config to ai-service AIConfig
+ */ /**
+ * Convert kodrdriv Config to AIConfig
+ */ function toAIConfig(config) {
+    return {
+        apiKey: config.openaiApiKey || process.env.OPENAI_API_KEY,
+        model: config.model,
+        reasoning: config.openaiReasoning,
+        commands: {
+            commit: config.commit ? {
+                model: config.commit.model,
+                reasoning: config.commit.openaiReasoning
+            } : undefined,
+            release: config.release ? {
+                model: config.release.model,
+                reasoning: config.release.openaiReasoning
+            } : undefined,
+            review: config.review ? {
+                model: config.review.model,
+                reasoning: config.review.openaiReasoning
+            } : undefined
+        }
+    };
+}
+
+/**
+ * Create a StorageAdapter implementation using kodrdriv Storage
+ *
+ * @param outputDirectory - Directory where output files should be written (default: 'output')
+ */ function createStorageAdapter(outputDirectory = 'output') {
+    const storage = createStorage();
+    return {
+        async writeOutput (fileName, content) {
+            // Ensure output directory exists
+            await storage.ensureDirectory(outputDirectory);
+            // Write file to output directory
+            const filePath = path__default.join(outputDirectory, fileName);
+            await storage.writeFile(filePath, content, 'utf8');
+        },
+        async readTemp (fileName) {
+            return await storage.readFile(fileName, 'utf8');
+        },
+        async writeTemp (fileName, content) {
+            await storage.writeFile(fileName, content, 'utf8');
+        },
+        async readFile (fileName, encoding = 'utf8') {
+            return await storage.readFile(fileName, encoding);
+        }
+    };
+}
+
+/**
+ * Create a Logger implementation using kodrdriv logging
+ */ function createLoggerAdapter(dryRun) {
+    const logger = getDryRunLogger(dryRun);
+    return {
+        info (message, ...meta) {
+            logger.info(message, ...meta);
+        },
+        error (message, ...meta) {
+            logger.error(message, ...meta);
+        },
+        warn (message, ...meta) {
+            logger.warn(message, ...meta);
+        },
+        debug (message, ...meta) {
+            logger.debug(message, ...meta);
+        },
+        // Additional methods required by riotprompt
+        verbose (message, ...meta) {
+            // Use debug for verbose if available, otherwise info
+            if ('verbose' in logger && typeof logger.verbose === 'function') {
+                logger.verbose(message, ...meta);
+            } else {
+                logger.debug(message, ...meta);
+            }
+        },
+        silly (message, ...meta) {
+            // Use debug for silly if available, otherwise skip
+            if ('silly' in logger && typeof logger.silly === 'function') {
+                logger.silly(message, ...meta);
+            } else {
+                logger.debug(message, ...meta);
+            }
+        }
+    };
+}
+
+/**
+ * Kodrdriv-specific validation utilities
+ *
+ * Note: Generic validation functions (validateString, validateNumber, etc.)
+ * are in @grunnverk/shared
+ */ /**
+ * Validates and safely casts data to ReleaseSummary type
+ */ const validateReleaseSummary = (data)=>{
+    if (!data || typeof data !== 'object') {
+        throw new Error('Invalid release summary: not an object');
+    }
+    if (typeof data.title !== 'string') {
+        throw new Error('Invalid release summary: title must be a string');
+    }
+    if (typeof data.body !== 'string') {
+        throw new Error('Invalid release summary: body must be a string');
+    }
+    return data;
+};
+/**
+ * Validates transcription result has required text property
+ */ const validateTranscriptionResult = (data)=>{
+    if (!data || typeof data !== 'object') {
+        throw new Error('Invalid transcription result: not an object');
+    }
+    if (typeof data.text !== 'string') {
+        throw new Error('Invalid transcription result: text property must be a string');
+    }
+    return data;
+};
+/**
+ * Sanitizes and truncates direction parameter for safe use in prompts
+ * @param direction The direction string to sanitize
+ * @param maxLength Maximum length before truncation (default: 2000)
+ * @returns Sanitized and truncated direction string
+ */ const sanitizeDirection = (direction, maxLength = 2000)=>{
+    if (!direction) {
+        return undefined;
+    }
+    // Remove newlines and excessive whitespace to prevent template breakage
+    const sanitized = direction.replace(/\r?\n/g, ' ') // Replace newlines with spaces
+    .replace(/\s+/g, ' ') // Replace multiple whitespace with single space
+    .trim();
+    // Truncate if too long
+    if (sanitized.length > maxLength) {
+        const truncated = sanitized.substring(0, maxLength - 3) + '...';
+        // Log truncation for debugging (only if not in MCP server mode)
+        if (process.env.KODRDRIV_MCP_SERVER !== 'true') {
+            // eslint-disable-next-line no-console
+            console.warn(`Direction truncated from ${sanitized.length} to ${truncated.length} characters`);
+        }
+        return truncated;
+    }
+    return sanitized;
+};
+
+/**
+ * Standardized error handler for all commands
+ */ const handleCommandError = async (error, options)=>{
+    const { logger, command, exitOnError = false } = options;
+    // Handle user cancellation gracefully
+    if (error instanceof UserCancellationError) {
+        logger.info('USER_CANCELLATION: Operation cancelled by user | Reason: ' + error.message + ' | Status: aborted');
+        if (exitOnError) process.exit(0);
+        return;
+    }
+    // Handle known command errors
+    if (error instanceof CommandError) {
+        // Import PullRequestCheckError dynamically to avoid circular imports
+        const { PullRequestCheckError } = await import('@grunnverk/shared');
+        // Special handling for PR check errors since they have detailed recovery instructions
+        if (error instanceof PullRequestCheckError) {
+            // The error has already displayed its detailed recovery instructions
+            // Just show a brief summary here
+            logger.error(`COMMAND_FAILED: Command execution failed | Command: ${command} | Error: ${error.message} | Recovery: See above`);
+            logger.info('ERROR_RECOVERY_INFO: Detailed recovery instructions provided above | Action: Review and follow steps');
+        } else {
+            logger.error(`COMMAND_FAILED: Command execution failed | Command: ${command} | Error: ${error.message}`);
+            if (error.cause && typeof error.cause === 'object' && 'message' in error.cause) {
+                logger.debug(`Caused by: ${error.cause.message}`);
+                if (logger.isDebugEnabled() && 'stack' in error.cause) {
+                    logger.debug(`Stack trace:`, error.cause.stack);
+                }
+            }
+            // Provide recovery suggestions for recoverable errors
+            if (error.recoverable) {
+                logger.info('ERROR_RECOVERABLE: This error is recoverable | Action: Retry operation or adjust configuration | Status: can-retry');
+            }
+        }
+        if (exitOnError) process.exit(1);
+        throw error;
+    }
+    // Handle unexpected errors
+    logger.error(`ERROR_UNEXPECTED: Command encountered unexpected error | Command: ${command} | Error: ${error.message} | Type: unexpected`);
+    if (logger.isDebugEnabled()) {
+        logger.debug(`Stack trace:`, error.stack);
+    }
+    if (exitOnError) process.exit(1);
+    throw error;
+};
+/**
+ * Wrapper for command execution with standardized error handling
+ */ const executeWithErrorHandling = async (command, logger, execution, exitOnError = true)=>{
+    try {
+        return await execution();
+    } catch (error) {
+        await handleCommandError(error, {
+            logger,
+            command,
+            exitOnError
+        });
+        // This line only reached if exitOnError is false
+        throw error;
+    }
+};
+/**
+ * Creates a command result for successful operations
+ */ const createSuccessResult = (data, warnings)=>({
+        success: true,
+        data,
+        warnings
+    });
+/**
+ * Creates a command result for failed operations
+ */ const createErrorResult = (error, warnings)=>({
+        success: false,
+        error,
+        warnings
+    });
+
+/**
+ * Progress tracking for long-running operations
+ *
+ * Provides structured progress updates for MCP integrations
+ */ function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class ProgressTracker {
+    /**
+     * Set the total number of items
+     */ setTotal(total) {
+        this.total = total;
+    }
+    /**
+     * Start a new step
+     */ startStep(stepName) {
+        this.currentStep = stepName;
+    }
+    /**
+     * Complete the current step
+     */ completeStep() {
+        if (this.currentStep) {
+            this.completedSteps.push(this.currentStep);
+            this.current++;
+        }
+    }
+    /**
+     * Set remaining packages
+     */ setRemainingPackages(packages) {
+        this.remainingPackages = packages;
+    }
+    /**
+     * Get current progress
+     */ getProgress() {
+        return {
+            current: this.current,
+            total: this.total,
+            currentStep: this.currentStep,
+            completedSteps: [
+                ...this.completedSteps
+            ],
+            remainingPackages: [
+                ...this.remainingPackages
+            ],
+            percentage: this.total > 0 ? Math.round(this.current / this.total * 100) : 0
+        };
+    }
+    /**
+     * Reset progress
+     */ reset() {
+        this.completedSteps = [];
+        this.currentStep = '';
+        this.current = 0;
+        this.remainingPackages = [];
+    }
+    /**
+     * Create a progress update for a package execution
+     */ static forPackage(packageName, index, total, completedPackages, remainingPackages) {
+        return {
+            current: index,
+            total: total,
+            currentStep: `Processing: ${packageName}`,
+            completedSteps: completedPackages.map((pkg)=>`Completed: ${pkg}`),
+            remainingPackages: remainingPackages,
+            percentage: total > 0 ? Math.round(index / total * 100) : 0
+        };
+    }
+    /**
+     * Create a progress update for a build phase
+     */ static forPhase(phase, completedPhases, totalPhases) {
+        return {
+            current: completedPhases.length,
+            total: totalPhases,
+            currentStep: phase,
+            completedSteps: completedPhases,
+            percentage: totalPhases > 0 ? Math.round(completedPhases.length / totalPhases * 100) : 0
+        };
+    }
+    constructor(total = 0){
+        _define_property$2(this, "completedSteps", []);
+        _define_property$2(this, "currentStep", '');
+        _define_property$2(this, "current", 0);
+        _define_property$2(this, "total", 0);
+        _define_property$2(this, "remainingPackages", []);
+        this.total = total;
+    }
+}
+
+const ConfigSchema = z.object({
+    dryRun: z.boolean().optional(),
+    verbose: z.boolean().optional(),
+    debug: z.boolean().optional(),
+    overrides: z.boolean().optional(),
+    model: z.string().optional(),
+    openaiReasoning: z.enum([
+        'low',
+        'medium',
+        'high'
+    ]).optional(),
+    openaiMaxOutputTokens: z.number().optional(),
+    contextDirectories: z.array(z.string()).optional(),
+    outputDirectory: z.string().optional(),
+    preferencesDirectory: z.string().optional(),
+    commit: z.object({
+        add: z.boolean().optional(),
+        cached: z.boolean().optional(),
+        sendit: z.boolean().optional(),
+        interactive: z.boolean().optional(),
+        amend: z.boolean().optional(),
+        push: z.union([
+            z.boolean(),
+            z.string()
+        ]).optional(),
+        messageLimit: z.number().optional(),
+        context: z.string().optional(),
+        contextFiles: z.array(z.string()).optional(),
+        direction: z.string().optional(),
+        skipFileCheck: z.boolean().optional(),
+        maxDiffBytes: z.number().optional(),
+        model: z.string().optional(),
+        openaiReasoning: z.enum([
+            'low',
+            'medium',
+            'high'
+        ]).optional(),
+        openaiMaxOutputTokens: z.number().optional(),
+        // Agentic options (always enabled)
+        maxAgenticIterations: z.number().optional(),
+        allowCommitSplitting: z.boolean().optional(),
+        autoSplit: z.boolean().optional(),
+        toolTimeout: z.number().optional(),
+        selfReflection: z.boolean().optional()
+    }).optional(),
+    audioCommit: z.object({
+        maxRecordingTime: z.number().optional(),
+        audioDevice: z.string().optional(),
+        file: z.string().optional(),
+        keepTemp: z.boolean().optional(),
+        model: z.string().optional(),
+        openaiReasoning: z.enum([
+            'low',
+            'medium',
+            'high'
+        ]).optional(),
+        openaiMaxOutputTokens: z.number().optional()
+    }).optional(),
+    release: z.object({
+        from: z.string().optional(),
+        to: z.string().optional(),
+        messageLimit: z.number().optional(),
+        context: z.string().optional(),
+        contextFiles: z.array(z.string()).optional(),
+        interactive: z.boolean().optional(),
+        focus: z.string().optional(),
+        maxDiffBytes: z.number().optional(),
+        model: z.string().optional(),
+        openaiReasoning: z.enum([
+            'low',
+            'medium',
+            'high'
+        ]).optional(),
+        openaiMaxOutputTokens: z.number().optional(),
+        noMilestones: z.boolean().optional(),
+        fromMain: z.boolean().optional(),
+        currentBranch: z.string().optional(),
+        version: z.string().optional(),
+        // Agentic options (always enabled)
+        maxAgenticIterations: z.number().optional(),
+        selfReflection: z.boolean().optional()
+    }).optional(),
+    review: z.object({
+        includeCommitHistory: z.boolean().optional(),
+        includeRecentDiffs: z.boolean().optional(),
+        includeReleaseNotes: z.boolean().optional(),
+        includeGithubIssues: z.boolean().optional(),
+        commitHistoryLimit: z.number().optional(),
+        diffHistoryLimit: z.number().optional(),
+        releaseNotesLimit: z.number().optional(),
+        githubIssuesLimit: z.number().optional(),
+        context: z.string().optional(),
+        sendit: z.boolean().optional(),
+        note: z.string().optional(),
+        editorTimeout: z.number().optional(),
+        maxContextErrors: z.number().optional(),
+        model: z.string().optional(),
+        openaiReasoning: z.enum([
+            'low',
+            'medium',
+            'high'
+        ]).optional(),
+        openaiMaxOutputTokens: z.number().optional(),
+        file: z.string().optional(),
+        directory: z.string().optional()
+    }).optional(),
+    audioReview: z.object({
+        includeCommitHistory: z.boolean().optional(),
+        includeRecentDiffs: z.boolean().optional(),
+        includeReleaseNotes: z.boolean().optional(),
+        includeGithubIssues: z.boolean().optional(),
+        commitHistoryLimit: z.number().optional(),
+        diffHistoryLimit: z.number().optional(),
+        releaseNotesLimit: z.number().optional(),
+        githubIssuesLimit: z.number().optional(),
+        context: z.string().optional(),
+        sendit: z.boolean().optional(),
+        maxRecordingTime: z.number().optional(),
+        audioDevice: z.string().optional(),
+        file: z.string().optional(),
+        directory: z.string().optional(),
+        keepTemp: z.boolean().optional(),
+        model: z.string().optional(),
+        openaiReasoning: z.enum([
+            'low',
+            'medium',
+            'high'
+        ]).optional(),
+        openaiMaxOutputTokens: z.number().optional()
+    }).optional(),
+    precommit: z.object({
+        fix: z.boolean().optional()
+    }).optional(),
+    publish: z.object({
+        mergeMethod: z.enum([
+            'merge',
+            'squash',
+            'rebase'
+        ]).optional(),
+        from: z.string().optional(),
+        targetVersion: z.string().optional(),
+        interactive: z.boolean().optional(),
+        skipAlreadyPublished: z.boolean().optional(),
+        forceRepublish: z.boolean().optional(),
+        dependencyUpdatePatterns: z.array(z.string()).optional(),
+        scopedDependencyUpdates: z.array(z.string()).optional(),
+        requiredEnvVars: z.array(z.string()).optional(),
+        linkWorkspacePackages: z.boolean().optional(),
+        unlinkWorkspacePackages: z.boolean().optional(),
+        checksTimeout: z.number().optional(),
+        skipUserConfirmation: z.boolean().optional(),
+        syncTarget: z.boolean().optional(),
+        sendit: z.boolean().optional(),
+        waitForReleaseWorkflows: z.boolean().optional(),
+        releaseWorkflowsTimeout: z.number().optional(),
+        releaseWorkflowNames: z.array(z.string()).optional(),
+        targetBranch: z.string().optional(),
+        noMilestones: z.boolean().optional(),
+        fromMain: z.boolean().optional(),
+        skipPrePublishMerge: z.boolean().optional(),
+        updateDeps: z.string().optional(),
+        agenticPublish: z.boolean().optional(),
+        agenticPublishMaxIterations: z.number().optional(),
+        skipLinkCleanup: z.boolean().optional()
+    }).optional(),
+    branches: z.record(z.string(), z.object({
+        targetBranch: z.string().optional(),
+        developmentBranch: z.boolean().optional(),
+        version: z.object({
+            type: z.enum([
+                'release',
+                'prerelease'
+            ]),
+            increment: z.boolean().optional(),
+            incrementLevel: z.enum([
+                'patch',
+                'minor',
+                'major'
+            ]).optional(),
+            tag: z.string().optional()
+        }).optional()
+    })).optional(),
+    link: z.object({
+        scopeRoots: z.record(z.string(), z.string()).optional(),
+        dryRun: z.boolean().optional(),
+        packageArgument: z.string().optional(),
+        externals: z.array(z.string()).optional()
+    }).optional(),
+    unlink: z.object({
+        scopeRoots: z.record(z.string(), z.string()).optional(),
+        workspaceFile: z.string().optional(),
+        dryRun: z.boolean().optional(),
+        cleanNodeModules: z.boolean().optional(),
+        packageArgument: z.string().optional(),
+        externals: z.array(z.string()).optional()
+    }).optional(),
+    tree: z.object({
+        directories: z.array(z.string()).optional(),
+        exclude: z.array(z.string()).optional(),
+        startFrom: z.string().optional(),
+        stopAt: z.string().optional(),
+        cmd: z.string().optional(),
+        builtInCommand: z.string().optional(),
+        continue: z.boolean().optional(),
+        status: z.boolean().optional(),
+        promote: z.string().optional(),
+        packageArgument: z.string().optional(),
+        cleanNodeModules: z.boolean().optional(),
+        externals: z.array(z.string()).optional(),
+        fix: z.boolean().optional(),
+        // Parallel execution options
+        parallel: z.boolean().optional(),
+        maxConcurrency: z.number().optional(),
+        retry: z.object({
+            maxAttempts: z.number().optional(),
+            initialDelayMs: z.number().optional(),
+            maxDelayMs: z.number().optional(),
+            backoffMultiplier: z.number().optional(),
+            retriableErrors: z.array(z.string()).optional()
+        }).optional(),
+        recovery: z.object({
+            checkpointInterval: z.enum([
+                'package',
+                'batch'
+            ]).optional(),
+            autoRetry: z.boolean().optional(),
+            continueOnError: z.boolean().optional()
+        }).optional(),
+        monitoring: z.object({
+            showProgress: z.boolean().optional(),
+            showMetrics: z.boolean().optional(),
+            logLevel: z.enum([
+                'minimal',
+                'normal',
+                'verbose'
+            ]).optional()
+        }).optional(),
+        // Recovery options
+        markCompleted: z.array(z.string()).optional(),
+        skipPackages: z.array(z.string()).optional(),
+        retryFailed: z.boolean().optional(),
+        skipFailed: z.boolean().optional(),
+        resetPackage: z.string().optional(),
+        statusParallel: z.boolean().optional(),
+        auditBranches: z.boolean().optional(),
+        validateState: z.boolean().optional(),
+        order: z.boolean().optional()
+    }).optional(),
+    development: z.object({
+        targetVersion: z.string().optional(),
+        noMilestones: z.boolean().optional(),
+        tagWorkingBranch: z.boolean().optional(),
+        createRetroactiveTags: z.boolean().optional(),
+        workingTagPrefix: z.string().optional()
+    }).optional(),
+    versions: z.object({
+        subcommand: z.string().optional(),
+        directories: z.array(z.string()).optional()
+    }).optional(),
+    updates: z.object({
+        scope: z.string().optional(),
+        scopes: z.array(z.string()).optional(),
+        directories: z.array(z.string()).optional(),
+        interProject: z.boolean().optional(),
+        report: z.boolean().optional(),
+        analyze: z.boolean().optional(),
+        strategy: z.enum([
+            'latest',
+            'conservative',
+            'compatible'
+        ]).optional()
+    }).optional(),
+    pull: z.object({
+        remote: z.string().optional(),
+        branch: z.string().optional(),
+        autoStash: z.boolean().optional(),
+        autoResolve: z.boolean().optional()
+    }).optional(),
+    excludedPatterns: z.array(z.string()).optional(),
+    traits: z.any().optional(),
+    stopContext: z.object({
+        enabled: z.boolean().optional(),
+        strings: z.array(z.string()).optional(),
+        patterns: z.array(z.object({
+            regex: z.string(),
+            flags: z.string().optional(),
+            description: z.string().optional()
+        })).optional(),
+        caseSensitive: z.boolean().optional(),
+        replacement: z.string().optional(),
+        warnOnFilter: z.boolean().optional()
+    }).optional()
+});
+const SecureConfigSchema = z.object({
+    openaiApiKey: z.string().optional()
+});
+const CommandConfigSchema = z.object({
+    commandName: z.string().optional()
+});
+
+/**
+ * Structured error types for kodrdriv operations
+ *
+ * These errors provide detailed context for MCP integrations and AI agents
+ * to understand failures and provide actionable recovery steps.
+ */ function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Base error class for all kodrdriv operations
+ */ class KodrdrivError extends Error {
+    constructor(message, context, recoverable = true){
+        super(message), _define_property$1(this, "context", void 0), _define_property$1(this, "recoverable", void 0), this.context = context, this.recoverable = recoverable;
+        this.name = 'KodrdrivError';
+        // Capture stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+/**
+ * Error specific to publish operations
+ */ class PublishError extends KodrdrivError {
+    constructor(message, context){
+        super(message, {
+            ...context,
+            operation: 'publish'
+        });
+        this.name = 'PublishError';
+    }
+}
+/**
+ * Error specific to tree operations (monorepo orchestration)
+ */ class TreeExecutionError extends KodrdrivError {
+    constructor(message, context, failedPackages = [], completedPackages = [], checkpointPath){
+        super(message, {
+            ...context,
+            operation: 'tree'
+        }), _define_property$1(this, "failedPackages", void 0), _define_property$1(this, "completedPackages", void 0), _define_property$1(this, "checkpointPath", void 0), this.failedPackages = failedPackages, this.completedPackages = completedPackages, this.checkpointPath = checkpointPath;
+        this.name = 'TreeExecutionError';
+    }
+}
+/**
+ * Error for validation failures (pre-flight checks)
+ */ class ValidationError extends KodrdrivError {
+    constructor(message, context, validationErrors = [], validationWarnings = []){
+        super(message, {
+            ...context,
+            operation: 'validation'
+        }, false), _define_property$1(this, "validationErrors", void 0), _define_property$1(this, "validationWarnings", void 0), this.validationErrors = validationErrors, this.validationWarnings = validationWarnings;
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * Error for workspace structure issues
+ */ class WorkspaceError extends KodrdrivError {
+    constructor(message, context, expectedStructure){
+        super(message, {
+            ...context,
+            operation: 'workspace'
+        }, false), _define_property$1(this, "expectedStructure", void 0), this.expectedStructure = expectedStructure;
+        this.name = 'WorkspaceError';
+    }
+}
+/**
+ * Format error for MCP tool responses
+ */ function formatErrorForMCP(error) {
+    // Handle TreeExecutionError
+    if (error instanceof TreeExecutionError) {
+        const recovery = [];
+        if (error.failedPackages.length > 0) {
+            recovery.push(`Fix the issue in: ${error.failedPackages.join(', ')}`);
+        }
+        if (error.checkpointPath) {
+            recovery.push(`Then resume with: kodrdriv tree_publish --continue`);
+            recovery.push(`Or via MCP: kodrdriv_tree_publish({directory: "...", continue: true})`);
+        }
+        return {
+            message: error.message,
+            context: {
+                ...error.context,
+                failedPackages: error.failedPackages,
+                completedPackages: error.completedPackages,
+                checkpointPath: error.checkpointPath,
+                recoverable: error.recoverable
+            },
+            recovery: recovery.length > 0 ? recovery : undefined
+        };
+    }
+    // Handle ValidationError
+    if (error instanceof ValidationError) {
+        const recovery = [];
+        if (error.validationErrors.length > 0) {
+            recovery.push('Fix the following validation errors:');
+            error.validationErrors.forEach((err, idx)=>{
+                recovery.push(`  ${idx + 1}. ${err.check}: ${err.message}`);
+                if (err.files && err.files.length > 0) {
+                    recovery.push(`     Files: ${err.files.join(', ')}`);
+                }
+            });
+        }
+        return {
+            message: error.message,
+            context: {
+                ...error.context,
+                validationErrors: error.validationErrors,
+                validationWarnings: error.validationWarnings,
+                recoverable: error.recoverable
+            },
+            recovery: recovery.length > 0 ? recovery : undefined
+        };
+    }
+    // Handle PublishError
+    if (error instanceof PublishError) {
+        const recovery = [];
+        if (error.context.phase) {
+            recovery.push(`Failed during: ${error.context.phase}`);
+        }
+        if (error.context.files && error.context.files.length > 0) {
+            recovery.push(`Check these files: ${error.context.files.join(', ')}`);
+        }
+        if (error.context.command) {
+            recovery.push(`Failed command: ${error.context.command}`);
+            if (error.context.exitCode) {
+                recovery.push(`Exit code: ${error.context.exitCode}`);
+            }
+        }
+        return {
+            message: error.message,
+            context: {
+                ...error.context,
+                recoverable: error.recoverable
+            },
+            recovery: recovery.length > 0 ? recovery : undefined
+        };
+    }
+    // Handle WorkspaceError
+    if (error instanceof WorkspaceError) {
+        const recovery = [];
+        if (error.expectedStructure) {
+            recovery.push(`Expected structure: ${error.expectedStructure}`);
+        }
+        if (error.context.files && error.context.files.length > 0) {
+            recovery.push(`Missing or invalid files: ${error.context.files.join(', ')}`);
+        }
+        return {
+            message: error.message,
+            context: {
+                ...error.context,
+                expectedStructure: error.expectedStructure,
+                recoverable: error.recoverable
+            },
+            recovery: recovery.length > 0 ? recovery : undefined
+        };
+    }
+    // Handle generic KodrdrivError
+    if (error instanceof KodrdrivError) {
+        return {
+            message: error.message,
+            context: {
+                ...error.context,
+                recoverable: error.recoverable
+            }
+        };
+    }
+    // Handle generic Error
+    return {
+        message: error.message || 'Unknown error occurred',
+        context: {
+            name: error.name,
+            stack: error.stack
+        }
+    };
+}
+/**
+ * Extract error details from command execution errors
+ */ function extractCommandErrorDetails(error) {
+    const context = {};
+    // Extract stdout/stderr from various error formats
+    if (error.stdout) {
+        context.stdout = typeof error.stdout === 'string' ? error.stdout : String(error.stdout);
+    }
+    if (error.stderr) {
+        context.stderr = typeof error.stderr === 'string' ? error.stderr : String(error.stderr);
+    }
+    // Extract exit code
+    if (error.code !== undefined) {
+        context.exitCode = error.code;
+    } else if (error.exitCode !== undefined) {
+        context.exitCode = error.exitCode;
+    }
+    // Extract command if available
+    if (error.cmd) {
+        context.command = error.cmd;
+    } else if (error.command) {
+        context.command = error.command;
+    }
+    return context;
+}
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class TransactionLog {
+    /**
+     * Record an operation with its rollback function
+     */ async record(type, details, rollback) {
+        this.operations.push({
+            type,
+            timestamp: new Date(),
+            details,
+            rollback
+        });
+        this.logger.debug(`TRANSACTION_RECORDED: ${type} | Details: ${JSON.stringify(details)}`);
+    }
+    /**
+     * Roll back all operations in reverse order
+     */ async rollbackAll() {
+        this.logger.info('TRANSACTION_ROLLBACK_STARTING: Rolling back operations | Count: ' + this.operations.length);
+        const errors = [];
+        // Rollback in reverse order (LIFO)
+        for(let i = this.operations.length - 1; i >= 0; i--){
+            const op = this.operations[i];
+            try {
+                this.logger.info(`TRANSACTION_ROLLBACK: Rolling back ${op.type} | Timestamp: ${op.timestamp.toISOString()}`);
+                await op.rollback();
+                this.logger.info(`TRANSACTION_ROLLBACK_SUCCESS: ${op.type} rolled back successfully`);
+            } catch (error) {
+                this.logger.error(`TRANSACTION_ROLLBACK_FAILED: Failed to rollback ${op.type} | Error: ${error.message}`);
+                errors.push(error);
+            // Continue rolling back other operations even if one fails
+            }
+        }
+        if (errors.length > 0) {
+            this.logger.error(`TRANSACTION_ROLLBACK_PARTIAL: ${errors.length} rollback operation(s) failed`);
+            throw new Error(`Rollback completed with ${errors.length} error(s). See logs for details.`);
+        }
+        this.logger.info('TRANSACTION_ROLLBACK_COMPLETE: All operations rolled back successfully');
+        this.operations = [];
+    }
+    /**
+     * Clear the transaction log without rolling back
+     */ clear() {
+        this.operations = [];
+        this.logger.debug('TRANSACTION_LOG_CLEARED: Transaction log cleared');
+    }
+    /**
+     * Get the number of recorded operations
+     */ get count() {
+        return this.operations.length;
+    }
+    /**
+     * Get all operations
+     */ getOperations() {
+        return [
+            ...this.operations
+        ];
+    }
+    /**
+     * Check if there are any recorded operations
+     */ hasOperations() {
+        return this.operations.length > 0;
+    }
+    constructor(){
+        _define_property(this, "operations", []);
+        _define_property(this, "logger", getLogger());
+    }
+}
+/**
+ * Create a no-op rollback function for operations that can't be rolled back
+ */ function noopRollback() {
+    return Promise.resolve();
+}
+/**
+ * Helper to create a file restore rollback
+ */ function createFileRestoreRollback(filePath, originalContent) {
+    return async ()=>{
+        const { createStorage } = await import('@grunnverk/shared');
+        const storage = createStorage();
+        await storage.writeFile(filePath, originalContent, 'utf-8');
+    };
+}
+/**
+ * Helper to create a git command rollback
+ */ function createGitRollback(command) {
+    return async ()=>{
+        const { run } = await import('@grunnverk/git-tools');
+        await run(command);
+    };
+}
+
+export { ALLOWED_COMMANDS, COMMAND_AUDIO_COMMIT, COMMAND_AUDIO_REVIEW, COMMAND_CHECK_CONFIG, COMMAND_CLEAN, COMMAND_COMMIT, COMMAND_DEVELOPMENT, COMMAND_INIT_CONFIG, COMMAND_LINK, COMMAND_PRECOMMIT, COMMAND_PUBLISH, COMMAND_RELEASE, COMMAND_REVIEW, COMMAND_SELECT_AUDIO, COMMAND_TREE, COMMAND_UNLINK, COMMAND_UPDATES, COMMAND_VERSIONS, CommandConfigSchema, ConfigSchema, DATE_FORMAT_DAY, DATE_FORMAT_HOURS, DATE_FORMAT_MILLISECONDS, DATE_FORMAT_MINUTES, DATE_FORMAT_MONTH, DATE_FORMAT_MONTH_DAY, DATE_FORMAT_SECONDS, DATE_FORMAT_SHORT_TIMESTAMP, DATE_FORMAT_YEAR, DATE_FORMAT_YEAR_MONTH, DATE_FORMAT_YEAR_MONTH_DAY, DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES, DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS, DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS, DATE_FORMAT_YEAR_MONTH_DAY_SLASH, DEFAULT_ADD, DEFAULT_AMEND_MODE, DEFAULT_BINARY_TO_TEXT_ENCODING, DEFAULT_CACHED, DEFAULT_CHARACTER_ENCODING, DEFAULT_COMMAND, DEFAULT_CONFIG_DIR, DEFAULT_CONTEXT_DIRECTORIES, DEFAULT_DEBUG, DEFAULT_DIFF, DEFAULT_DIRECTORY_PREFIX, DEFAULT_DRY_RUN, DEFAULT_EXCLUDED_PATTERNS, DEFAULT_FROM_COMMIT_ALIAS, DEFAULT_GIT_COMMAND_MAX_BUFFER, DEFAULT_IGNORE_PATTERNS, DEFAULT_INSTRUCTIONS_COMMIT_FILE, DEFAULT_INSTRUCTIONS_DIR, DEFAULT_INSTRUCTIONS_MAP, DEFAULT_INSTRUCTIONS_RELEASE_FILE, DEFAULT_INSTRUCTIONS_REVIEW_FILE, DEFAULT_INTERACTIVE_MODE, DEFAULT_LOG, DEFAULT_MAX_DIFF_BYTES, DEFAULT_MERGE_METHOD, DEFAULT_MESSAGE_LIMIT, DEFAULT_MODEL, DEFAULT_MODEL_STRONG, DEFAULT_OPENAI_MAX_OUTPUT_TOKENS, DEFAULT_OPENAI_REASONING, DEFAULT_OUTPUT_DIRECTORY, DEFAULT_OVERRIDES, DEFAULT_PATH_SEPARATOR, DEFAULT_PERSONA_DIR, DEFAULT_PERSONA_MAP, DEFAULT_PERSONA_RELEASER_FILE, DEFAULT_PERSONA_YOU_FILE, DEFAULT_PREFERENCES_DIRECTORY, DEFAULT_SENDIT_MODE, DEFAULT_TO_COMMIT_ALIAS, DEFAULT_VERBOSE, diff as Diff, FileLock, files as Files, INTERNAL_DATETIME_FORMAT, INTERNAL_DEFAULT_OUTPUT_FILE, KODRDRIV_DEFAULTS, KodrdrivError, log as Log, PROGRAM_NAME, ProgressTracker, PublishError, RepositoryFileLockManager, RepositoryMutexManager, SecureConfigSchema, TransactionLog, TreeExecutionError, VERSION, ValidationError, WorkspaceError, areInSameRepository, calculateBranchDependentVersion, checkIfTagExists, confirmVersionInteractively, createErrorResult, createFileRestoreRollback, createGitRollback, createLoggerAdapter, createStorageAdapter, createSuccessResult, destroyGitMutexManager, executeWithErrorHandling, extractCommandErrorDetails, filterContent, findDevelopmentBranch, formatErrorForMCP, getDryRunLogger, getExpectedVersionPattern, getGitMutexManager, getGitRepositoryRoot, getLogger, getNpmPublishedVersion, getOutputPath, getTagInfo, getTimestampedArchivedAudioFilename, getTimestampedArchivedTranscriptFilename, getTimestampedAudioFilename, getTimestampedCommitFilename, getTimestampedFilename, getTimestampedReleaseNotesFilename, getTimestampedRequestFilename, getTimestampedResponseFilename, getTimestampedReviewFilename, getTimestampedReviewNotesFilename, getTimestampedTranscriptFilename, getVersionFromBranch, handleCommandError, haveSamePrereleaseTag, improveContentWithLLM, isDevelopmentVersion, isInGitRepository, isReleaseVersion, isStopContextEnabled, isVersionPublishedOnNpm, noopRollback, runGitWithLock, sanitizeDirection, setLogLevel, toAIConfig, validateReleaseSummary, validateTranscriptionResult, validateVersionForBranch };
+//# sourceMappingURL=index.js.map