@phuetz/code-buddy 0.4.0 → 1.0.0

package/dist/openclaw/index.d.ts

@@ -1,7 +1,7 @@
 /**
- * OpenClaw-inspired Modules
+ * Enterprise-grade Modules
  *
- * This module exports all the advanced features inspired by OpenClaw,
+ * This module exports all the advanced features Advanced enterprise architecture for,
  * the most advanced LLM client project on GitHub.
  *
  * Features included:
@@ -23,11 +23,12 @@ export { RetryFallbackEngine, _getRetryFallbackEngine as getRetryFallbackEngine,
 import { SemanticMemorySearch, getSemanticMemorySearch as _getSemanticMemorySearch, resetSemanticMemorySearch as _resetSemanticMemorySearch, searchAndRetrieve, type MemoryEntry, type SearchResult, type SearchOptions, type RetrievalOptions, type RetrievalResult, type MemorySearchConfig } from '../memory/semantic-memory-search.js';
 export { SemanticMemorySearch, _getSemanticMemorySearch as getSemanticMemorySearch, _resetSemanticMemorySearch as resetSemanticMemorySearch, searchAndRetrieve, type MemoryEntry, type SearchResult, type SearchOptions, type RetrievalOptions, type RetrievalResult, type MemorySearchConfig, };
 import { PluginConflictDetector, getPluginConflictDetector as _getPluginConflictDetector, resetPluginConflictDetector as _resetPluginConflictDetector, registerPlugins, type Plugin, type PluginTool, type PluginContext, type PluginToolMeta, type ConflictReport, type ConflictInfo, type AllowlistConfig } from '../plugins/conflict-detection.js';
+export { attachOpenClawGateway, approveOpenClawPendingNode, buildOpenClawNodeDescriptor, buildOpenClawResponsePreview, callOpenClawGatewayWebSocket, discoverOpenClawGateway, getOpenClawGatewayAttachLogPath, getOpenClawGatewayLockfilePath, getOpenClawNodeLockfilePath, getOpenClawResponseSendLogPath, getOpenClawWebSocketCallLogPath, getOpenClawWebSocketProbeLogPath, listOpenClawPendingNodes, mapOpenClawChannelToCodeBuddy, prepareOpenClawFleetHandoffDraft, probeOpenClawGatewayWebSocket, rejectOpenClawPendingNode, sendOpenClawResponse, validateOpenClawUpstreamCompatibility, type OpenClawBridgeOptions, type OpenClawBridgeResponsePreview, type OpenClawFleetDispatchDraftInput, type OpenClawFleetHandoffDraft, type OpenClawGatewayAttachInput, type OpenClawGatewayAttachOptions, type OpenClawGatewayAttachRecord, type OpenClawGatewayAttachResult, type OpenClawGatewayDiscovery, type OpenClawGatewayDiscoveryOptions, type OpenClawGatewayLockfile, type OpenClawHttpTransport, type OpenClawHttpTransportResponse, type OpenClawInboundMessage, type OpenClawNodeLockfile, type OpenClawNodeDescriptor, type OpenClawNodePairingInput, type OpenClawApproveNodeInput, type OpenClawRejectNodeInput, type OpenClawResponseSendInput, type OpenClawResponseSendOptions, type OpenClawResponseSendRecord, type OpenClawResponseSendResult, type OpenClawWebSocketCallInput, type OpenClawWebSocketCallOptions, type OpenClawWebSocketCallRecord, type OpenClawWebSocketCallResult, type OpenClawWebSocketProbeInput, type OpenClawWebSocketProbeOptions, type OpenClawWebSocketProbeRecord, type OpenClawWebSocketProbeResult, type OpenClawUpstreamValidationCheck, type OpenClawUpstreamValidationInput, type OpenClawUpstreamValidationResult, } from './gateway-bridge.js';
 export { PluginConflictDetector, _getPluginConflictDetector as getPluginConflictDetector, _resetPluginConflictDetector as resetPluginConflictDetector, registerPlugins, type Plugin, type PluginTool, type PluginContext, type PluginToolMeta, type ConflictReport, type ConflictInfo, type AllowlistConfig, };
 /**
- * Initialize all OpenClaw modules with default configuration
+ * Initialize all Native Engine modules with default configuration
  */
-export declare function initializeOpenClawModules(config?: {
+export declare function initializeNativeEngineModules(config?: {
     builtInTools?: string[];
     policyHierarchy?: PolicyHierarchy;
     compactionConfig?: CompactionConfig;
@@ -36,6 +37,6 @@ export declare function initializeOpenClawModules(config?: {
     allowlist?: AllowlistConfig;
 }): void;
 /**
- * Reset all OpenClaw module singletons
+ * Reset all Native Engine module singletons
  */
-export declare function resetAllOpenClawModules(): void;
+export declare function resetAllNativeEngineModules(): void;

package/dist/openclaw/index.js

@@ -1,7 +1,7 @@
 /**
- * OpenClaw-inspired Modules
+ * Enterprise-grade Modules
  *
- * This module exports all the advanced features inspired by OpenClaw,
+ * This module exports all the advanced features Advanced enterprise architecture for,
  * the most advanced LLM client project on GitHub.
  *
  * Features included:
@@ -29,11 +29,12 @@ import { SemanticMemorySearch, getSemanticMemorySearch as _getSemanticMemorySear
 export { SemanticMemorySearch, _getSemanticMemorySearch as getSemanticMemorySearch, _resetSemanticMemorySearch as resetSemanticMemorySearch, searchAndRetrieve, };
 // Plugin Conflict Detection
 import { PluginConflictDetector, getPluginConflictDetector as _getPluginConflictDetector, resetPluginConflictDetector as _resetPluginConflictDetector, registerPlugins, } from '../plugins/conflict-detection.js';
+export { attachOpenClawGateway, approveOpenClawPendingNode, buildOpenClawNodeDescriptor, buildOpenClawResponsePreview, callOpenClawGatewayWebSocket, discoverOpenClawGateway, getOpenClawGatewayAttachLogPath, getOpenClawGatewayLockfilePath, getOpenClawNodeLockfilePath, getOpenClawResponseSendLogPath, getOpenClawWebSocketCallLogPath, getOpenClawWebSocketProbeLogPath, listOpenClawPendingNodes, mapOpenClawChannelToCodeBuddy, prepareOpenClawFleetHandoffDraft, probeOpenClawGatewayWebSocket, rejectOpenClawPendingNode, sendOpenClawResponse, validateOpenClawUpstreamCompatibility, } from './gateway-bridge.js';
 export { PluginConflictDetector, _getPluginConflictDetector as getPluginConflictDetector, _resetPluginConflictDetector as resetPluginConflictDetector, registerPlugins, };
 /**
- * Initialize all OpenClaw modules with default configuration
+ * Initialize all Native Engine modules with default configuration
  */
-export function initializeOpenClawModules(config = {}) {
+export function initializeNativeEngineModules(config = {}) {
     // Initialize Tool Policy
     if (config.policyHierarchy) {
         _getToolPolicyEngine(config.policyHierarchy);
@@ -54,9 +55,9 @@ export function initializeOpenClawModules(config = {}) {
     _getPluginConflictDetector(config.builtInTools, config.allowlist);
 }
 /**
- * Reset all OpenClaw module singletons
+ * Reset all Native Engine module singletons
  */
-export function resetAllOpenClawModules() {
+export function resetAllNativeEngineModules() {
     _resetToolPolicyEngine();
     _resetToolLifecycleHooks();
     _resetSmartCompactionEngine();

package/dist/optimization/cache-breakpoints.d.ts

@@ -1,5 +1,5 @@
 /**
- * Prompt Cache Breakpoints — Manus AI / OpenClaw KV-cache optimization
+ * Prompt Cache Breakpoints — Manus AI / Native Engine KV-cache optimization
  *
  * Without explicit breakpoints, Anthropic Claude caching only activates when
  * the entire prompt is identical — which never happens if the time or todos

package/dist/optimization/cache-breakpoints.js

@@ -1,5 +1,5 @@
 /**
- * Prompt Cache Breakpoints — Manus AI / OpenClaw KV-cache optimization
+ * Prompt Cache Breakpoints — Manus AI / Native Engine KV-cache optimization
  *
  * Without explicit breakpoints, Anthropic Claude caching only activates when
  * the entire prompt is identical — which never happens if the time or todos
@@ -40,7 +40,7 @@ const DYNAMIC_MARKERS = [
 export function buildStableDynamicSplit(systemPrompt) {
     const lines = systemPrompt.split('\n');
     for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
+        const line = (lines[i] ?? '').trim();
         if (DYNAMIC_MARKERS.some(re => re.test(line))) {
             return {
                 stablePrefix: lines.slice(0, i).join('\n').trimEnd(),
@@ -69,17 +69,20 @@ export function injectAnthropicCacheBreakpoints(messages) {
     const result = [...messages];
     // Find the last system message index
     let lastSystemIdx = -1;
+    let lastSystemMessage;
     for (let i = result.length - 1; i >= 0; i--) {
-        if (result[i].role === 'system') {
+        const message = result[i];
+        if (message?.role === 'system') {
             lastSystemIdx = i;
+            lastSystemMessage = message;
             break;
         }
     }
-    if (lastSystemIdx === -1)
+    if (lastSystemIdx === -1 || lastSystemMessage === undefined)
         return result;
     // Clone and add cache_control to the last system message
     result[lastSystemIdx] = {
-        ...result[lastSystemIdx],
+        ...lastSystemMessage,
         cache_control: { type: 'ephemeral' },
     };
     return result;

package/dist/optimization/latency-optimizer.js

@@ -95,20 +95,20 @@ export class LatencyOptimizer extends EventEmitter {
         let operation;
         let startTimeStr;
         if (separator === "::") {
-            operation = parts[0];
-            startTimeStr = parts[1];
+            operation = parts[0] ?? "";
+            startTimeStr = parts[1] ?? "";
         }
         else {
             // Old format - find the timestamp (13-digit number)
             const timestampIndex = parts.findIndex(p => /^\d{13}$/.test(p));
             if (timestampIndex === -1) {
                 // Fallback to old behavior for backward compatibility
-                operation = parts[0];
-                startTimeStr = parts[1];
+                operation = parts[0] ?? "";
+                startTimeStr = parts[1] ?? "";
             }
             else {
                 operation = parts.slice(0, timestampIndex).join("-");
-                startTimeStr = parts[timestampIndex];
+                startTimeStr = parts[timestampIndex] ?? "";
             }
         }
         const measurement = this.measurements.find((m) => m.operation === operation && m.startTime.toString() === startTimeStr);
@@ -237,17 +237,14 @@ export class LatencyOptimizer extends EventEmitter {
         const durations = completed.map((m) => m.duration).sort((a, b) => a - b);
         const percentile = (p) => {
             const index = Math.ceil((p / 100) * durations.length) - 1;
-            return durations[Math.max(0, index)];
+            return durations[Math.max(0, index)] ?? 0;
         };
         // Group by operation
         const byOperation = {};
         for (const m of completed) {
-            if (!byOperation[m.operation]) {
-                byOperation[m.operation] = { count: 0, avg: 0, met: 0 };
-            }
-            const op = byOperation[m.operation];
+            const op = (byOperation[m.operation] ??= { count: 0, avg: 0, met: 0 });
             op.count++;
-            op.avg = (op.avg * (op.count - 1) + m.duration) / op.count;
+            op.avg = (op.avg * (op.count - 1) + (m.duration ?? 0)) / op.count;
             if (m.status === "met")
                 op.met++;
         }
@@ -302,6 +299,7 @@ export class LatencyOptimizer extends EventEmitter {
      */
     startPeriodicCleanup() {
         this.cleanupIntervalId = setInterval(() => this.cleanup(), 60000); // Every minute
+        this.cleanupIntervalId.unref?.();
     }
     /**
      * Reset all measurements
@@ -358,9 +356,9 @@ export class StreamingOptimizer {
         const sorted = [...this.firstTokenTimes].sort((a, b) => a - b);
         const percentile = (p) => {
             const index = Math.ceil((p / 100) * sorted.length) - 1;
-            return sorted[Math.max(0, index)];
+            return sorted[Math.max(0, index)] ?? 0;
         };
-        const target = OPERATION_TARGETS.streaming_start;
+        const target = OPERATION_TARGETS.streaming_start ?? LATENCY_THRESHOLDS.ACCEPTABLE;
         const meetingTarget = this.firstTokenTimes.filter((t) => t <= target).length;
         return {
             avgFirstToken: this.firstTokenTimes.reduce((a, b) => a + b, 0) / this.firstTokenTimes.length,

package/dist/optimization/model-routing.js

@@ -218,7 +218,10 @@ export function getCostComparison(tokens) {
     // Sort by cost
     costs.sort((a, b) => a.cost - b.cost);
     // Calculate savings vs most expensive
-    const maxCost = costs[costs.length - 1].cost;
+    const mostExpensive = costs[costs.length - 1];
+    if (mostExpensive === undefined)
+        return [];
+    const maxCost = mostExpensive.cost;
     return costs.map((c) => ({
         ...c,
         savings: c.cost === maxCost

package/dist/orchestration/orchestrator.d.ts

@@ -121,6 +121,11 @@ export declare class Orchestrator extends EventEmitter {
      * Execute loop step
      */
     private executeLoopStep;
+    /**
+     * Execute batch step (parallel map)
+     */
+    private executeBatchStep;
+    private evaluateExpression;
     /**
      * Wait for task completion
      */

package/dist/orchestration/orchestrator.js

@@ -4,7 +4,8 @@
  * Coordinates multiple agents working together on complex tasks.
  */
 import { EventEmitter } from 'events';
-import { safeEvalCondition } from '../sandbox/safe-eval.js';
+import { safeEvalCondition, safeEval } from '../sandbox/safe-eval.js';
+import { logger } from '../utils/logger.js';
 // Default configuration
 const DEFAULT_CONFIG = {
     maxAgents: 10,
@@ -137,7 +138,7 @@ export class Orchestrator extends EventEmitter {
                 return priorityDiff;
             return a.completedTasks - b.completedTasks;
         });
-        return candidates[0];
+        return candidates[0] ?? null;
     }
     // ============================================================================
     // Task Management
@@ -182,8 +183,8 @@ export class Orchestrator extends EventEmitter {
         const priority = PRIORITY_WEIGHTS[task.definition.priority];
         // Find insertion point (sorted by priority descending)
         let insertIdx = 0;
-        for (let i = 0; i < this.taskQueue.length; i++) {
-            const existingPriority = PRIORITY_WEIGHTS[this.taskQueue[i].definition.priority];
+        for (const [i, existing] of this.taskQueue.entries()) {
+            const existingPriority = PRIORITY_WEIGHTS[existing.definition.priority];
             if (priority > existingPriority) {
                 break;
             }
@@ -450,6 +451,9 @@ export class Orchestrator extends EventEmitter {
             case 'loop':
                 await this.executeLoopStep(instance, step, context);
                 break;
+            case 'batch':
+                await this.executeBatchStep(instance, step, context);
+                break;
         }
     }
     /**
@@ -467,10 +471,15 @@ export class Orchestrator extends EventEmitter {
             this.queueTask(task.definition.id);
             // Wait for completion
             await this.waitForTask(task.definition.id);
-            // Add output to context
+            // Add output to context — both under the task's namespaced key and,
+            // optionally, under a user-provided alias for readability in
+            // downstream conditions / tool inputs.
             const completedTask = this.tasks.get(task.definition.id);
             if (completedTask?.output) {
                 context[`task_${task.definition.id}`] = completedTask.output;
+                if (typeof taskDef.aliasAs === 'string' && taskDef.aliasAs.length > 0) {
+                    context[taskDef.aliasAs] = completedTask.output;
+                }
             }
         }
     }
@@ -514,6 +523,12 @@ export class Orchestrator extends EventEmitter {
         while (this.evaluateCondition(step.loopCondition || 'false', context) &&
             iteration < maxIterations) {
             context['iteration'] = iteration;
+            this.emit('loop_iteration_started', {
+                type: 'loop_iteration_started',
+                instanceId: instance.instanceId,
+                stepId: step.id,
+                iteration
+            });
             if (step.loopBody) {
                 for (const bodyStep of step.loopBody) {
                     await this.executeWorkflowStep(instance, bodyStep, context);
@@ -522,6 +537,60 @@ export class Orchestrator extends EventEmitter {
             iteration++;
         }
     }
+    /**
+     * Execute batch step (parallel map)
+     */
+    async executeBatchStep(instance, step, context) {
+        const itemsExpr = step.batchItemsExpression;
+        const varName = step.batchVariableName;
+        const concurrency = step.batchConcurrencyLimit || 5;
+        const body = step.batchBody;
+        if (!itemsExpr || !varName || !body)
+            return;
+        // Evaluate items to get an array
+        const items = this.evaluateExpression(itemsExpr, context);
+        if (!Array.isArray(items)) {
+            logger.warn(`[Orchestrator] Batch items expression did not evaluate to an array: ${itemsExpr}`);
+            return;
+        }
+        const tasks = items.map((item, index) => async () => {
+            // Create local context fork for this batch item execution
+            const localContext = { ...context, [varName]: item, index };
+            this.emit('loop_iteration_started', {
+                type: 'loop_iteration_started',
+                instanceId: instance.instanceId,
+                stepId: step.id,
+                iteration: index
+            });
+            for (const bodyStep of body) {
+                await this.executeWorkflowStep(instance, bodyStep, localContext);
+            }
+        });
+        // Run parallel batches with concurrency limit
+        let taskIdx = 0;
+        const workers = Array(Math.min(concurrency, tasks.length)).fill(null).map(async () => {
+            while (taskIdx < tasks.length) {
+                const myIndex = taskIdx++;
+                const taskFn = tasks[myIndex];
+                if (!taskFn)
+                    continue;
+                await taskFn();
+            }
+        });
+        await Promise.all(workers);
+    }
+    evaluateExpression(expression, context) {
+        let resolved = expression;
+        for (const [key, value] of Object.entries(context)) {
+            resolved = resolved.replace(new RegExp(`\\$${key}`, 'g'), JSON.stringify(value));
+        }
+        try {
+            return safeEval(resolved, { context, timeout: 2000 });
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Wait for task completion
      */

package/dist/orchestration/types.d.ts

@@ -76,6 +76,14 @@ export interface TaskDefinition {
     maxRetries?: number;
     /** Parent task (for subtasks) */
     parentId?: string;
+    /**
+     * Optional alias key under which the orchestrator additionally stores
+     * `task.output` in the workflow context. Without it, the result is
+     * only reachable as `context['task_<id>']`. With it, downstream
+     * conditions and tool inputs can reference `$<aliasAs>` directly,
+     * which is more readable for humans authoring visual workflows.
+     */
+    aliasAs?: string;
 }
 export interface TaskInstance {
     /** Definition */
@@ -123,7 +131,7 @@ export interface WorkflowStep {
     /** Step name */
     name: string;
     /** Step type */
-    type: 'task' | 'parallel' | 'conditional' | 'loop';
+    type: 'task' | 'parallel' | 'conditional' | 'loop' | 'batch';
     /** Task definitions for this step */
     tasks?: TaskDefinition[];
     /** Parallel branches (for parallel type) */
@@ -138,6 +146,14 @@ export interface WorkflowStep {
     loopCondition?: string;
     /** Loop body */
     loopBody?: WorkflowStep[];
+    /** Batch items expression */
+    batchItemsExpression?: string;
+    /** Batch variable name */
+    batchVariableName?: string;
+    /** Batch concurrency limit */
+    batchConcurrencyLimit?: number;
+    /** Batch body */
+    batchBody?: WorkflowStep[];
     /** Dependencies */
     dependsOn?: string[];
 }

package/dist/output/json-schema-output.d.ts

@@ -6,7 +6,7 @@
  * a built-in schema validator (no external deps).
  */
 export interface JsonSchemaConfig {
-    schema: Record<string, any>;
+    schema: Record<string, unknown>;
     strict: boolean;
     extractFromMarkdown: boolean;
 }
@@ -19,7 +19,7 @@ export interface ValidationError {
 export interface ValidationResult {
     valid: boolean;
     errors: ValidationError[];
-    data?: any;
+    data?: unknown;
 }
 export declare class JsonSchemaOutput {
     private config;
@@ -59,9 +59,9 @@ export declare class JsonSchemaOutput {
     /**
      * Format valid output as pretty JSON
      */
-    formatValidOutput(data: any): string;
+    formatValidOutput(data: unknown): string;
     /**
      * Get the schema
      */
-    getSchema(): Record<string, any>;
+    getSchema(): Record<string, unknown>;
 }

package/dist/output/json-schema-output.js

@@ -64,10 +64,11 @@ export class JsonSchemaOutput {
         }
         // Try to find JSON object or array in text
         const jsonMatch = trimmed.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
-        if (jsonMatch) {
+        const candidate = jsonMatch?.[1];
+        if (candidate !== undefined) {
             try {
-                JSON.parse(jsonMatch[1]);
-                return jsonMatch[1];
+                JSON.parse(candidate);
+                return candidate;
             }
             catch {
                 // Not valid JSON
@@ -82,10 +83,12 @@ export class JsonSchemaOutput {
         // Match ```json ... ``` or ``` ... ```
         const codeBlockRegex = /```(?:json)?\s*\n([\s\S]*?)\n```/;
         const match = text.match(codeBlockRegex);
-        if (match) {
+        const block = match?.[1];
+        if (block !== undefined) {
             try {
-                JSON.parse(match[1].trim());
-                return match[1].trim();
+                const trimmed = block.trim();
+                JSON.parse(trimmed);
+                return trimmed;
             }
             catch {
                 // Not valid JSON in code block
@@ -98,13 +101,14 @@ export class JsonSchemaOutput {
      */
     validateSchema(data, schema, path) {
         const errors = [];
+        const schemaType = schema.type;
         // Type check
-        if (schema.type) {
-            if (!this.checkType(data, schema.type)) {
+        if (schemaType) {
+            if (!this.checkType(data, schemaType)) {
                 errors.push({
                     path: path || '$',
-                    message: `Expected type "${schema.type}"`,
-                    expected: schema.type,
+                    message: `Expected type "${schemaType}"`,
+                    expected: schemaType,
                     actual: Array.isArray(data) ? 'array' : typeof data,
                 });
                 return errors; // Can't validate further if type is wrong
@@ -112,20 +116,22 @@ export class JsonSchemaOutput {
         }
         // Enum check
         if (schema.enum) {
-            if (!this.checkEnum(data, schema.enum)) {
+            const enumValues = schema.enum;
+            if (!this.checkEnum(data, enumValues)) {
                 errors.push({
                     path: path || '$',
-                    message: `Value must be one of: ${schema.enum.join(', ')}`,
-                    expected: schema.enum.join(' | '),
+                    message: `Value must be one of: ${enumValues.join(', ')}`,
+                    expected: enumValues.join(' | '),
                     actual: String(data),
                 });
             }
         }
         // Object-specific validations
-        if (schema.type === 'object' && typeof data === 'object' && data !== null && !Array.isArray(data)) {
+        if (schemaType === 'object' && typeof data === 'object' && data !== null && !Array.isArray(data)) {
+            const obj = data;
             // Required fields
             if (schema.required) {
-                const missing = this.checkRequired(data, schema.required);
+                const missing = this.checkRequired(obj, schema.required);
                 for (const field of missing) {
                     errors.push({
                         path: path ? `${path}.${field}` : field,
@@ -136,15 +142,15 @@ export class JsonSchemaOutput {
             // Properties
             if (schema.properties) {
                 for (const [key, propSchema] of Object.entries(schema.properties)) {
-                    if (data[key] !== undefined) {
+                    if (obj[key] !== undefined) {
                         const propPath = path ? `${path}.${key}` : key;
-                        errors.push(...this.validateSchema(data[key], propSchema, propPath));
+                        errors.push(...this.validateSchema(obj[key], propSchema, propPath));
                     }
                 }
             }
         }
         // Array-specific validations
-        if (schema.type === 'array' && Array.isArray(data)) {
+        if (schemaType === 'array' && Array.isArray(data)) {
             if (schema.items) {
                 for (let i = 0; i < data.length; i++) {
                     const itemPath = `${path || '$'}[${i}]`;
@@ -169,7 +175,7 @@ export class JsonSchemaOutput {
             }
         }
         // String-specific validations
-        if (schema.type === 'string' && typeof data === 'string') {
+        if (schemaType === 'string' && typeof data === 'string') {
             if (schema.minLength !== undefined && data.length < schema.minLength) {
                 errors.push({
                     path: path || '$',
@@ -192,7 +198,7 @@ export class JsonSchemaOutput {
             }
         }
         // Number-specific validations
-        if (schema.type === 'number' && typeof data === 'number') {
+        if (schemaType === 'number' && typeof data === 'number') {
             if (schema.minimum !== undefined && data < schema.minimum) {
                 errors.push({
                     path: path || '$',

package/dist/performance/benchmark-suite.js

@@ -88,7 +88,10 @@ export class BenchmarkSuite extends EventEmitter {
             // Warmup runs
             this.emit('phase', { phase: 'warmup', total: this.config.warmupRuns });
             for (let i = 0; i < this.config.warmupRuns; i++) {
-                const prompt = this.config.prompts[i % this.config.prompts.length];
+                const prompts = this.config.prompts;
+                const prompt = prompts[i % prompts.length];
+                if (!prompt)
+                    throw new Error('Benchmark requires at least one prompt');
                 this.emit('warmup', { run: i + 1, total: this.config.warmupRuns });
                 await this.executeRun(prompt, callback, true);
             }
@@ -123,7 +126,10 @@ export class BenchmarkSuite extends EventEmitter {
      */
     async runSequential(callback) {
         for (let i = 0; i < this.config.runs; i++) {
-            const prompt = this.config.prompts[i % this.config.prompts.length];
+            const prompts = this.config.prompts;
+            const prompt = prompts[i % prompts.length];
+            if (!prompt)
+                throw new Error('Benchmark requires at least one prompt');
             this.emit('run', { run: i + 1, total: this.config.runs, prompt: prompt.name });
             const run = await this.executeRun(prompt, callback, false);
             this.runs.push(run);
@@ -141,7 +147,10 @@ export class BenchmarkSuite extends EventEmitter {
             const promises = [];
             for (let i = 0; i < batchSize; i++) {
                 const runIndex = batchStart + i;
-                const prompt = this.config.prompts[runIndex % this.config.prompts.length];
+                const prompts = this.config.prompts;
+                const prompt = prompts[runIndex % prompts.length];
+                if (!prompt)
+                    throw new Error('Benchmark requires at least one prompt');
                 this.emit('run', {
                     run: runIndex + 1,
                     total: this.config.runs,
@@ -282,8 +291,8 @@ export class BenchmarkSuite extends EventEmitter {
         const avgSquaredDiff = squaredDiffs.reduce((a, b) => a + b, 0) / values.length;
         const stdDev = Math.sqrt(avgSquaredDiff);
         return {
-            min: sorted[0],
-            max: sorted[sorted.length - 1],
+            min: sorted[0] ?? 0,
+            max: sorted[sorted.length - 1] ?? 0,
             avg,
             p50: this.percentile(sorted, 50),
             p95: this.percentile(sorted, 95),
@@ -298,11 +307,13 @@ export class BenchmarkSuite extends EventEmitter {
         const index = (p / 100) * (sorted.length - 1);
         const lower = Math.floor(index);
         const upper = Math.ceil(index);
+        const lo = sorted[lower] ?? 0;
+        const hi = sorted[upper] ?? 0;
         if (lower === upper) {
-            return sorted[lower];
+            return lo;
         }
         const weight = index - lower;
-        return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+        return lo * (1 - weight) + hi * weight;
     }
     /**
      * Format results for display

package/dist/persistence/conversation-branches.js

@@ -322,8 +322,7 @@ export class ConversationBranchManager extends EventEmitter {
         const formatNode = (node, indent = "") => {
             const isCurrent = node.branch.id === this.currentBranchId ? " 🟢" : "";
             let result = `${indent}├─ ${node.branch.name} (${node.branch.messages.length} msgs)${isCurrent}\n`;
-            for (let i = 0; i < node.children.length; i++) {
-                const child = node.children[i];
+            for (const [i, child] of node.children.entries()) {
                 const isLast = i === node.children.length - 1;
                 const newIndent = indent + (isLast ? "   " : "│  ");
                 result += formatNode(child, newIndent);

package/dist/persistence/session-export.js

@@ -564,6 +564,9 @@ export class SessionPlayer extends EventEmitter {
                 await this.waitForResume();
             }
             const message = messages[this.currentIndex];
+            if (message === undefined) {
+                break;
+            }
             const prevMessage = messages[this.currentIndex - 1];
             // Calculate delay based on real time difference
             if (opts.speed > 0 && prevMessage) {

package/dist/persistence/session-lock.d.ts

@@ -1,5 +1,5 @@
 /**
- * Session Write Locks (OpenClaw-inspired)
+ * Session Write Locks (Enterprise-grade)
  *
  * PID-based file locks with stale detection for session files.
  * Prevents concurrent writes to the same session from multiple processes.
@@ -16,6 +16,7 @@ export interface LockInfo {
 export declare class SessionLock {
     private lockPath;
     private acquired;
+    private cleanupHandler;
     constructor(sessionFilePath: string);
     /**
      * Attempt to acquire the lock.
@@ -26,6 +27,7 @@ export declare class SessionLock {
      * Release the lock.
      */
     release(): void;
+    private removeProcessCleanupHandlers;
     /**
      * Check if the lock is currently held (by any process).
      */