@syrin/cli 1.3.1 → 1.4.0

package/dist/presentation/config-ui.js

@@ -0,0 +1,139 @@
+/**
+ * Presentation layer for config command UI.
+ * Separates display logic from business logic.
+ */
+import { log } from '../utils/logger.js';
+import { Icons } from '../constants/index.js';
+import { getGlobalConfigPath } from '../config/global-loader.js';
+/**
+ * Mask an API key to show only first 4 and last 4 characters.
+ */
+function maskApiKey(apiKey) {
+    if (!apiKey || apiKey.length <= 8) {
+        return '****';
+    }
+    // If it looks like an env var reference (e.g., OPENAI_API_KEY), don't mask
+    if (/^[A-Z][A-Z0-9_]*$/.test(apiKey)) {
+        return apiKey;
+    }
+    return `${apiKey.slice(0, 4)}...${apiKey.slice(-4)}`;
+}
+/**
+ * Display configuration list/show output.
+ */
+export function displayConfigList(config, context, configPath) {
+    log.blank();
+    log.heading(`${context === 'local' ? 'Local' : 'Global'} Configuration`);
+    log.blank();
+    log.labelValue(`${Icons.FOLDER} Path`, configPath);
+    log.blank();
+    if (context === 'local' && 'transport' in config) {
+        log.heading('Project Settings');
+        log.labelValue('  project_name', String(config.project_name));
+        log.labelValue('  agent_name', String(config.agent_name));
+        log.labelValue('  transport', config.transport);
+        if (config.mcp_url) {
+            log.labelValue('  mcp_url', String(config.mcp_url));
+        }
+        if (config.script) {
+            log.labelValue('  script', String(config.script));
+        }
+        log.blank();
+    }
+    log.heading('LLM Providers');
+    const providers = Object.entries(config.llm);
+    if (providers.length === 0) {
+        log.plain('  No providers configured');
+    }
+    else {
+        for (const [provider, settings] of providers) {
+            const isDefault = settings.default || false;
+            const defaultMarker = isDefault ? ' (default)' : '';
+            log.label(`  ${provider}${defaultMarker}`);
+            if (settings.API_KEY) {
+                log.labelValue('    API_KEY', maskApiKey(String(settings.API_KEY)));
+            }
+            if (settings.MODEL_NAME) {
+                log.labelValue('    MODEL_NAME', String(settings.MODEL_NAME));
+            }
+        }
+    }
+    log.blank();
+}
+/**
+ * Display success message for config update.
+ */
+export function displayConfigUpdated(key, value, context, configPath) {
+    log.blank();
+    log.success(`${Icons.CHECK} Configuration updated successfully`);
+    log.blank();
+    log.labelValue('  Key', key);
+    log.labelValue('  Value', value);
+    log.labelValue('  Config', `${context} (${configPath})`);
+    log.blank();
+}
+/**
+ * Display message for opening editor.
+ */
+export function displayEditorOpening(context, filePath, editorName) {
+    log.blank();
+    log.info(`Opening ${context} config in editor...`);
+    log.labelValue(`  ${Icons.FOLDER} File`, filePath);
+    log.labelValue(`  ${Icons.DOCUMENT} Editor`, editorName);
+    log.blank();
+}
+/**
+ * Display message after editor closes.
+ */
+export function displayEditorClosed(fileType) {
+    log.blank();
+    if (fileType === 'config') {
+        log.success(`Config file updated`);
+        log.blank();
+        log.info(`Run \`syrin doctor\` to validate your changes`);
+    }
+    else {
+        log.success(`${Icons.CHECK} Environment file updated`);
+    }
+    log.blank();
+}
+/**
+ * Display setup completion message.
+ */
+export function displaySetupComplete(isGlobal) {
+    log.blank();
+    if (isGlobal) {
+        log.success(`${Icons.CHECK} Global configuration created`);
+        log.blank();
+        log.labelValue(`  ${Icons.FOLDER} Config`, getGlobalConfigPath());
+        log.blank();
+        log.info(`${Icons.DOCUMENT} Next steps:`);
+        log.plain('  1. Set your API keys in ~/.syrin/.env or as environment variables');
+        log.plain('  2. Run `syrin config edit-env --global` to edit the environment file');
+        log.plain('  3. Run `syrin doctor` to validate your setup');
+    }
+    log.blank();
+}
+/**
+ * Display default provider set message.
+ */
+export function displayDefaultProviderSet(provider, context) {
+    log.blank();
+    log.success(`${Icons.CHECK} Default provider updated`);
+    log.blank();
+    log.labelValue('  Provider', provider);
+    log.labelValue('  Config', context);
+    log.blank();
+}
+/**
+ * Display provider removed message.
+ */
+export function displayProviderRemoved(provider, context) {
+    log.blank();
+    log.success(`${Icons.CHECK} Provider removed`);
+    log.blank();
+    log.labelValue('  Provider', provider);
+    log.labelValue('  Config', context);
+    log.blank();
+}
+//# sourceMappingURL=config-ui.js.map

package/dist/presentation/doctor-ui.d.ts

@@ -17,6 +17,9 @@ interface DoctorReport {
         mcp_url?: unknown;
         script?: unknown;
     };
+    configSource?: 'local' | 'global';
+    configPath?: string;
+    envSource?: 'local.env' | 'global.env' | 'process.env';
     transportCheck: CheckResult;
     scriptCheck: CheckResult | null;
     llmChecks: Array<{
@@ -31,6 +34,14 @@ interface DoctorReport {
         modelName?: string;
     }>;
 }
+/**
+ * Display global config validation results.
+ */
+export declare function displayGlobalConfigValidation(globalConfigPath: string, globalEnvPath: string, globalEnvExists: boolean, llmChecks: Array<{
+    provider: string;
+    apiKeyCheck: CheckResult;
+    modelCheck: CheckResult;
+}>): void;
 /**
  * Display doctor report using plain console output.
  * This avoids Ink taking control of stdin, which disables terminal history.

package/dist/presentation/doctor-ui.js

@@ -1,11 +1,49 @@
 import { getVersionDisplayString } from '../utils/version-display.js';
 import { log } from '../utils/logger.js';
+/**
+ * Display global config validation results.
+ */
+export function displayGlobalConfigValidation(globalConfigPath, globalEnvPath, globalEnvExists, llmChecks) {
+    log.blank();
+    log.heading('Validating Syrin configuration...');
+    log.blank();
+    log.label('No local config found at ./syrin.yaml');
+    log.label('Using global configuration...');
+    log.blank();
+    log.labelValue('Global Config:', globalConfigPath);
+    if (globalEnvExists) {
+        log.labelValue('Global Environment:', globalEnvPath);
+    }
+    else {
+        log.labelValue('Global Environment:', `${globalEnvPath} (not found)`);
+    }
+    log.blank();
+    const hasErrors = llmChecks.some(check => !check.apiKeyCheck.isValid || !check.modelCheck.isValid);
+    if (hasErrors) {
+        log.heading('Global configuration has issues:');
+        log.blank();
+        for (const check of llmChecks) {
+            if (!check.apiKeyCheck.isValid) {
+                log.plain(`  • ${check.provider} API Key: ${check.apiKeyCheck.fix || 'Missing'}`);
+            }
+            if (!check.modelCheck.isValid) {
+                log.plain(`  • ${check.provider} Model: ${check.modelCheck.fix || 'Missing'}`);
+            }
+        }
+        log.blank();
+    }
+    else {
+        log.success('Global configuration is valid!');
+        log.label('To create a local config, run: syrin init');
+        log.blank();
+    }
+}
 /**
  * Display doctor report using plain console output.
  * This avoids Ink taking control of stdin, which disables terminal history.
  */
 export async function displayDoctorReport(report) {
-    const { config, transportCheck, scriptCheck, llmChecks, localLlmChecks } = report;
+    const { config, configSource, configPath, envSource, transportCheck, scriptCheck, llmChecks, localLlmChecks, } = report;
     const allValid = transportCheck.isValid &&
         (scriptCheck === null || scriptCheck.isValid) &&
         llmChecks.every(l => l.apiKeyCheck.isValid && l.modelCheck.isValid) &&
@@ -19,6 +57,19 @@ export async function displayDoctorReport(report) {
     log.label('═══════════════════');
     log.labelValue('Version:', versionDisplayString);
     log.blank();
+    // Config Source Info
+    if (configSource && configPath) {
+        log.labelValue(`${configSource === 'local' ? 'Local' : 'Global'} Config:`, configPath);
+        if (envSource) {
+            const envSourceLabel = envSource === 'local.env'
+                ? 'Local project .env file'
+                : envSource === 'global.env'
+                    ? 'Global .env file'
+                    : 'process.env';
+            log.labelValue('Environment Source:', envSourceLabel);
+        }
+        log.blank();
+    }
     // Project Info
     log.labelValue('Project:', String(config.project_name));
     log.labelValue('Agent:', String(config.agent_name));

package/dist/presentation/init-ui.d.ts

@@ -11,4 +11,13 @@ export declare function displayAlreadyInitialized(): void;
  * @param configPath - Path to the created config file
  */
 export declare function displayInitSuccess(configPath: string): void;
+/**
+ * Display the "global already initialized" message.
+ */
+export declare function displayGlobalAlreadyInitialized(): void;
+/**
+ * Display the global initialization success message.
+ * @param configPath - Path to the created global config file
+ */
+export declare function displayGlobalInitSuccess(configPath: string): void;
 //# sourceMappingURL=init-ui.d.ts.map

package/dist/presentation/init-ui.js

@@ -38,4 +38,37 @@ export function displayInitSuccess(configPath) {
     log.plain(`   4. ${Messages.INIT_RUN_DEV(ToolCommands.DEV)}`);
     log.blank();
 }
+/**
+ * Display the "global already initialized" message.
+ */
+export function displayGlobalAlreadyInitialized() {
+    log.blank();
+    log.warning(`  ${Messages.GLOBAL_INIT_ALREADY_INITIALIZED}`);
+    log.blank();
+    log.plain(`${Icons.FOLDER} ${Messages.GLOBAL_INIT_CONFIG_FILE(Paths.GLOBAL_CONFIG_FILE)}`);
+    log.blank();
+    log.plain(`${Icons.DOCUMENT} ${Messages.INIT_NEXT_STEPS_HEADER}`);
+    log.plain(`   ${Messages.GLOBAL_INIT_EDIT_CONFIG}`);
+    log.plain(`   ${Messages.GLOBAL_INIT_EDIT_ENV}`);
+    log.blank();
+    log.info(Messages.GLOBAL_INIT_REINITIALIZE_TIP);
+    log.plain(`   ${Messages.GLOBAL_INIT_REINITIALIZE_INSTRUCTION}`);
+    log.blank();
+}
+/**
+ * Display the global initialization success message.
+ * @param configPath - Path to the created global config file
+ */
+export function displayGlobalInitSuccess(configPath) {
+    log.blank();
+    log.success(`${Icons.CHECK} ${Messages.GLOBAL_INIT_SUCCESS}`);
+    log.blank();
+    log.plain(`${Icons.FOLDER} Configuration file: ${configPath}`);
+    log.blank();
+    log.plain(`${Icons.DOCUMENT} ${Messages.INIT_NEXT_STEPS_HEADER}`);
+    log.plain(`   1. Set your API keys in ~/.syrin/.env or as environment variables`);
+    log.plain(`   2. Run \`syrin config edit-env --global\` to edit the environment file`);
+    log.plain(`   3. ${Messages.INIT_RUN_DOCTOR(ToolCommands.DOCTOR)}`);
+    log.blank();
+}
 //# sourceMappingURL=init-ui.js.map

package/dist/runtime/analysis/analyser.js

@@ -7,7 +7,7 @@ import { normalizeTools } from './normalizer.js';
 import { buildIndexes } from './indexer.js';
 import { inferDependencies } from './dependencies.js';
 import { ALL_RULES } from './rules/index.js';
-import { logger } from '../../utils/logger.js';
+import { log } from '../../utils/logger.js';
 /**
  * Analyze MCP tools and return diagnostics.
  * Executes all registered rules.
@@ -32,7 +32,7 @@ function runRules(tools, dependencies, indexes) {
         }
         catch (error) {
             // If a rule fails, log error but don't crash the analysis
-            logger.error(`Rule ${rule.id} failed`, error instanceof Error ? error : new Error(String(error)), {
+            log.error(`Rule ${rule.id} failed`, error instanceof Error ? error : new Error(String(error)), {
                 ruleId: rule.id,
                 ruleName: rule.ruleName,
             });

package/dist/runtime/analysis/rules/warnings/w104-generic-description.d.ts

@@ -42,7 +42,7 @@ declare class W104GenericDescriptionRule extends BaseRule {
  *
  * @example
  * ```ts
- * import { createW104Rule, DEFAULT_CONCRETE_NOUNS } from './w005-generic-description.js';
+ * import { createW104Rule, DEFAULT_CONCRETE_NOUNS } from './w005-generic-description';
  * const customNouns = [...DEFAULT_CONCRETE_NOUNS, 'invoice', 'report'];
  * const customRule = createW104Rule(customNouns);
  * ```

package/dist/runtime/analysis/rules/warnings/w104-generic-description.js

@@ -96,7 +96,7 @@ class W104GenericDescriptionRule extends BaseRule {
  *
  * @example
  * ```ts
- * import { createW104Rule, DEFAULT_CONCRETE_NOUNS } from './w005-generic-description.js';
+ * import { createW104Rule, DEFAULT_CONCRETE_NOUNS } from './w005-generic-description';
  * const customNouns = [...DEFAULT_CONCRETE_NOUNS, 'invoice', 'report'];
  * const customRule = createW104Rule(customNouns);
  * ```

package/dist/runtime/dev/event-mapper.js

@@ -148,10 +148,26 @@ export class DevEventMapper {
      */
     handleValidationFailed(event) {
         const payload = event.payload;
+        // Format each validation error with better structure
         const errors = payload.validation_errors
-            .map(err => `  - ${err.message} (${err.code})`)
-            .join('\n');
-        this.chatUI.addMessage('system', `❌ Validation failed for **${payload.tool_name}**:\n${errors}`);
+            .map(err => {
+            // If the message contains newlines, it's already formatted with details
+            // Otherwise, format it simply
+            if (err.message.includes('\n')) {
+                // Multi-line error message - format with proper indentation
+                const lines = err.message.split('\n');
+                const firstLine = lines[0];
+                const details = lines
+                    .slice(1)
+                    .map(line => `    ${line}`)
+                    .join('\n');
+                return `  • ${firstLine}\n${details}`;
+            }
+            // Simple error message
+            return `  • ${err.message} (${err.code})`;
+        })
+            .join('\n\n');
+        this.chatUI.addMessage('system', `❌ Validation failed for **${payload.tool_name}**:\n\n${errors}`);
     }
     /**
      * Handle tool execution started event.

package/dist/runtime/dev/session.d.ts

@@ -50,6 +50,10 @@ export declare class DevSession {
      * Validate a tool call.
      */
     private validateToolCall;
+    /**
+     * Format field type information for error messages.
+     */
+    private formatFieldType;
     /**
      * Build prompt after tool execution.
      */

package/dist/runtime/dev/session.js

@@ -5,7 +5,7 @@
 import { SessionLifecycleEventType, LLMContextEventType, LLMProposalEventType, ValidationEventType, } from '../../events/event-type.js';
 import { makePromptID } from '../../types/factories.js';
 import { v4 as uuidv4 } from 'uuid';
-import { logger } from '../../utils/logger.js';
+import { log } from '../../utils/logger.js';
 import { DataManager } from './data-manager.js';
 /**
  * Dev Mode Session implementation.
@@ -216,7 +216,7 @@ you can request the full data if needed.`;
                     reason: `Duplicate tool call detected: ${toolCall.name} with identical arguments was already executed`,
                 });
                 // Use logger instead of console.warn for proper event tracking
-                logger.warn(`Skipping duplicate tool call: ${toolCall.name} with arguments ${normalizedArgs}`);
+                log.warn(`Skipping duplicate tool call: ${toolCall.name} with arguments ${normalizedArgs}`);
                 continue;
             }
             seenKeys.add(key);
@@ -354,7 +354,27 @@ you can request the full data if needed.`;
         if (schema.required) {
             for (const requiredField of schema.required) {
                 if (!(requiredField in toolCall.arguments)) {
-                    const error = `Missing required argument: ${requiredField}`;
+                    // Extract field information from schema
+                    const fieldDef = schema.properties?.[requiredField];
+                    const fieldType = this.formatFieldType(fieldDef);
+                    const fieldDescription = fieldDef?.description;
+                    // Build comprehensive error message
+                    let error = `Missing required field: "${requiredField}"`;
+                    if (fieldType) {
+                        error += `\n  Expected type: ${fieldType}`;
+                    }
+                    if (fieldDescription) {
+                        error += `\n  Description: ${fieldDescription}`;
+                    }
+                    if (fieldDef?.enum) {
+                        const enumValues = fieldDef.enum
+                            .map(v => (typeof v === 'string' ? `"${v}"` : String(v)))
+                            .join(', ');
+                        error += `\n  Allowed values: ${enumValues}`;
+                    }
+                    if (fieldDef?.format) {
+                        error += `\n  Format: ${fieldDef.format}`;
+                    }
                     await this.config.eventEmitter.emit(ValidationEventType.TOOL_CALL_VALIDATION_FAILED, {
                         tool_name: toolCall.name,
                         arguments: toolCall.arguments,
@@ -379,6 +399,35 @@ you can request the full data if needed.`;
         });
         return { valid: true };
     }
+    /**
+     * Format field type information for error messages.
+     */
+    formatFieldType(fieldDef) {
+        if (!fieldDef) {
+            return null;
+        }
+        const type = fieldDef.type;
+        if (!type) {
+            return null;
+        }
+        // Handle array types
+        if (Array.isArray(type)) {
+            return type.join(' | ');
+        }
+        // Handle object type (could be a complex object)
+        if (type === 'object') {
+            return 'object';
+        }
+        // Handle array of items
+        if (type === 'array') {
+            const itemsType = fieldDef.items?.type;
+            if (itemsType) {
+                return `array<${itemsType}>`;
+            }
+            return 'array';
+        }
+        return type;
+    }
     /**
      * Build prompt after tool execution.
      */

package/dist/runtime/llm/ollama.js

@@ -6,7 +6,7 @@ import { Ollama } from 'ollama';
 import * as childProcess from 'child_process';
 import { v4 as uuidv4 } from 'uuid';
 import { ConfigurationError } from '../../utils/errors.js';
-import { logger, log } from '../../utils/logger.js';
+import { log } from '../../utils/logger.js';
 import { checkCommandExists, checkEnvVar } from '../../config/env-checker.js';
 /**
  * Static process manager for Ollama service.
@@ -89,12 +89,12 @@ class OllamaProcessManager {
                 const message = data.toString().trim();
                 // Only log errors, not normal startup messages
                 if (message && /error|fatal|critical/i.test(message)) {
-                    logger.warn(`Ollama: ${message}`);
+                    log.warn(`Ollama: ${message}`);
                 }
             });
             // Handle process errors
             this.ollamaProcess.on('error', (error) => {
-                logger.error('Failed to start Ollama service', error);
+                log.error(`Error: ${error.message}`, error);
                 this.ollamaProcess = null;
                 this.isStarting = false;
                 throw new ConfigurationError(`Failed to start Ollama service: ${error.message}`);
@@ -212,7 +212,7 @@ export class OllamaProvider {
             const modelsResponse = await this.client.list();
             const modelExists = modelsResponse.models?.some((m) => m.name === this.modelName || m.name.startsWith(`${this.modelName}:`)) ?? false;
             if (!modelExists) {
-                logger.info(`Model ${this.modelName} not found. Downloading...`);
+                log.info(`Model ${this.modelName} not found. Downloading...`);
                 log.blank();
                 log.info(`📥 Downloading model: ${this.modelName}`);
                 log.plain('This may take a few minutes depending on your internet connection...');

package/dist/runtime/mcp/client/manager.js

@@ -7,7 +7,7 @@ import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
 import { TransportEventType } from '../../../events/event-type.js';
 import { getConnectedClient } from '../connection.js';
 import { ConfigurationError } from '../../../utils/errors.js';
-import { logger } from '../../../utils/logger.js';
+import { log } from '../../../utils/logger.js';
 import { parseCommand, setupProcessLogCapture, spawnProcess } from './process.js';
 import { BaseMCPClientManager } from './base.js';
 /**
@@ -106,7 +106,7 @@ export class HTTPMCPClientManager extends BaseMCPClientManager {
         catch (error) {
             // Log but don't throw - cleanup errors are non-critical
             const err = error instanceof Error ? error : new Error(String(error));
-            logger.error('Error closing transport during disconnect', err);
+            log.error(`Error: ${err.message}`, err);
             await this.eventEmitter.emit(TransportEventType.TRANSPORT_ERROR, {
                 transport_type: 'http',
                 error_message: err.message,
@@ -213,7 +213,7 @@ export class StdioMCPClientManager extends BaseMCPClientManager {
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
-            logger.error('Error closing transport during disconnect', err);
+            log.error(`Error: ${err.message}`, err);
             await this.emitTransportError(err.message, 'DISCONNECT_ERROR', false);
         }
     }

package/dist/runtime/sandbox/executor.js

@@ -12,7 +12,7 @@ import { parseCommand } from '../../runtime/mcp/client/process.js';
 import { ConfigurationError } from '../../utils/errors.js';
 import { formatTimeString } from './time-parser.js';
 import { ToolExecutionErrorType } from './types.js';
-import { logger } from '../../utils/logger.js';
+import { log } from '../../utils/logger.js';
 // Re-export types for convenience
 export * from './types.js';
 /**
@@ -51,7 +51,7 @@ export class SandboxExecutor {
                 if (isNodeCommand) {
                     // For Node.js: inject --max-old-space-size flag
                     args = ['--max-old-space-size', String(memoryMB), ...args];
-                    logger.debug(`Memory limit: ${memoryMB}MB enforced via --max-old-space-size for Node.js`);
+                    log.debug(`Memory limit: ${memoryMB}MB enforced via --max-old-space-size for Node.js`);
                 }
                 else if (process.platform !== 'win32') {
                     // For POSIX systems: wrap with ulimit -v (virtual memory limit)
@@ -64,12 +64,12 @@ export class SandboxExecutor {
                     executable = '/bin/sh';
                     args = ['-c', `ulimit -v ${memoryKB} && exec ${originalCommand}`];
                     isWrapped = true;
-                    logger.debug(`Memory limit: ${memoryMB}MB (${memoryKB}KB) enforced via ulimit -v`);
+                    log.debug(`Memory limit: ${memoryMB}MB (${memoryKB}KB) enforced via ulimit -v`);
                 }
                 else {
                     // Windows: Memory limits require different approach (SetProcessWorkingSetSize, Job Objects)
                     // For now, log warning that limit is not enforced on Windows
-                    logger.warn(`Memory limit ${memoryMB}MB specified but not enforced on Windows platform`);
+                    log.warn(`Memory limit ${memoryMB}MB specified but not enforced on Windows platform`);
                 }
             }
             // Suppress stderr output if requested (for CI mode)
@@ -137,7 +137,7 @@ export class SandboxExecutor {
                     : typeof event === 'object' && event !== null && 'message' in event
                         ? String(event.message)
                         : 'Unknown MCP client error';
-                logger.error(`MCP client connection error: ${errorMessage}`, event instanceof Error ? event : new Error(errorMessage));
+                log.error(`Error: ${errorMessage}`, event instanceof Error ? event : new Error(errorMessage));
                 // Errors will also be caught in try-catch blocks during tool execution
             };
             // Connect client to server (StdioClientTransport spawns the process here)

package/dist/runtime/test/orchestrator.js

@@ -27,7 +27,7 @@ import { E600UnexpectedTestResult } from '../../runtime/analysis/rules/errors/e6
 // Centralized error code constants - single source of truth for error codes
 import { ERROR_CODES, ERROR_TYPE_TO_CODE, } from '../../runtime/analysis/rules/error-codes.js';
 import { applyStrictMode, computeVerdict, } from '../../runtime/analysis/strict-mode.js';
-import { logger } from '../../utils/logger.js';
+import { log } from '../../utils/logger.js';
 import { ConfigurationError } from '../../utils/errors.js';
 /**
  * Test orchestrator for tool validation.
@@ -158,7 +158,7 @@ export class TestOrchestrator {
             const mcpCommand = this.options.mcpCommand || config.script;
             const scriptName = mcpCommand ? String(mcpCommand) : 'unknown';
             if (!this.options.ci) {
-                logger.warn(`Tool "${toolName}" not found in MCP server. Running: ${scriptName}`);
+                log.warn(`Tool "${toolName}" not found in MCP server. Running: ${scriptName}`);
             }
             // Create a diagnostic error for missing tool using E000 rule
             const diagnostics = E000ToolNotFound.checkWithRuntimeContext({
@@ -190,12 +190,12 @@ export class TestOrchestrator {
             try {
                 toolTimeoutMs = parseTimeString(contract.guarantees.max_execution_time);
                 if (!this.options.ci) {
-                    logger.info(`Tool "${toolName}" declared max_execution_time: ${contract.guarantees.max_execution_time} (${toolTimeoutMs}ms)`);
+                    log.info(`Tool "${toolName}" declared max_execution_time: ${contract.guarantees.max_execution_time} (${toolTimeoutMs}ms)`);
                 }
             }
             catch (_error) {
                 if (!this.options.ci) {
-                    logger.warn(`Invalid max_execution_time for tool "${toolName}": ${contract.guarantees.max_execution_time}. Using global default.`);
+                    log.warn(`Invalid max_execution_time for tool "${toolName}": ${contract.guarantees.max_execution_time}. Using global default.`);
                 }
             }
         }

package/dist/utils/editor.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Editor utility for opening files in system editor.
+ * Supports nano (Unix) and notepad (Windows).
+ */
+/**
+ * Get the appropriate editor command for the current platform.
+ * Checks EDITOR and VISUAL environment variables first, then falls back to platform defaults.
+ * @returns Editor command
+ */
+export declare function getEditor(): string;
+/**
+ * Check file permissions and return security status.
+ * @param filePath - Path to file to check
+ * @returns Permission check result
+ */
+export declare function checkFilePermissions(filePath: string): {
+    isSecure: boolean;
+    currentMode: string;
+    recommendedMode: string;
+};
+/**
+ * Ensure a file exists, creating it with a template if needed.
+ * @param filePath - Path to file
+ * @param template - Template content to use if file doesn't exist
+ * @param secure - Whether to set secure permissions (default: true for .env files)
+ */
+export declare function ensureFileExists(filePath: string, template: string, secure?: boolean): void;
+/**
+ * Open a file in the system editor.
+ * @param filePath - Path to file to open
+ * @param createIfMissing - Whether to create file if it doesn't exist (default: false)
+ * @param template - Template content if creating file (optional)
+ * @returns Promise that resolves when editor closes
+ * @throws {Error} If editor fails to open
+ */
+export declare function openInEditor(filePath: string, createIfMissing?: boolean, template?: string): Promise<void>;
+//# sourceMappingURL=editor.d.ts.map