fss-link 1.0.60 → 1.0.62

package/bundle/fss-link.js

@@ -8321,8 +8321,194 @@ var init_constants = __esm({
   }
 });
 
+// packages/core/dist/src/telemetry/fallback-metrics.js
+var FallbackMetricsCollector, fallbackMetrics;
+var init_fallback_metrics = __esm({
+  "packages/core/dist/src/telemetry/fallback-metrics.js"() {
+    "use strict";
+    FallbackMetricsCollector = class {
+      metrics = {
+        toolCalls: {
+          total: 0,
+          success: 0,
+          failure: 0,
+          byName: {}
+        },
+        tokens: {
+          input: 0,
+          output: 0,
+          cached: 0,
+          thoughts: 0,
+          tool: 0,
+          total: 0,
+          byModel: {}
+        },
+        api: {
+          requests: 0,
+          errors: 0,
+          totalLatencyMs: 0,
+          byModel: {}
+        },
+        files: {
+          operations: 0,
+          linesAdded: 0,
+          linesRemoved: 0
+        },
+        sessions: {
+          started: 0,
+          compressed: 0
+        }
+      };
+      recordToolCall(functionName, durationMs, success, decision) {
+        this.metrics.toolCalls.total++;
+        if (success) {
+          this.metrics.toolCalls.success++;
+        } else {
+          this.metrics.toolCalls.failure++;
+        }
+        if (!this.metrics.toolCalls.byName[functionName]) {
+          this.metrics.toolCalls.byName[functionName] = {
+            count: 0,
+            success: 0,
+            durationMs: 0,
+            decisions: {
+              accept: 0,
+              reject: 0,
+              modify: 0,
+              auto_accept: 0
+            }
+          };
+        }
+        const toolStats = this.metrics.toolCalls.byName[functionName];
+        toolStats.count++;
+        toolStats.durationMs += durationMs;
+        if (success) {
+          toolStats.success++;
+        }
+        if (decision) {
+          toolStats.decisions[decision]++;
+        }
+      }
+      recordTokenUsage(model, tokenCount, type2) {
+        const propName = type2 === "thought" ? "thoughts" : type2 === "cache" ? "cached" : type2;
+        if (propName === "input")
+          this.metrics.tokens.input += tokenCount;
+        else if (propName === "output")
+          this.metrics.tokens.output += tokenCount;
+        else if (propName === "cached")
+          this.metrics.tokens.cached += tokenCount;
+        else if (propName === "thoughts")
+          this.metrics.tokens.thoughts += tokenCount;
+        else if (propName === "tool")
+          this.metrics.tokens.tool += tokenCount;
+        this.metrics.tokens.total += tokenCount;
+        if (!this.metrics.tokens.byModel[model]) {
+          this.metrics.tokens.byModel[model] = {
+            input: 0,
+            output: 0,
+            cached: 0,
+            thoughts: 0,
+            tool: 0
+          };
+        }
+        this.metrics.tokens.byModel[model][propName] += tokenCount;
+      }
+      recordApiResponse(model, durationMs, error = false) {
+        this.metrics.api.requests++;
+        this.metrics.api.totalLatencyMs += durationMs;
+        if (error) {
+          this.metrics.api.errors++;
+        }
+        if (!this.metrics.api.byModel[model]) {
+          this.metrics.api.byModel[model] = {
+            requests: 0,
+            errors: 0,
+            latencyMs: 0
+          };
+        }
+        this.metrics.api.byModel[model].requests++;
+        this.metrics.api.byModel[model].latencyMs += durationMs;
+        if (error) {
+          this.metrics.api.byModel[model].errors++;
+        }
+      }
+      recordFileOperation(diffStat) {
+        this.metrics.files.operations++;
+        if (diffStat) {
+          this.metrics.files.linesAdded += diffStat.ai_added_lines || 0;
+          this.metrics.files.linesRemoved += diffStat.ai_removed_lines || 0;
+        }
+      }
+      recordSession() {
+        this.metrics.sessions.started++;
+      }
+      recordChatCompression() {
+        this.metrics.sessions.compressed++;
+      }
+      getMetrics() {
+        return { ...this.metrics };
+      }
+      // Welcome Back system integration
+      getEfficiencyMetrics() {
+        const toolSuccessRate = this.metrics.toolCalls.total > 0 ? this.metrics.toolCalls.success / this.metrics.toolCalls.total * 100 : 0;
+        const avgToolLatency = this.metrics.toolCalls.total > 0 ? Object.values(this.metrics.toolCalls.byName).reduce((sum, tool) => sum + tool.durationMs, 0) / this.metrics.toolCalls.total : 0;
+        const apiErrorRate = this.metrics.api.requests > 0 ? this.metrics.api.errors / this.metrics.api.requests * 100 : 0;
+        const totalInteractions = this.metrics.toolCalls.total + this.metrics.api.requests;
+        return {
+          toolSuccessRate,
+          avgToolLatency,
+          apiErrorRate,
+          totalInteractions
+        };
+      }
+      getTokenEfficiencyString() {
+        const totalTokens = this.metrics.tokens.total;
+        const totalInteractions = this.metrics.toolCalls.total + this.metrics.api.requests;
+        if (totalTokens === 0)
+          return "No token usage recorded";
+        const tokenStr = totalTokens > 1e3 ? `${Math.round(totalTokens / 1e3)}k tokens` : `${totalTokens} tokens`;
+        return `${tokenStr} \u2192 ${totalInteractions} interactions`;
+      }
+      reset() {
+        this.metrics = {
+          toolCalls: {
+            total: 0,
+            success: 0,
+            failure: 0,
+            byName: {}
+          },
+          tokens: {
+            input: 0,
+            output: 0,
+            cached: 0,
+            thoughts: 0,
+            tool: 0,
+            total: 0,
+            byModel: {}
+          },
+          api: {
+            requests: 0,
+            errors: 0,
+            totalLatencyMs: 0,
+            byModel: {}
+          },
+          files: {
+            operations: 0,
+            linesAdded: 0,
+            linesRemoved: 0
+          },
+          sessions: {
+            started: 0,
+            compressed: 0
+          }
+        };
+      }
+    };
+    fallbackMetrics = new FallbackMetricsCollector();
+  }
+});
+
 // packages/core/dist/src/telemetry/metrics.js
-import { metrics, ValueType } from "@opentelemetry/api";
 function getCommonAttributes(config) {
   return {
     "session.id": config.getSessionId()
@@ -8337,6 +8523,11 @@ function getMeter() {
 function initializeMetrics(config) {
   if (isMetricsInitialized)
     return;
+  if (!openTelemetryAvailable) {
+    fallbackMetrics.recordSession();
+    isMetricsInitialized = true;
+    return;
+  }
   const meter = getMeter();
   if (!meter)
     return;
@@ -8390,6 +8581,10 @@ function initializeMetrics(config) {
   isMetricsInitialized = true;
 }
 function recordChatCompressionMetrics(config, args) {
+  if (!openTelemetryAvailable) {
+    fallbackMetrics.recordChatCompression();
+    return;
+  }
   if (!chatCompressionCounter || !isMetricsInitialized)
     return;
   chatCompressionCounter.add(1, {
@@ -8398,6 +8593,10 @@ function recordChatCompressionMetrics(config, args) {
   });
 }
 function recordToolCallMetrics(config, functionName, durationMs, success, decision, tool_type) {
+  if (!openTelemetryAvailable) {
+    fallbackMetrics.recordToolCall(functionName, durationMs, success, decision);
+    return;
+  }
   if (!toolCallCounter || !toolCallLatencyHistogram || !isMetricsInitialized)
     return;
   const metricAttributes = {
@@ -8414,6 +8613,10 @@ function recordToolCallMetrics(config, functionName, durationMs, success, decisi
   });
 }
 function recordTokenUsageMetrics(config, model, tokenCount, type2) {
+  if (!openTelemetryAvailable) {
+    fallbackMetrics.recordTokenUsage(model, tokenCount, type2);
+    return;
+  }
   if (!tokenUsageCounter || !isMetricsInitialized)
     return;
   tokenUsageCounter.add(tokenCount, {
@@ -8423,6 +8626,10 @@ function recordTokenUsageMetrics(config, model, tokenCount, type2) {
   });
 }
 function recordApiResponseMetrics(config, model, durationMs, statusCode, error) {
+  if (!openTelemetryAvailable) {
+    fallbackMetrics.recordApiResponse(model, durationMs, !!error);
+    return;
+  }
   if (!apiRequestCounter || !apiRequestLatencyHistogram || !isMetricsInitialized)
     return;
   const metricAttributes = {
@@ -8437,6 +8644,10 @@ function recordApiResponseMetrics(config, model, durationMs, statusCode, error)
   });
 }
 function recordApiErrorMetrics(config, model, durationMs, statusCode, errorType) {
+  if (!openTelemetryAvailable) {
+    fallbackMetrics.recordApiResponse(model, durationMs, true);
+    return;
+  }
   if (!apiRequestCounter || !apiRequestLatencyHistogram || !isMetricsInitialized)
     return;
   const metricAttributes = {
@@ -8452,6 +8663,10 @@ function recordApiErrorMetrics(config, model, durationMs, statusCode, errorType)
   });
 }
 function recordFileOperationMetric(config, operation, lines, mimetype, extension, diffStat) {
+  if (!openTelemetryAvailable) {
+    fallbackMetrics.recordFileOperation(diffStat);
+    return;
+  }
   if (!fileOperationCounter || !isMetricsInitialized)
     return;
   const attributes = {
@@ -8487,11 +8702,24 @@ function recordContentRetryFailure(config) {
     return;
   contentRetryFailureCounter.add(1, getCommonAttributes(config));
 }
-var FileOperation, cliMeter, toolCallCounter, toolCallLatencyHistogram, apiRequestCounter, apiRequestLatencyHistogram, tokenUsageCounter, fileOperationCounter, chatCompressionCounter, invalidChunkCounter, contentRetryCounter, contentRetryFailureCounter, isMetricsInitialized;
+var metrics, ValueType, openTelemetryAvailable, FileOperation, cliMeter, toolCallCounter, toolCallLatencyHistogram, apiRequestCounter, apiRequestLatencyHistogram, tokenUsageCounter, fileOperationCounter, chatCompressionCounter, invalidChunkCounter, contentRetryCounter, contentRetryFailureCounter, isMetricsInitialized;
 var init_metrics = __esm({
   "packages/core/dist/src/telemetry/metrics.js"() {
     "use strict";
     init_constants();
+    init_fallback_metrics();
+    openTelemetryAvailable = false;
+    try {
+      const otelApi = __require("@opentelemetry/api");
+      metrics = otelApi.metrics;
+      ValueType = otelApi.ValueType;
+      openTelemetryAvailable = true;
+    } catch (error) {
+      console.debug("OpenTelemetry unavailable, using fallback metrics system");
+      openTelemetryAvailable = false;
+      metrics = { getMeter: () => null };
+      ValueType = { INT: "int" };
+    }
     (function(FileOperation2) {
       FileOperation2["CREATE"] = "create";
       FileOperation2["READ"] = "read";
@@ -10644,8 +10872,6 @@ var init_qwen_logger = __esm({
 
 // packages/core/dist/src/telemetry/file-exporters.js
 import * as fs3 from "node:fs";
-import { ExportResultCode } from "@opentelemetry/core";
-import { AggregationTemporality } from "@opentelemetry/sdk-metrics";
 var FileExporter, FileSpanExporter, FileLogExporter, FileMetricExporter;
 var init_file_exporters = __esm({
   "packages/core/dist/src/telemetry/file-exporters.js"() {
@@ -10666,38 +10892,20 @@ var init_file_exporters = __esm({
     };
     FileSpanExporter = class extends FileExporter {
       export(spans, resultCallback) {
-        const data = spans.map((span) => this.serialize(span)).join("");
-        this.writeStream.write(data, (err) => {
-          resultCallback({
-            code: err ? ExportResultCode.FAILED : ExportResultCode.SUCCESS,
-            error: err || void 0
-          });
-        });
+        resultCallback({ code: 0 });
       }
     };
     FileLogExporter = class extends FileExporter {
       export(logs2, resultCallback) {
-        const data = logs2.map((log) => this.serialize(log)).join("");
-        this.writeStream.write(data, (err) => {
-          resultCallback({
-            code: err ? ExportResultCode.FAILED : ExportResultCode.SUCCESS,
-            error: err || void 0
-          });
-        });
+        resultCallback({ code: 0 });
       }
     };
     FileMetricExporter = class extends FileExporter {
       export(metrics2, resultCallback) {
-        const data = this.serialize(metrics2);
-        this.writeStream.write(data, (err) => {
-          resultCallback({
-            code: err ? ExportResultCode.FAILED : ExportResultCode.SUCCESS,
-            error: err || void 0
-          });
-        });
+        resultCallback({ code: 0 });
       }
       getPreferredAggregationTemporality() {
-        return AggregationTemporality.CUMULATIVE;
+        return "cumulative";
       }
       async forceFlush() {
         return Promise.resolve();
@@ -10707,21 +10915,6 @@ var init_file_exporters = __esm({
 });
 
 // packages/core/dist/src/telemetry/sdk.js
-import { DiagConsoleLogger, DiagLogLevel, diag } from "@opentelemetry/api";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-grpc";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-grpc";
-import { OTLPTraceExporter as OTLPTraceExporterHttp } from "@opentelemetry/exporter-trace-otlp-http";
-import { OTLPLogExporter as OTLPLogExporterHttp } from "@opentelemetry/exporter-logs-otlp-http";
-import { OTLPMetricExporter as OTLPMetricExporterHttp } from "@opentelemetry/exporter-metrics-otlp-http";
-import { CompressionAlgorithm } from "@opentelemetry/otlp-exporter-base";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { BatchSpanProcessor, ConsoleSpanExporter } from "@opentelemetry/sdk-trace-node";
-import { BatchLogRecordProcessor, ConsoleLogRecordExporter } from "@opentelemetry/sdk-logs";
-import { ConsoleMetricExporter, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
 function isTelemetrySdkInitialized() {
   return telemetryInitialized;
 }
@@ -10737,12 +10930,16 @@ function parseOtlpEndpoint(otlpEndpointSetting, protocol) {
     }
     return url2.href;
   } catch (error) {
-    diag.error("Invalid OTLP endpoint URL provided:", trimmedEndpoint, error);
+    if (openTelemetryAvailable2 && diag) {
+      diag.error("Invalid OTLP endpoint URL provided:", trimmedEndpoint, error);
+    } else {
+      console.error("Invalid OTLP endpoint URL provided:", trimmedEndpoint, error);
+    }
     return void 0;
   }
 }
 function initializeTelemetry(config) {
-  if (telemetryInitialized || !config.getTelemetryEnabled()) {
+  if (telemetryInitialized || !config.getTelemetryEnabled() || !openTelemetryAvailable2) {
     return;
   }
   const resource = resourceFromAttributes({
@@ -10843,14 +11040,58 @@ async function shutdownTelemetry(config) {
     telemetryInitialized = false;
   }
 }
-var sdk, telemetryInitialized;
+var openTelemetryAvailable2, DiagConsoleLogger, DiagLogLevel, diag, OTLPTraceExporter, OTLPLogExporter, OTLPMetricExporter, OTLPTraceExporterHttp, OTLPLogExporterHttp, OTLPMetricExporterHttp, CompressionAlgorithm, NodeSDK, SemanticResourceAttributes, resourceFromAttributes, BatchSpanProcessor, ConsoleSpanExporter, BatchLogRecordProcessor, ConsoleLogRecordExporter, ConsoleMetricExporter, PeriodicExportingMetricReader, HttpInstrumentation, sdk, telemetryInitialized;
 var init_sdk = __esm({
   "packages/core/dist/src/telemetry/sdk.js"() {
     "use strict";
     init_constants();
     init_metrics();
     init_file_exporters();
-    diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
+    openTelemetryAvailable2 = false;
+    try {
+      const otelApi = __require("@opentelemetry/api");
+      const otelTraceGrpc = __require("@opentelemetry/exporter-trace-otlp-grpc");
+      const otelLogsGrpc = __require("@opentelemetry/exporter-logs-otlp-grpc");
+      const otelMetricsGrpc = __require("@opentelemetry/exporter-metrics-otlp-grpc");
+      const otelTraceHttp = __require("@opentelemetry/exporter-trace-otlp-http");
+      const otelLogsHttp = __require("@opentelemetry/exporter-logs-otlp-http");
+      const otelMetricsHttp = __require("@opentelemetry/exporter-metrics-otlp-http");
+      const otelExporterBase = __require("@opentelemetry/otlp-exporter-base");
+      const otelSdkNode = __require("@opentelemetry/sdk-node");
+      const otelSemanticConventions = __require("@opentelemetry/semantic-conventions");
+      const otelResources = __require("@opentelemetry/resources");
+      const otelSdkTraceNode = __require("@opentelemetry/sdk-trace-node");
+      const otelSdkLogs = __require("@opentelemetry/sdk-logs");
+      const otelSdkMetrics = __require("@opentelemetry/sdk-metrics");
+      const otelInstrumentationHttp = __require("@opentelemetry/instrumentation-http");
+      DiagConsoleLogger = otelApi.DiagConsoleLogger;
+      DiagLogLevel = otelApi.DiagLogLevel;
+      diag = otelApi.diag;
+      OTLPTraceExporter = otelTraceGrpc.OTLPTraceExporter;
+      OTLPLogExporter = otelLogsGrpc.OTLPLogExporter;
+      OTLPMetricExporter = otelMetricsGrpc.OTLPMetricExporter;
+      OTLPTraceExporterHttp = otelTraceHttp.OTLPTraceExporter;
+      OTLPLogExporterHttp = otelLogsHttp.OTLPLogExporter;
+      OTLPMetricExporterHttp = otelMetricsHttp.OTLPMetricExporter;
+      CompressionAlgorithm = otelExporterBase.CompressionAlgorithm;
+      NodeSDK = otelSdkNode.NodeSDK;
+      SemanticResourceAttributes = otelSemanticConventions.SemanticResourceAttributes;
+      resourceFromAttributes = otelResources.resourceFromAttributes;
+      BatchSpanProcessor = otelSdkTraceNode.BatchSpanProcessor;
+      ConsoleSpanExporter = otelSdkTraceNode.ConsoleSpanExporter;
+      BatchLogRecordProcessor = otelSdkLogs.BatchLogRecordProcessor;
+      ConsoleLogRecordExporter = otelSdkLogs.ConsoleLogRecordExporter;
+      ConsoleMetricExporter = otelSdkMetrics.ConsoleMetricExporter;
+      PeriodicExportingMetricReader = otelSdkMetrics.PeriodicExportingMetricReader;
+      HttpInstrumentation = otelInstrumentationHttp.HttpInstrumentation;
+      openTelemetryAvailable2 = true;
+    } catch (error) {
+      console.debug("OpenTelemetry SDK unavailable, telemetry disabled");
+      openTelemetryAvailable2 = false;
+    }
+    if (openTelemetryAvailable2 && diag && DiagConsoleLogger && DiagLogLevel) {
+      diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
+    }
     telemetryInitialized = false;
   }
 });
@@ -11007,8 +11248,6 @@ var init_uiTelemetry = __esm({
 });
 
 // packages/core/dist/src/telemetry/loggers.js
-import { logs } from "@opentelemetry/api-logs";
-import { SemanticAttributes } from "@opentelemetry/semantic-conventions";
 function getCommonAttributes2(config) {
   return {
     "session.id": config.getSessionId()
@@ -11347,7 +11586,7 @@ function logContentRetryFailure(config, event) {
   logger6.emit(logRecord);
   recordContentRetryFailure(config);
 }
-var shouldLogUserPrompts;
+var LogAttributes, LogRecord, logs, SemanticAttributes, openTelemetryAvailable3, shouldLogUserPrompts;
 var init_loggers = __esm({
   "packages/core/dist/src/telemetry/loggers.js"() {
     "use strict";
@@ -11357,6 +11596,25 @@ var init_loggers = __esm({
     init_sdk();
     init_uiTelemetry();
     init_safeJsonStringify();
+    openTelemetryAvailable3 = false;
+    try {
+      const otelApiLogs = __require("@opentelemetry/api-logs");
+      const otelSemanticConventions = __require("@opentelemetry/semantic-conventions");
+      LogAttributes = otelApiLogs.LogAttributes;
+      LogRecord = otelApiLogs.LogRecord;
+      logs = otelApiLogs.logs;
+      SemanticAttributes = otelSemanticConventions.SemanticAttributes;
+      openTelemetryAvailable3 = true;
+    } catch (error) {
+      console.debug("OpenTelemetry loggers unavailable, using stubs");
+      openTelemetryAvailable3 = false;
+      LogAttributes = {};
+      LogRecord = class {
+      };
+      logs = { getLogger: () => ({ emit: () => {
+      } }) };
+      SemanticAttributes = {};
+    }
     shouldLogUserPrompts = (config) => config.getTelemetryLogPromptsEnabled();
   }
 });
@@ -17563,8 +17821,8 @@ var init_uploads3 = __esm({
 var allSettledWithThrow;
 var init_Util = __esm({
   "node_modules/openai/lib/Util.mjs"() {
-    allSettledWithThrow = async (promises3) => {
-      const results = await Promise.allSettled(promises3);
+    allSettledWithThrow = async (promises4) => {
+      const results = await Promise.allSettled(promises4);
       const rejected = results.filter((result) => result.status === "rejected");
       if (rejected.length) {
         for (const result of rejected) {
@@ -19454,465 +19712,6 @@ var init_safeJsonParse = __esm({
   }
 });
 
-// node_modules/tiktoken/tiktoken_bg.cjs
-var require_tiktoken_bg = __commonJS({
-  "node_modules/tiktoken/tiktoken_bg.cjs"(exports, module) {
-    var wasm2;
-    module.exports.__wbg_set_wasm = function(val) {
-      wasm2 = val;
-    };
-    var lTextDecoder = typeof TextDecoder === "undefined" ? (0, module.require)("util").TextDecoder : TextDecoder;
-    var cachedTextDecoder = new lTextDecoder("utf-8", { ignoreBOM: true, fatal: true });
-    cachedTextDecoder.decode();
-    var cachedUint8ArrayMemory0 = null;
-    function getUint8ArrayMemory0() {
-      if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm2.memory.buffer);
-      }
-      return cachedUint8ArrayMemory0;
-    }
-    function getStringFromWasm0(ptr, len) {
-      ptr = ptr >>> 0;
-      return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-    }
-    var heap = new Array(128).fill(void 0);
-    heap.push(void 0, null, true, false);
-    var heap_next = heap.length;
-    function addHeapObject(obj) {
-      if (heap_next === heap.length) heap.push(heap.length + 1);
-      const idx = heap_next;
-      heap_next = heap[idx];
-      heap[idx] = obj;
-      return idx;
-    }
-    function handleError(f, args) {
-      try {
-        return f.apply(this, args);
-      } catch (e2) {
-        wasm2.__wbindgen_export_0(addHeapObject(e2));
-      }
-    }
-    function getObject(idx) {
-      return heap[idx];
-    }
-    function dropObject(idx) {
-      if (idx < 132) return;
-      heap[idx] = heap_next;
-      heap_next = idx;
-    }
-    function takeObject(idx) {
-      const ret = getObject(idx);
-      dropObject(idx);
-      return ret;
-    }
-    var WASM_VECTOR_LEN = 0;
-    var lTextEncoder = typeof TextEncoder === "undefined" ? (0, module.require)("util").TextEncoder : TextEncoder;
-    var cachedTextEncoder = new lTextEncoder("utf-8");
-    var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
-      return cachedTextEncoder.encodeInto(arg, view);
-    } : function(arg, view) {
-      const buf = cachedTextEncoder.encode(arg);
-      view.set(buf);
-      return {
-        read: arg.length,
-        written: buf.length
-      };
-    };
-    function passStringToWasm0(arg, malloc, realloc) {
-      if (realloc === void 0) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr2 = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr2;
-      }
-      let len = arg.length;
-      let ptr = malloc(len, 1) >>> 0;
-      const mem = getUint8ArrayMemory0();
-      let offset = 0;
-      for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 127) break;
-        mem[ptr + offset] = code;
-      }
-      if (offset !== len) {
-        if (offset !== 0) {
-          arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = encodeString(arg, view);
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-      }
-      WASM_VECTOR_LEN = offset;
-      return ptr;
-    }
-    function isLikeNone(x) {
-      return x === void 0 || x === null;
-    }
-    var cachedDataViewMemory0 = null;
-    function getDataViewMemory0() {
-      if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm2.memory.buffer) {
-        cachedDataViewMemory0 = new DataView(wasm2.memory.buffer);
-      }
-      return cachedDataViewMemory0;
-    }
-    var cachedUint32ArrayMemory0 = null;
-    function getUint32ArrayMemory0() {
-      if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
-        cachedUint32ArrayMemory0 = new Uint32Array(wasm2.memory.buffer);
-      }
-      return cachedUint32ArrayMemory0;
-    }
-    function getArrayU32FromWasm0(ptr, len) {
-      ptr = ptr >>> 0;
-      return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
-    }
-    function passArray8ToWasm0(arg, malloc) {
-      const ptr = malloc(arg.length * 1, 1) >>> 0;
-      getUint8ArrayMemory0().set(arg, ptr / 1);
-      WASM_VECTOR_LEN = arg.length;
-      return ptr;
-    }
-    function passArray32ToWasm0(arg, malloc) {
-      const ptr = malloc(arg.length * 4, 4) >>> 0;
-      getUint32ArrayMemory0().set(arg, ptr / 4);
-      WASM_VECTOR_LEN = arg.length;
-      return ptr;
-    }
-    function getArrayU8FromWasm0(ptr, len) {
-      ptr = ptr >>> 0;
-      return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-    }
-    module.exports.get_encoding = function(encoding, extend_special_tokens) {
-      if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-      try {
-        const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(encoding, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
-        const len0 = WASM_VECTOR_LEN;
-        wasm2.get_encoding(retptr, ptr0, len0, addHeapObject(extend_special_tokens));
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r22) {
-          throw takeObject(r1);
-        }
-        return Tiktoken.__wrap(r0);
-      } finally {
-        wasm2.__wbindgen_add_to_stack_pointer(16);
-      }
-    };
-    module.exports.encoding_for_model = function(model, extend_special_tokens) {
-      if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-      try {
-        const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(model, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
-        const len0 = WASM_VECTOR_LEN;
-        wasm2.encoding_for_model(retptr, ptr0, len0, addHeapObject(extend_special_tokens));
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r22) {
-          throw takeObject(r1);
-        }
-        return Tiktoken.__wrap(r0);
-      } finally {
-        wasm2.__wbindgen_add_to_stack_pointer(16);
-      }
-    };
-    module.exports.get_encoding_name_for_model = function(model) {
-      if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-      let deferred3_0;
-      let deferred3_1;
-      try {
-        const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(model, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
-        const len0 = WASM_VECTOR_LEN;
-        wasm2.get_encoding_name_for_model(retptr, ptr0, len0);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        var ptr2 = r0;
-        var len2 = r1;
-        if (r3) {
-          ptr2 = 0;
-          len2 = 0;
-          throw takeObject(r22);
-        }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
-      } finally {
-        wasm2.__wbindgen_add_to_stack_pointer(16);
-        wasm2.__wbindgen_export_3(deferred3_0, deferred3_1, 1);
-      }
-    };
-    var TiktokenFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
-    }, unregister: () => {
-    } } : new FinalizationRegistry((ptr) => wasm2.__wbg_tiktoken_free(ptr >>> 0, 1));
-    var Tiktoken = class _Tiktoken {
-      /**
-       * @param {string} tiktoken_bfe
-       * @param {any} special_tokens
-       * @param {string} pat_str
-       */
-      constructor(tiktoken_bfe, special_tokens, pat_str) {
-        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-        const ptr0 = passStringToWasm0(tiktoken_bfe, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(pat_str, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm2.tiktoken_new(ptr0, len0, addHeapObject(special_tokens), ptr1, len1);
-        this.__wbg_ptr = ret >>> 0;
-        TiktokenFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-      }
-      /** @returns {string | undefined} */
-      get name() {
-        try {
-          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-          wasm2.tiktoken_name(retptr, this.__wbg_ptr);
-          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-          let v1;
-          if (r0 !== 0) {
-            v1 = getStringFromWasm0(r0, r1).slice();
-            wasm2.__wbindgen_export_3(r0, r1 * 1, 1);
-          }
-          return v1;
-        } finally {
-          wasm2.__wbindgen_add_to_stack_pointer(16);
-        }
-      }
-      static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(_Tiktoken.prototype);
-        obj.__wbg_ptr = ptr;
-        TiktokenFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-      }
-      __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        TiktokenFinalization.unregister(this);
-        return ptr;
-      }
-      free() {
-        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-        const ptr = this.__destroy_into_raw();
-        wasm2.__wbg_tiktoken_free(ptr, 0);
-      }
-      /**
-       * @param {string} text
-       * @param {any} allowed_special
-       * @param {any} disallowed_special
-       * @returns {Uint32Array}
-       */
-      encode(text, allowed_special, disallowed_special) {
-        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-        try {
-          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-          const ptr0 = passStringToWasm0(text, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
-          const len0 = WASM_VECTOR_LEN;
-          wasm2.tiktoken_encode(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(allowed_special), addHeapObject(disallowed_special));
-          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-          var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-          var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-          if (r3) {
-            throw takeObject(r22);
-          }
-          var v2 = getArrayU32FromWasm0(r0, r1).slice();
-          wasm2.__wbindgen_export_3(r0, r1 * 4, 4);
-          return v2;
-        } finally {
-          wasm2.__wbindgen_add_to_stack_pointer(16);
-        }
-      }
-      /**
-       * @param {string} text
-       * @returns {Uint32Array}
-       */
-      encode_ordinary(text) {
-        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-        try {
-          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-          const ptr0 = passStringToWasm0(text, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
-          const len0 = WASM_VECTOR_LEN;
-          wasm2.tiktoken_encode_ordinary(retptr, this.__wbg_ptr, ptr0, len0);
-          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-          var v2 = getArrayU32FromWasm0(r0, r1).slice();
-          wasm2.__wbindgen_export_3(r0, r1 * 4, 4);
-          return v2;
-        } finally {
-          wasm2.__wbindgen_add_to_stack_pointer(16);
-        }
-      }
-      /**
-       * @param {string} text
-       * @param {any} allowed_special
-       * @param {any} disallowed_special
-       * @returns {any}
-       */
-      encode_with_unstable(text, allowed_special, disallowed_special) {
-        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-        try {
-          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-          const ptr0 = passStringToWasm0(text, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
-          const len0 = WASM_VECTOR_LEN;
-          wasm2.tiktoken_encode_with_unstable(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(allowed_special), addHeapObject(disallowed_special));
-          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-          var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-          if (r22) {
-            throw takeObject(r1);
-          }
-          return takeObject(r0);
-        } finally {
-          wasm2.__wbindgen_add_to_stack_pointer(16);
-        }
-      }
-      /**
-       * @param {Uint8Array} bytes
-       * @returns {number}
-       */
-      encode_single_token(bytes) {
-        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-        const ptr0 = passArray8ToWasm0(bytes, wasm2.__wbindgen_export_1);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm2.tiktoken_encode_single_token(this.__wbg_ptr, ptr0, len0);
-        return ret >>> 0;
-      }
-      /**
-       * @param {Uint32Array} tokens
-       * @returns {Uint8Array}
-       */
-      decode(tokens) {
-        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-        try {
-          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-          const ptr0 = passArray32ToWasm0(tokens, wasm2.__wbindgen_export_1);
-          const len0 = WASM_VECTOR_LEN;
-          wasm2.tiktoken_decode(retptr, this.__wbg_ptr, ptr0, len0);
-          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-          var v2 = getArrayU8FromWasm0(r0, r1).slice();
-          wasm2.__wbindgen_export_3(r0, r1 * 1, 1);
-          return v2;
-        } finally {
-          wasm2.__wbindgen_add_to_stack_pointer(16);
-        }
-      }
-      /**
-       * @param {number} token
-       * @returns {Uint8Array}
-       */
-      decode_single_token_bytes(token2) {
-        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-        try {
-          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-          wasm2.tiktoken_decode_single_token_bytes(retptr, this.__wbg_ptr, token2);
-          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-          var v1 = getArrayU8FromWasm0(r0, r1).slice();
-          wasm2.__wbindgen_export_3(r0, r1 * 1, 1);
-          return v1;
-        } finally {
-          wasm2.__wbindgen_add_to_stack_pointer(16);
-        }
-      }
-      /** @returns {any} */
-      token_byte_values() {
-        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-        const ret = wasm2.tiktoken_token_byte_values(this.__wbg_ptr);
-        return takeObject(ret);
-      }
-    };
-    module.exports.Tiktoken = Tiktoken;
-    module.exports.__wbg_parse_def2e24ef1252aff = function() {
-      return handleError(function(arg0, arg1) {
-        const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-      }, arguments);
-    };
-    module.exports.__wbg_stringify_f7ed6987935b4a24 = function() {
-      return handleError(function(arg0) {
-        const ret = JSON.stringify(getObject(arg0));
-        return addHeapObject(ret);
-      }, arguments);
-    };
-    module.exports.__wbindgen_error_new = function(arg0, arg1) {
-      const ret = new Error(getStringFromWasm0(arg0, arg1));
-      return addHeapObject(ret);
-    };
-    module.exports.__wbindgen_is_undefined = function(arg0) {
-      const ret = getObject(arg0) === void 0;
-      return ret;
-    };
-    module.exports.__wbindgen_object_drop_ref = function(arg0) {
-      takeObject(arg0);
-    };
-    module.exports.__wbindgen_string_get = function(arg0, arg1) {
-      if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
-      const obj = getObject(arg1);
-      const ret = typeof obj === "string" ? obj : void 0;
-      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
-      var len1 = WASM_VECTOR_LEN;
-      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-    };
-    module.exports.__wbindgen_throw = function(arg0, arg1) {
-      throw new Error(getStringFromWasm0(arg0, arg1));
-    };
-  }
-});
-
-// node_modules/tiktoken/tiktoken.cjs
-var require_tiktoken = __commonJS({
-  "node_modules/tiktoken/tiktoken.cjs"(exports) {
-    var wasm2 = require_tiktoken_bg();
-    var imports = {};
-    imports["./tiktoken_bg.js"] = wasm2;
-    var path81 = __require("path");
-    var fs70 = __require("fs");
-    var candidates = __dirname.split(path81.sep).reduce((memo, _, index, array) => {
-      const prefix = array.slice(0, index + 1).join(path81.sep) + path81.sep;
-      if (!prefix.includes("node_modules" + path81.sep)) {
-        memo.unshift(
-          path81.join(
-            prefix,
-            "node_modules",
-            "tiktoken",
-            "",
-            "./tiktoken_bg.wasm"
-          )
-        );
-      }
-      return memo;
-    }, []);
-    candidates.unshift(path81.join(__dirname, "./tiktoken_bg.wasm"));
-    var bytes = null;
-    for (const candidate of candidates) {
-      try {
-        bytes = fs70.readFileSync(candidate);
-        break;
-      } catch {
-      }
-    }
-    if (bytes == null) throw new Error("Missing tiktoken_bg.wasm");
-    var wasmModule = new WebAssembly.Module(bytes);
-    var wasmInstance = new WebAssembly.Instance(wasmModule, imports);
-    wasm2.__wbg_set_wasm(wasmInstance.exports);
-    exports["get_encoding"] = wasm2["get_encoding"];
-    exports["encoding_for_model"] = wasm2["encoding_for_model"];
-    exports["get_encoding_name_for_model"] = wasm2["get_encoding_name_for_model"];
-    exports["Tiktoken"] = wasm2["Tiktoken"];
-  }
-});
-
 // packages/core/dist/src/core/openaiContentGenerator.js
 var openaiContentGenerator_exports = {};
 __export(openaiContentGenerator_exports, {
@@ -20327,7 +20126,7 @@ Streaming setup timeout troubleshooting:
         const content = JSON.stringify(request2.contents);
         let totalTokens = 0;
         try {
-          const { get_encoding } = await Promise.resolve().then(() => __toESM(require_tiktoken(), 1));
+          const { get_encoding } = await import("tiktoken");
           const encoding = get_encoding("cl100k_base");
           totalTokens = encoding.encode(content).length;
           encoding.free();
@@ -22121,7 +21920,7 @@ function createContentGeneratorConfig(config, authType) {
   return contentGeneratorConfig;
 }
 async function createContentGenerator(config, gcConfig, sessionId2) {
-  const version = "1.0.60";
+  const version = "1.0.62";
   const userAgent = `FSS-Link/${version} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent
@@ -30666,14 +30465,14 @@ var init_esm5 = __esm({
               if (er)
                 return results.emit("error", er);
               if (follow && !didRealpaths) {
-                const promises3 = [];
+                const promises4 = [];
                 for (const e2 of entries) {
                   if (e2.isSymbolicLink()) {
-                    promises3.push(e2.realpath().then((r3) => r3?.isUnknown() ? r3.lstat() : r3));
+                    promises4.push(e2.realpath().then((r3) => r3?.isUnknown() ? r3.lstat() : r3));
                   }
                 }
-                if (promises3.length) {
-                  Promise.all(promises3).then(() => onReaddir(null, entries, true));
+                if (promises4.length) {
+                  Promise.all(promises4).then(() => onReaddir(null, entries, true));
                   return;
                 }
               }
@@ -38311,8 +38110,8 @@ var init_edit = __esm({
         let currentContent = null;
         let fileExists = false;
         let isNewFile = false;
-        let finalNewString = params.new_string;
-        let finalOldString = params.old_string;
+        const finalNewString = params.new_string;
+        const finalOldString = params.old_string;
         let occurrences = 0;
         let error = void 0;
         try {
@@ -38342,22 +38141,77 @@ var init_edit = __esm({
               type: ToolErrorType.ATTEMPT_TO_CREATE_EXISTING_FILE
             };
           } else if (occurrences === 0) {
+            const oldStringPreview = params.old_string.length > 100 ? params.old_string.substring(0, 97) + "..." : params.old_string;
+            const hasEscapeChars = /\\[ntr"'`\\]/.test(params.old_string);
+            const hasSpecialWhitespace = /[\u0000-\u001F\u007F-\u009F]/.test(params.old_string);
+            const diagnosticHints = [];
+            if (hasEscapeChars) {
+              diagnosticHints.push("String contains escape characters (\\n, \\t, etc.) - these must match exactly");
+            }
+            if (hasSpecialWhitespace) {
+              diagnosticHints.push("String contains special whitespace or control characters");
+            }
+            if (params.old_string.includes("\n")) {
+              diagnosticHints.push("Multi-line string - verify line endings and indentation match exactly");
+            }
+            if (params.old_string.trim() !== params.old_string) {
+              diagnosticHints.push("String has leading/trailing whitespace - this must match file content exactly");
+            }
+            const diagnostics = diagnosticHints.length > 0 ? "\n\nDiagnostics:\n" + diagnosticHints.join("\n") : "";
             error = {
-              display: `Failed to edit, could not find the string to replace.`,
-              raw: `Failed to edit, 0 occurrences found for old_string in ${params.file_path}. No edits made. The exact text in old_string was not found. Ensure you're not escaping content incorrectly and check whitespace, indentation, and context. Use ${ReadFileTool.Name} tool to verify.`,
+              display: `Failed to edit: target string not found in file.`,
+              raw: `Failed to edit: 0 occurrences found for old_string in ${params.file_path}.
+
+Target string (${params.old_string.length} chars): "${oldStringPreview}"
+
+The exact text was not found. Common causes:
+\u2022 Whitespace differences (spaces, tabs, line endings)
+\u2022 Escape character issues (\\n vs actual newlines)
+\u2022 Case sensitivity mismatches
+\u2022 Text has been modified since last read
+
+Recommended actions:
+1. Use ${ReadFileTool.Name} to verify current file content
+2. Copy the exact text from the file (including whitespace)
+3. Check for hidden characters or encoding issues${diagnostics}`,
               type: ToolErrorType.EDIT_NO_OCCURRENCE_FOUND
             };
           } else if (occurrences !== expectedReplacements) {
             const occurrenceTerm = expectedReplacements === 1 ? "occurrence" : "occurrences";
+            const foundTerm = occurrences === 1 ? "occurrence" : "occurrences";
+            const oldStringPreview = params.old_string.length > 100 ? params.old_string.substring(0, 97) + "..." : params.old_string;
             error = {
-              display: `Failed to edit, expected ${expectedReplacements} ${occurrenceTerm} but found ${occurrences}.`,
-              raw: `Failed to edit, Expected ${expectedReplacements} ${occurrenceTerm} but found ${occurrences} for old_string in file: ${params.file_path}`,
+              display: `Edit safety check failed: found ${occurrences} matches, expected ${expectedReplacements}.`,
+              raw: `Edit safety check failed in ${params.file_path}:
+
+Expected: ${expectedReplacements} ${occurrenceTerm}
+Found:    ${occurrences} ${foundTerm}
+
+Target string: "${oldStringPreview}"
+
+This safety check prevents unintended bulk replacements. Solutions:
+\u2022 If you want to replace all ${occurrences} instances, set expected_replacements: ${occurrences}
+\u2022 If you want to replace only specific instances, make your old_string more specific
+\u2022 Use ${ReadFileTool.Name} to see all occurrences and their context
+\u2022 Consider using line-specific context to make the target unique
+
+Safety first: FSS Link prevents accidental mass replacements.`,
               type: ToolErrorType.EDIT_EXPECTED_OCCURRENCE_MISMATCH
             };
           } else if (finalOldString === finalNewString) {
             error = {
-              display: `No changes to apply. The old_string and new_string are identical.`,
-              raw: `No changes to apply. The old_string and new_string are identical in file: ${params.file_path}`,
+              display: `No changes to apply: old_string and new_string are identical.`,
+              raw: `No changes to apply in ${params.file_path}:
+
+The old_string and new_string are identical:
+"${params.old_string}"
+
+This might indicate:
+\u2022 The change has already been applied
+\u2022 Copy-paste error where old and new text are the same
+\u2022 Unintended duplicate content
+
+Verify your intended changes and ensure old_string \u2260 new_string.`,
               type: ToolErrorType.EDIT_NO_CHANGE
             };
           }
@@ -38485,11 +38339,13 @@ var init_edit = __esm({
         try {
           this.ensureParentDirectoriesExist(this.params.file_path);
           await this.config.getFileSystemService().writeTextFile(this.params.file_path, editData.newContent);
+          const fileName = path19.basename(this.params.file_path);
+          const originallyProposedContent = this.params.ai_proposed_string || this.params.new_string;
+          const diffStat = getDiffStat(fileName, editData.currentContent ?? "", originallyProposedContent, this.params.new_string);
           let displayResult;
           if (editData.isNewFile) {
             displayResult = `Created ${shortenPath(makeRelative(this.params.file_path, this.config.getTargetDir()))}`;
           } else {
-            const fileName = path19.basename(this.params.file_path);
             const fileDiff = createPatch(
               fileName,
               editData.currentContent ?? "",
@@ -38499,8 +38355,6 @@ var init_edit = __esm({
               "Proposed",
               DEFAULT_DIFF_OPTIONS
             );
-            const originallyProposedContent = this.params.ai_proposed_string || this.params.new_string;
-            const diffStat = getDiffStat(fileName, editData.currentContent ?? "", originallyProposedContent, this.params.new_string);
             displayResult = {
               fileDiff,
               fileName,
@@ -38509,11 +38363,36 @@ var init_edit = __esm({
               diffStat
             };
           }
+          const oldLines = (editData.currentContent ?? "").split("\n").length;
+          const newLines = editData.newContent.split("\n").length;
+          const lineDelta = newLines - oldLines;
+          const findChangeLineNumber = (content, target) => {
+            if (!content || editData.isNewFile)
+              return 1;
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+              if (lines[i].includes(target.split("\n")[0])) {
+                return i + 1;
+              }
+            }
+            return 1;
+          };
+          const changeLineNumber = findChangeLineNumber(editData.currentContent ?? "", this.params.old_string);
+          const oldChars = (editData.currentContent ?? "").length;
+          const newChars = editData.newContent.length;
+          const charDelta = newChars - oldChars;
+          const oldWords = (editData.currentContent ?? "").split(/\s+/).filter((w) => w.length > 0).length;
+          const newWords = editData.newContent.split(/\s+/).filter((w) => w.length > 0).length;
+          const wordDelta = newWords - oldWords;
           const llmSuccessMessageParts = [
-            editData.isNewFile ? `Created new file: ${this.params.file_path} with provided content.` : `Successfully modified file: ${this.params.file_path} (${editData.occurrences} replacements).`
+            editData.isNewFile ? `Created new file: ${this.params.file_path}
+Content: ${newLines} lines, ${newChars} characters, ${newWords} words` : `Successfully modified: ${this.params.file_path}
+Location: line ${changeLineNumber} (${editData.occurrences} replacement${editData.occurrences === 1 ? "" : "s"})
+Changes: ${diffStat.ai_added_lines > 0 ? `+${diffStat.ai_added_lines}` : ""}${diffStat.ai_removed_lines > 0 ? ` -${diffStat.ai_removed_lines}` : ""} lines${lineDelta !== 0 ? ` (${lineDelta > 0 ? "+" : ""}${lineDelta} net)` : ""}
+File size: ${oldLines} \u2192 ${newLines} lines, ${oldChars} \u2192 ${newChars} chars${charDelta !== 0 ? ` (${charDelta > 0 ? "+" : ""}${charDelta})` : ""}${wordDelta !== 0 ? `, ${wordDelta > 0 ? "+" : ""}${wordDelta} words` : ""}`
           ];
           if (this.params.modified_by_user) {
-            llmSuccessMessageParts.push(`User modified the \`new_string\` content to be: ${this.params.new_string}.`);
+            llmSuccessMessageParts.push(`User modified the content during confirmation.`);
           }
           return {
             llmContent: llmSuccessMessageParts.join(" "),
@@ -49029,11 +48908,20 @@ var init_write_file = __esm({
           const fileDiff = createPatch(fileName, currentContentForDiff, fileContent, "Original", "Written", DEFAULT_DIFF_OPTIONS);
           const originallyProposedContent = ai_proposed_content || content;
           const diffStat = getDiffStat(fileName, currentContentForDiff, originallyProposedContent, content);
+          const totalLines = fileContent.split("\n").length;
+          const chars = fileContent.length;
+          const words = fileContent.split(/\s+/).filter((w) => w.length > 0).length;
+          const bytes = Buffer.byteLength(fileContent, "utf8");
+          const oldSize = originalContent.length;
+          const sizeDelta = chars - oldSize;
           const llmSuccessMessageParts = [
-            isNewFile ? `Successfully created and wrote to new file: ${file_path}.` : `Successfully overwrote file: ${file_path}.`
+            isNewFile ? `Created new file: ${file_path}
+Content: ${totalLines} lines, ${chars} characters, ${words} words (${bytes} bytes)` : `Overwrote file: ${file_path}
+Content: ${totalLines} lines, ${chars} characters, ${words} words (${bytes} bytes)${sizeDelta !== 0 ? `
+Size change: ${sizeDelta > 0 ? "+" : ""}${sizeDelta} characters (${oldSize} \u2192 ${chars})` : ""}`
           ];
           if (modified_by_user) {
-            llmSuccessMessageParts.push(`User modified the \`content\` to be: ${content}`);
+            llmSuccessMessageParts.push(`User modified the content during confirmation.`);
           }
           const displayResult = {
             fileDiff,
@@ -93540,7 +93428,7 @@ var require_xlsx = __commonJS({
         }
         return ws2;
       }
-      var utils = {
+      var utils2 = {
         encode_col,
         encode_row,
         encode_cell,
@@ -93739,7 +93627,7 @@ var require_xlsx = __commonJS({
       XLSX3.writeFile = writeFileSync7;
       XLSX3.writeFileSync = writeFileSync7;
       XLSX3.writeFileAsync = writeFileAsync;
-      XLSX3.utils = utils;
+      XLSX3.utils = utils2;
       XLSX3.writeXLSX = writeSyncXLSX;
       XLSX3.writeFileXLSX = writeFileSyncXLSX;
       XLSX3.SSF = SSF;
@@ -98072,23 +97960,124 @@ var init_safety_manager = __esm({
   }
 });
 
+// packages/core/dist/src/parsers/excel/memory-tracker.js
+var MemoryTracker;
+var init_memory_tracker = __esm({
+  "packages/core/dist/src/parsers/excel/memory-tracker.js"() {
+    "use strict";
+    MemoryTracker = class {
+      maxMemoryMB;
+      startTime;
+      lastCheckTime;
+      checkInterval = 1e3;
+      // Check every second
+      constructor(maxMemoryMB) {
+        this.maxMemoryMB = maxMemoryMB;
+        this.startTime = Date.now();
+        this.lastCheckTime = this.startTime;
+      }
+      /**
+       * Get current memory usage in MB
+       */
+      getCurrentUsage() {
+        const memUsage = process.memoryUsage();
+        return Math.round(memUsage.heapUsed / 1024 / 1024 * 100) / 100;
+      }
+      /**
+       * Get peak memory usage since start
+       */
+      getPeakUsage() {
+        const memUsage = process.memoryUsage();
+        return Math.round(memUsage.heapTotal / 1024 / 1024 * 100) / 100;
+      }
+      /**
+       * Check if we're approaching memory limits
+       */
+      isMemoryLimitApproached() {
+        const currentUsage = this.getCurrentUsage();
+        return currentUsage > this.maxMemoryMB * 0.8;
+      }
+      /**
+       * Check if memory limit has been exceeded
+       */
+      isMemoryLimitExceeded() {
+        const currentUsage = this.getCurrentUsage();
+        return currentUsage > this.maxMemoryMB;
+      }
+      /**
+       * Get memory status for progress reporting
+       */
+      getMemoryStatus() {
+        const currentUsage = this.getCurrentUsage();
+        return {
+          currentMB: currentUsage,
+          maxMB: this.maxMemoryMB,
+          percentageUsed: Math.round(currentUsage / this.maxMemoryMB * 100),
+          isApproachingLimit: this.isMemoryLimitApproached(),
+          isExceeded: this.isMemoryLimitExceeded()
+        };
+      }
+      /**
+       * Force garbage collection if available (V8 specific)
+       */
+      async forceGC() {
+        if (global.gc) {
+          global.gc();
+          await new Promise((resolve19) => setTimeout(resolve19, 10));
+        }
+      }
+      /**
+       * Get elapsed time since tracking started
+       */
+      getElapsedTime() {
+        return Date.now() - this.startTime;
+      }
+      /**
+       * Reset tracking (useful for new operations)
+       */
+      reset() {
+        this.startTime = Date.now();
+        this.lastCheckTime = this.startTime;
+      }
+      /**
+       * Log memory status for debugging
+       */
+      logMemoryStatus(context = "") {
+        const status = this.getMemoryStatus();
+        const prefix = context ? `[${context}] ` : "";
+        console.log(`${prefix}Memory: ${status.currentMB}MB / ${status.maxMB}MB (${status.percentageUsed}%)`);
+        if (status.isApproachingLimit) {
+          console.warn(`${prefix}Warning: Approaching memory limit!`);
+        }
+        if (status.isExceeded) {
+          console.error(`${prefix}Error: Memory limit exceeded!`);
+        }
+      }
+    };
+  }
+});
+
 // packages/core/dist/src/parsers/excel/excel-parser.js
 var excel_parser_exports = {};
 __export(excel_parser_exports, {
   ExcelParser: () => ExcelParser
 });
 import * as fs24 from "fs";
-var import_xlsx, ExcelParser;
+var XLSX, ExcelParser;
 var init_excel_parser = __esm({
   "packages/core/dist/src/parsers/excel/excel-parser.js"() {
     "use strict";
-    import_xlsx = __toESM(require_xlsx(), 1);
+    XLSX = __toESM(require_xlsx(), 1);
     init_lib2();
     init_js_yaml();
     init_safety_manager();
+    init_memory_tracker();
     ExcelParser = class {
       config;
       safetyManager;
+      progressCallback;
+      abortController;
+      memoryTracker;
       constructor(config = {}) {
         this.config = {
           readAllSheets: true,
@@ -98097,16 +98086,96 @@ var init_excel_parser = __esm({
           safetyChecks: true,
           preserveFormulas: false,
           includeFormatting: false,
+          maxMemoryUsage: 512,
+          // 512MB default
+          chunkSize: 1e3,
+          // 1000 rows per chunk
+          enableProgress: true,
+          enableCancellation: true,
           ...config
         };
         this.safetyManager = new SafetyManager();
+        this.memoryTracker = new MemoryTracker(this.config.maxMemoryUsage);
+      }
+      // Set progress callback for streaming operations
+      setProgressCallback(callback2) {
+        this.progressCallback = callback2;
+      }
+      // Enable cancellation for long-running operations
+      enableCancellation(controller) {
+        this.abortController = controller;
+      }
+      // StreamingParser interface implementation
+      getProgressCallback() {
+        return (progress) => {
+          if (this.progressCallback) {
+            this.progressCallback({
+              phase: "processing",
+              currentSheet: "",
+              sheetsProcessed: 0,
+              totalSheets: 1,
+              rowsProcessed: Math.floor(progress * 100),
+              totalRows: 100,
+              memoryUsage: this.memoryTracker.getCurrentUsage(),
+              elapsedTime: Date.now()
+            });
+          }
+        };
+      }
+      async processChunk(chunk, index) {
+        const chunkStr = chunk.toString();
+        const rows = [];
+        const lines = chunkStr.split("\n");
+        lines.forEach((line) => {
+          const cells = line.split(",").map((value) => ({
+            value: value.trim(),
+            type: "string"
+          }));
+          rows.push(cells);
+        });
+        return {
+          rows,
+          startRow: index * this.config.chunkSize,
+          endRow: (index + 1) * this.config.chunkSize - 1,
+          sheetName: "Chunk" + index,
+          isLastChunk: false
+          // This would be determined by the calling context
+        };
+      }
+      async mergeResults(chunks) {
+        const workbookData = {
+          sheets: {}
+        };
+        chunks.forEach((chunk) => {
+          if (!workbookData.sheets[chunk.sheetName]) {
+            workbookData.sheets[chunk.sheetName] = {
+              name: chunk.sheetName,
+              data: [],
+              range: "",
+              rowCount: 0,
+              columnCount: 0
+            };
+          }
+          const sheet = workbookData.sheets[chunk.sheetName];
+          sheet.data.push(...chunk.rows);
+          sheet.rowCount += chunk.rows.length;
+          sheet.columnCount = Math.max(sheet.columnCount, chunk.rows[0]?.length || 0);
+        });
+        return {
+          success: true,
+          data: workbookData
+        };
       }
       async parseFile(filePath) {
         const startTime = Date.now();
+        this.memoryTracker.reset();
         const result = {
           success: false,
           warnings: [],
-          errors: []
+          errors: [],
+          chunksProcessed: 0,
+          peakMemoryUsage: 0,
+          averageChunkTime: 0
         };
         try {
           if (this.config.safetyChecks) {
@@ -98116,8 +98185,17 @@ var init_excel_parser = __esm({
               return result;
             }
           }
+          const stats = await fs24.promises.stat(filePath);
+          const fileSizeMB = stats.size / 1024 / 1024;
+          const shouldStream = fileSizeMB > 50;
+          if (shouldStream && this.config.enableProgress) {
+            console.log(`\u{1F4CA} Large file detected (${fileSizeMB.toFixed(1)}MB), using streaming mode...`);
+          }
           const extension = filePath.toLowerCase().split(".").pop();
           let workbookData;
+          if (this.config.enableProgress) {
+            this.reportProgress("reading", "", 0, 1, 0, 0);
+          }
           switch (extension) {
             case "xlsx":
             case "xls":
@@ -98139,11 +98217,88 @@ var init_excel_parser = __esm({
           }
           result.success = true;
           result.processingTime = Date.now() - startTime;
+          result.peakMemoryUsage = this.memoryTracker.getPeakUsage();
+          if (this.config.enableProgress) {
+            this.reportProgress("complete", "", 1, 1, 1, 1);
+          }
         } catch (error) {
           result.errors?.push(`Parsing failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+          if (this.memoryTracker.isMemoryLimitExceeded()) {
+            result.errors?.push(`Memory limit exceeded: ${this.memoryTracker.getCurrentUsage()}MB > ${this.config.maxMemoryUsage}MB`);
+          }
         }
         return result;
       }
+      // Enhanced streaming Excel file parser
+      async parseExcelFileStreaming(filePath) {
+        this.reportProgress("reading", filePath, 0, 1, 0, 0);
+        const workbook = XLSX.readFile(filePath, {
+          bookProps: true,
+          bookSheets: true,
+          sheetRows: 0
+          // Don't load data yet
+        });
+        const workbookData = {
+          sheets: {},
+          metadata: this.extractWorkbookMetadata(workbook),
+          revisionHistory: this.extractRevisionHistory(workbook),
+          lastAuthors: this.extractLastAuthors(workbook)
+        };
+        const sheetsToProcess = this.config.readAllSheets ? workbook.SheetNames : [workbook.SheetNames[0]];
+        for (let i = 0; i < sheetsToProcess.length; i++) {
+          const sheetName = sheetsToProcess[i];
+          this.reportProgress("processing", sheetName, i, sheetsToProcess.length, 0, 0);
+          if (this.abortController?.signal.aborted) {
+            throw new Error("Operation cancelled by user");
+          }
+          if (this.memoryTracker.isMemoryLimitExceeded()) {
+            await this.memoryTracker.forceGC();
+            if (this.memoryTracker.isMemoryLimitExceeded()) {
+              throw new Error(`Memory limit exceeded: ${this.memoryTracker.getCurrentUsage()}MB`);
+            }
+          }
+          const enhancedSheet = await this.processWorksheetStreaming(workbook, sheetName, filePath);
+          workbookData.sheets[sheetName] = enhancedSheet;
+          this.reportProgress("processing", sheetName, i + 1, sheetsToProcess.length, 0, 0);
+        }
+        return workbookData;
+      }
+      // Process worksheet with streaming and enhanced features
+      async processWorksheetStreaming(workbook, sheetName, filePath) {
+        const sheetWorkbook = XLSX.readFile(filePath, {
+          sheets: [sheetName],
+          cellFormula: this.config.preserveFormulas,
+          cellStyles: this.config.includeFormatting
+        });
+        const worksheet = sheetWorkbook.Sheets[sheetName];
+        if (!worksheet) {
+          throw new Error(`Sheet ${sheetName} not found`);
+        }
+        const baseSheetData = this.processWorksheet(worksheet, sheetName);
+        const enhancedSheetData = {
+          ...baseSheetData,
+          formulaRelationships: this.config.preserveFormulas ? this.extractFormulaRelationships(worksheet) : void 0,
+          tables: this.extractTableInfo(worksheet),
+          charts: this.extractChartInfo(worksheet),
+          revisionHistory: this.extractSheetRevisionHistory(worksheet)
+        };
+        return enhancedSheetData;
+      }
+      // Helper method for progress reporting
+      reportProgress(phase, currentSheet, sheetsProcessed, totalSheets, rowsProcessed, totalRows) {
+        if (this.progressCallback && this.config.enableProgress) {
+          this.progressCallback({
+            phase,
+            currentSheet,
+            sheetsProcessed,
+            totalSheets,
+            rowsProcessed,
+            totalRows,
+            memoryUsage: this.memoryTracker.getCurrentUsage(),
+            elapsedTime: this.memoryTracker.getElapsedTime()
+          });
+        }
+      }
       async parseExcelFile(filePath) {
         const options3 = {};
         if (this.config.preserveFormulas !== void 0)
@@ -98152,7 +98307,7 @@ var init_excel_parser = __esm({
           options3.cellStyles = this.config.includeFormatting;
         if (this.config.includeMetadata !== void 0)
           options3.bookProps = this.config.includeMetadata;
-        const workbook = import_xlsx.default.readFile(filePath, options3);
+        const workbook = XLSX.readFile(filePath, options3);
         const workbookData = {
           sheets: {}
         };
@@ -98187,16 +98342,16 @@ var init_excel_parser = __esm({
         const targetRange = this.config.range || sheetRange;
         let range;
         try {
-          range = import_xlsx.default.utils.decode_range(targetRange);
+          range = XLSX.utils.decode_range(targetRange);
         } catch (_error) {
           console.warn(`Invalid range specified: ${targetRange}, falling back to full sheet`);
-          range = import_xlsx.default.utils.decode_range(sheetRange);
+          range = XLSX.utils.decode_range(sheetRange);
         }
         const data = [];
         for (let row = range.s.r; row <= range.e.r; row++) {
           const rowData = [];
           for (let col = range.s.c; col <= range.e.c; col++) {
-            const cellAddress = import_xlsx.default.utils.encode_cell({ r: row, c: col });
+            const cellAddress = XLSX.utils.encode_cell({ r: row, c: col });
             const cell = worksheet[cellAddress];
             if (cell) {
               const cellData = {
@@ -98257,7 +98412,7 @@ var init_excel_parser = __esm({
             const sheetData = {
               name: "Sheet1",
               data,
-              range: `A1:${import_xlsx.default.utils.encode_cell({ r: data.length - 1, c: Math.max(0, (data[0]?.length || 1) - 1) })}`,
+              range: `A1:${XLSX.utils.encode_cell({ r: data.length - 1, c: Math.max(0, (data[0]?.length || 1) - 1) })}`,
               rowCount: data.length,
               columnCount: data[0]?.length || 0
             };
@@ -98348,12 +98503,221 @@ var init_excel_parser = __esm({
         });
         return markdown2;
       }
+      // Enhanced metadata extraction with version tracking
+      extractWorkbookMetadata(workbook) {
+        if (!this.config.includeMetadata || !workbook.Props) {
+          return void 0;
+        }
+        const metadata = {};
+        if (workbook.Props.Title)
+          metadata.title = workbook.Props.Title;
+        if (workbook.Props.Author)
+          metadata.author = workbook.Props.Author;
+        if (workbook.Props.Subject)
+          metadata.subject = workbook.Props.Subject;
+        if (workbook.Props.CreatedDate)
+          metadata.created = workbook.Props.CreatedDate;
+        if (workbook.Props.ModifiedDate)
+          metadata.modified = workbook.Props.ModifiedDate;
+        if (workbook.Props.Application)
+          metadata.application = workbook.Props.Application;
+        metadata.sheetNames = workbook.SheetNames;
+        return metadata;
+      }
+      // Extract revision history from workbook properties
+      extractRevisionHistory(workbook) {
+        if (!workbook.Props)
+          return void 0;
+        const revisions = [];
+        if (workbook.Props.LastAuthor) {
+          revisions.push({
+            author: workbook.Props.LastAuthor,
+            timestamp: workbook.Props.ModifiedDate,
+            description: "Last modification"
+          });
+        }
+        return revisions.length > 0 ? revisions : void 0;
+      }
+      // Extract last authors from document properties
+      extractLastAuthors(workbook) {
+        if (!workbook.Props)
+          return void 0;
+        const authors = [];
+        if (workbook.Props.Author)
+          authors.push(workbook.Props.Author);
+        if (workbook.Props.LastAuthor && workbook.Props.LastAuthor !== workbook.Props.Author) {
+          authors.push(workbook.Props.LastAuthor);
+        }
+        return authors.length > 0 ? authors : void 0;
+      }
+      // Extract formula relationships for enhanced formula preservation
+      extractFormulaRelationships(worksheet) {
+        const relationships = [];
+        const cellAddresses = Object.keys(worksheet).filter((addr) => addr.match(/^[A-Z]+\d+$/));
+        for (const cellAddr of cellAddresses) {
+          const cell = worksheet[cellAddr];
+          if (cell && cell.f) {
+            const dependencies = this.extractFormulaDependencies(cell.f);
+            const targetCells = this.findReferencingCells(worksheet, cellAddr);
+            relationships.push({
+              sourceCell: cellAddr,
+              targetCells,
+              formula: cell.f,
+              dependencies
+            });
+          }
+        }
+        return relationships;
+      }
+      // Extract dependencies from formula string
+      extractFormulaDependencies(formula) {
+        const cellRefRegex = /\b[A-Z]+\d+\b/g;
+        const matches = formula.match(cellRefRegex);
+        return matches ? Array.from(new Set(matches)) : [];
+      }
+      // Find cells that reference the given cell
+      findReferencingCells(worksheet, targetCell) {
+        const referencingCells = [];
+        const cellAddresses = Object.keys(worksheet).filter((addr) => addr.match(/^[A-Z]+\d+$/));
+        for (const cellAddr of cellAddresses) {
+          const cell = worksheet[cellAddr];
+          if (cell && cell.f) {
+            const dependencies = this.extractFormulaDependencies(cell.f);
+            if (dependencies.includes(targetCell)) {
+              referencingCells.push(cellAddr);
+            }
+          }
+        }
+        return referencingCells;
+      }
+      // Extract table information from worksheet
+      extractTableInfo(worksheet) {
+        const tables = [];
+        if (worksheet["!ref"]) {
+          const range = XLSX.utils.decode_range(worksheet["!ref"]);
+          const hasHeaders = this.detectHeaders(worksheet, range);
+          if (hasHeaders) {
+            const headers = this.extractTableHeaders(worksheet, range);
+            tables.push({
+              range: worksheet["!ref"],
+              headers,
+              columnCount: range.e.c - range.s.c + 1,
+              rowCount: range.e.r - range.s.r + 1,
+              hasFilters: false,
+              // Could be enhanced to detect actual filters
+              hasTotalsRow: false
+              // Could be enhanced to detect totals
+            });
+          }
+        }
+        return tables;
+      }
+      // Extract chart information (basic implementation)
+      extractChartInfo(worksheet) {
+        return [];
+      }
+      // Extract sheet-level revision history
+      extractSheetRevisionHistory(worksheet) {
+        return void 0;
+      }
+      // Detect if worksheet has headers
+      detectHeaders(worksheet, range) {
+        for (let col = range.s.c; col <= range.e.c; col++) {
+          const cellAddr = XLSX.utils.encode_cell({ r: range.s.r, c: col });
+          const cell = worksheet[cellAddr];
+          if (cell && typeof cell.v === "string") {
+            return true;
+          }
+        }
+        return false;
+      }
+      // Extract table headers from first row
+      extractTableHeaders(worksheet, range) {
+        const headers = [];
+        for (let col = range.s.c; col <= range.e.c; col++) {
+          const cellAddr = XLSX.utils.encode_cell({ r: range.s.r, c: col });
+          const cell = worksheet[cellAddr];
+          headers.push(cell ? String(cell.v || `Column ${col + 1}`) : `Column ${col + 1}`);
+        }
+        return headers;
+      }
+      // Streaming CSV parser for large files
+      async parseCsvFileStreaming(filePath, delimiter2 = ",") {
+        return new Promise((resolve19, reject) => {
+          const data = [];
+          const fileStream = fs24.createReadStream(filePath);
+          let rowCount = 0;
+          const chunkSize = this.config.chunkSize || 1e3;
+          fileStream.pipe(parse3({
+            delimiter: delimiter2,
+            skip_empty_lines: true,
+            trim: true
+          })).on("data", (row) => {
+            if (rowCount % chunkSize === 0) {
+              this.reportProgress("processing", "CSV Data", 0, 1, rowCount, rowCount);
+              if (this.memoryTracker.isMemoryLimitApproached()) {
+                this.memoryTracker.forceGC();
+              }
+              if (this.memoryTracker.isMemoryLimitExceeded()) {
+                reject(new Error(`Memory limit exceeded while processing CSV: ${this.memoryTracker.getCurrentUsage()}MB`));
+                return;
+              }
+            }
+            const rowData = row.map((cell) => ({
+              value: this.parseValue(cell),
+              type: this.inferType(cell)
+            }));
+            data.push(rowData);
+            rowCount++;
+          }).on("end", () => {
+            const sheetData = {
+              name: "Sheet1",
+              data,
+              range: `A1:${XLSX.utils.encode_cell({ r: data.length - 1, c: Math.max(0, (data[0]?.length || 1) - 1) })}`,
+              rowCount: data.length,
+              columnCount: data[0]?.length || 0
+            };
+            resolve19({
+              sheets: { "Sheet1": sheetData }
+            });
+          }).on("error", reject);
+        });
+      }
       updateConfig(newConfig) {
         this.config = { ...this.config, ...newConfig };
       }
       getConfig() {
         return { ...this.config };
       }
+      // New method: Generate Excel file (round-trip functionality)
+      async generateExcel(data, outputPath) {
+        const workbook = XLSX.utils.book_new();
+        for (const [sheetName, sheetData] of Object.entries(data.sheets)) {
+          const worksheet = XLSX.utils.aoa_to_sheet(sheetData.data.map((row) => row.map((cell) => cell.value)));
+          if (sheetData.data.some((row) => row.some((cell) => cell.formula))) {
+            sheetData.data.forEach((row, rowIndex) => {
+              row.forEach((cell, colIndex) => {
+                if (cell.formula) {
+                  const cellAddr = XLSX.utils.encode_cell({ r: rowIndex, c: colIndex });
+                  worksheet[cellAddr] = { ...worksheet[cellAddr], f: cell.formula };
+                }
+              });
+            });
+          }
+          XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+        }
+        if (data.metadata) {
+          workbook.Props = {
+            Title: data.metadata.title,
+            Author: data.metadata.author,
+            Subject: data.metadata.subject,
+            CreatedDate: data.metadata.created,
+            ModifiedDate: data.metadata.modified,
+            Application: data.metadata.application
+          };
+        }
+        XLSX.writeFile(workbook, outputPath);
+      }
     };
   }
 });
@@ -117857,11 +118221,11 @@ var require_pdf_worker = __commonJS({
                 cleanup: function Catalog_cleanup() {
                   var _this = this;
                   this.pageKidsCountCache.clear();
-                  var promises3 = [];
+                  var promises4 = [];
                   this.fontCache.forEach(function(promise2) {
-                    promises3.push(promise2);
+                    promises4.push(promise2);
                   });
-                  return Promise.all(promises3).then(function(translatedFonts) {
+                  return Promise.all(promises4).then(function(translatedFonts) {
                     for (var i = 0, ii = translatedFonts.length; i < ii; i++) {
                       var font = translatedFonts[i].dict;
                       delete font.translated;
@@ -180061,11 +180425,11 @@ var require_pdf_worker2 = __commonJS({
                 cleanup: function Catalog_cleanup() {
                   var _this = this;
                   this.pageKidsCountCache.clear();
-                  var promises3 = [];
+                  var promises4 = [];
                   this.fontCache.forEach(function(promise2) {
-                    promises3.push(promise2);
+                    promises4.push(promise2);
                   });
-                  return Promise.all(promises3).then(function(translatedFonts) {
+                  return Promise.all(promises4).then(function(translatedFonts) {
                     for (var i = 0, ii = translatedFonts.length; i < ii; i++) {
                       var font = translatedFonts[i].dict;
                       delete font.translated;
@@ -252287,11 +252651,11 @@ var require_pdf_worker3 = __commonJS({
                 cleanup: function Catalog_cleanup() {
                   var _this = this;
                   this.pageKidsCountCache.clear();
-                  var promises3 = [];
+                  var promises4 = [];
                   this.fontCache.forEach(function(promise2) {
-                    promises3.push(promise2);
+                    promises4.push(promise2);
                   });
-                  return Promise.all(promises3).then(function(translatedFonts) {
+                  return Promise.all(promises4).then(function(translatedFonts) {
                     for (var i = 0, ii = translatedFonts.length; i < ii; i++) {
                       var font = translatedFonts[i].dict;
                       delete font.translated;
@@ -270802,13 +271166,13 @@ var require_pdf_worker3 = __commonJS({
                     this._reject(e2);
                   }
                 };
-                Promise2.all = function Promise_all(promises3) {
+                Promise2.all = function Promise_all(promises4) {
                   var resolveAll, rejectAll;
                   var deferred = new Promise2(function(resolve20, reject2) {
                     resolveAll = resolve20;
                     rejectAll = reject2;
                   });
-                  var unresolved = promises3.length;
+                  var unresolved = promises4.length;
                   var results = [];
                   if (unresolved === 0) {
                     resolveAll(results);
@@ -270821,8 +271185,8 @@ var require_pdf_worker3 = __commonJS({
                     results = [];
                     rejectAll(reason);
                   }
-                  for (var i = 0, ii = promises3.length; i < ii; ++i) {
-                    var promise2 = promises3[i];
+                  for (var i = 0, ii = promises4.length; i < ii; ++i) {
+                    var promise2 = promises4[i];
                     var resolve19 = /* @__PURE__ */ (function(i2) {
                       return function(value) {
                         if (deferred._status === STATUS_REJECTED) {
@@ -284368,13 +284732,13 @@ var require_pdf3 = __commonJS({
                     this._reject(e2);
                   }
                 };
-                Promise2.all = function Promise_all(promises3) {
+                Promise2.all = function Promise_all(promises4) {
                   var resolveAll, rejectAll;
                   var deferred = new Promise2(function(resolve20, reject2) {
                     resolveAll = resolve20;
                     rejectAll = reject2;
                   });
-                  var unresolved = promises3.length;
+                  var unresolved = promises4.length;
                   var results = [];
                   if (unresolved === 0) {
                     resolveAll(results);
@@ -284387,8 +284751,8 @@ var require_pdf3 = __commonJS({
                     results = [];
                     rejectAll(reason);
                   }
-                  for (var i = 0, ii = promises3.length; i < ii; ++i) {
-                    var promise2 = promises3[i];
+                  for (var i = 0, ii = promises4.length; i < ii; ++i) {
+                    var promise2 = promises4[i];
                     var resolve19 = /* @__PURE__ */ (function(i2) {
                       return function(value) {
                         if (deferred._status === STATUS_REJECTED) {
@@ -294178,11 +294542,11 @@ var require_pdf_worker4 = __commonJS({
                 cleanup: function Catalog_cleanup() {
                   var _this = this;
                   this.pageKidsCountCache.clear();
-                  var promises3 = [];
+                  var promises4 = [];
                   this.fontCache.forEach(function(promise2) {
-                    promises3.push(promise2);
+                    promises4.push(promise2);
                   });
-                  return Promise.all(promises3).then(function(translatedFonts) {
+                  return Promise.all(promises4).then(function(translatedFonts) {
                     for (var i = 0, ii = translatedFonts.length; i < ii; i++) {
                       var font = translatedFonts[i].dict;
                       delete font.translated;
@@ -349522,9 +349886,7 @@ var init_gitService = __esm({
 });
 
 // packages/core/dist/src/telemetry/index.js
-import { SpanStatusCode, ValueType as ValueType2 } from "@opentelemetry/api";
-import { SemanticAttributes as SemanticAttributes2 } from "@opentelemetry/semantic-conventions";
-var TelemetryTarget, DEFAULT_TELEMETRY_TARGET, DEFAULT_OTLP_ENDPOINT;
+var TelemetryTarget, DEFAULT_TELEMETRY_TARGET, DEFAULT_OTLP_ENDPOINT, SpanStatusCode, ValueType2, SemanticAttributes2;
 var init_telemetry = __esm({
   "packages/core/dist/src/telemetry/index.js"() {
     "use strict";
@@ -349539,6 +349901,20 @@ var init_telemetry = __esm({
     })(TelemetryTarget || (TelemetryTarget = {}));
     DEFAULT_TELEMETRY_TARGET = TelemetryTarget.LOCAL;
     DEFAULT_OTLP_ENDPOINT = "http://localhost:4317";
+    try {
+      const otelApi = __require("@opentelemetry/api");
+      SpanStatusCode = otelApi.SpanStatusCode;
+      ValueType2 = otelApi.ValueType;
+    } catch (error) {
+      SpanStatusCode = { OK: 1, ERROR: 2 };
+      ValueType2 = { INT: "int", DOUBLE: "double" };
+    }
+    try {
+      const otelSemanticConventions = __require("@opentelemetry/semantic-conventions");
+      SemanticAttributes2 = otelSemanticConventions.SemanticAttributes;
+    } catch (error) {
+      SemanticAttributes2 = {};
+    }
   }
 });
 
@@ -351599,6 +351975,7 @@ var init_projectSummary = __esm({
   "packages/core/dist/src/utils/projectSummary.js"() {
     "use strict";
     init_paths();
+    init_fallback_metrics();
     execAsync2 = promisify3(exec3);
     ProjectSummaryParser = class {
       gitStatusCache = /* @__PURE__ */ new Map();
@@ -351612,7 +351989,7 @@ var init_projectSummary = __esm({
        */
       async getProjectSummary(workingDir = process.cwd()) {
         const projectHash = getProjectHash(workingDir);
-        const projectDir = path43.join(FSS_LINK_DIR, "tmp", projectHash);
+        const projectDir = getProjectTempDir(workingDir);
         try {
           const logsFile = path43.join(projectDir, "logs.json");
           const logsExist = await this.fileExists(logsFile);
@@ -351806,13 +352183,26 @@ var init_projectSummary = __esm({
         return void 0;
       }
       /**
-       * Calculate efficiency rating based on session patterns
+       * Calculate efficiency rating based on session patterns and metrics data
        */
       calculateEfficiency(sessions, activeSessions) {
         if (sessions.length === 0)
           return "normal";
         const avgMessagesPerSession = sessions.reduce((acc, s2) => acc + s2.messageCount, 0) / sessions.length;
         const recentActivityRatio = activeSessions / Math.max(sessions.length, 1);
+        try {
+          const efficiencyMetrics = fallbackMetrics.getEfficiencyMetrics();
+          if (efficiencyMetrics.totalInteractions > 0) {
+            const toolSuccessRate = efficiencyMetrics.toolSuccessRate;
+            const apiErrorRate = efficiencyMetrics.apiErrorRate;
+            if (toolSuccessRate > 80 && apiErrorRate < 5 && recentActivityRatio > 0.5)
+              return "high";
+            if (toolSuccessRate < 50 || apiErrorRate > 20)
+              return "low";
+            return recentActivityRatio > 0.2 ? "normal" : "low";
+          }
+        } catch (error) {
+        }
         if (avgMessagesPerSession > 10 && recentActivityRatio > 0.5)
           return "high";
         if (avgMessagesPerSession < 3 || recentActivityRatio < 0.1)
@@ -351820,9 +352210,25 @@ var init_projectSummary = __esm({
         return "normal";
       }
       /**
-       * Generate recent activity summary
+       * Generate recent activity summary with enhanced metrics awareness
        */
       generateRecentActivity(activeSessions, totalSessions, timeAgo) {
+        try {
+          const metrics2 = fallbackMetrics.getMetrics();
+          const totalTools = metrics2.toolCalls.total;
+          const totalApiCalls = metrics2.api.requests;
+          if (activeSessions > 1) {
+            const toolInfo = totalTools > 0 ? `, ${totalTools} tools used` : "";
+            return `${activeSessions} agents active${toolInfo}, last work ${timeAgo || "recently"}`;
+          } else if (activeSessions === 1) {
+            const activityInfo = totalApiCalls > 0 ? `, ${totalApiCalls} API calls` : "";
+            return `1 active session${activityInfo}, last work ${timeAgo || "recently"}`;
+          } else {
+            const sessionInfo = totalSessions > 1 ? `${totalSessions} total sessions` : "Previous session";
+            return `${sessionInfo}, last work ${timeAgo || "some time ago"}`;
+          }
+        } catch (error) {
+        }
         if (activeSessions > 1) {
           return `${activeSessions} agents active, last work ${timeAgo || "recently"}`;
         } else if (activeSessions === 1) {
@@ -351832,9 +352238,16 @@ var init_projectSummary = __esm({
         }
       }
       /**
-       * Generate token efficiency summary
+       * Generate token efficiency summary using real metrics data when available
        */
       generateTokenEfficiency(logs2) {
+        try {
+          const tokenEfficiencyStr = fallbackMetrics.getTokenEfficiencyString();
+          if (tokenEfficiencyStr !== "No token usage recorded") {
+            return tokenEfficiencyStr;
+          }
+        } catch (error) {
+        }
         const messageCount = logs2.length;
         const estimatedTokens = messageCount * 50;
         if (messageCount === 0)
@@ -354868,7 +355281,7 @@ var require_utils3 = __commonJS({
 var require_scan = __commonJS({
   "node_modules/picomatch/lib/scan.js"(exports, module) {
     "use strict";
-    var utils = require_utils3();
+    var utils2 = require_utils3();
     var {
       CHAR_ASTERISK: CHAR_ASTERISK2,
       /* * */
@@ -355129,9 +355542,9 @@ var require_scan = __commonJS({
         }
       }
       if (opts.unescape === true) {
-        if (glob2) glob2 = utils.removeBackslashes(glob2);
+        if (glob2) glob2 = utils2.removeBackslashes(glob2);
         if (base && backslashes === true) {
-          base = utils.removeBackslashes(base);
+          base = utils2.removeBackslashes(base);
         }
       }
       const state = {
@@ -355199,7 +355612,7 @@ var require_parse2 = __commonJS({
   "node_modules/picomatch/lib/parse.js"(exports, module) {
     "use strict";
     var constants2 = require_constants();
-    var utils = require_utils3();
+    var utils2 = require_utils3();
     var {
       MAX_LENGTH,
       POSIX_REGEX_SOURCE,
@@ -355216,7 +355629,7 @@ var require_parse2 = __commonJS({
       try {
         new RegExp(value);
       } catch (ex) {
-        return args.map((v) => utils.escapeRegex(v)).join("..");
+        return args.map((v) => utils2.escapeRegex(v)).join("..");
       }
       return value;
     };
@@ -355282,7 +355695,7 @@ var require_parse2 = __commonJS({
         globstar: false,
         tokens
       };
-      input = utils.removePrefix(input, state);
+      input = utils2.removePrefix(input, state);
       len = input.length;
       const extglobs = [];
       const braces = [];
@@ -355421,7 +355834,7 @@ var require_parse2 = __commonJS({
           state.output = input;
           return state;
         }
-        state.output = utils.wrapOutput(output, state, options3);
+        state.output = utils2.wrapOutput(output, state, options3);
         return state;
       }
       while (!eos()) {
@@ -355497,7 +355910,7 @@ var require_parse2 = __commonJS({
           continue;
         }
         if (state.quotes === 1 && value !== '"') {
-          value = utils.escapeRegex(value);
+          value = utils2.escapeRegex(value);
           prev.value += value;
           append({ value });
           continue;
@@ -355558,10 +355971,10 @@ var require_parse2 = __commonJS({
           }
           prev.value += value;
           append({ value });
-          if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+          if (opts.literalBrackets === false || utils2.hasRegexChars(prevValue)) {
             continue;
           }
-          const escaped = utils.escapeRegex(prev.value);
+          const escaped = utils2.escapeRegex(prev.value);
           state.output = state.output.slice(0, -prev.value.length);
           if (opts.literalBrackets === true) {
             state.output += escaped;
@@ -355866,17 +356279,17 @@ var require_parse2 = __commonJS({
       }
       while (state.brackets > 0) {
         if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
-        state.output = utils.escapeLast(state.output, "[");
+        state.output = utils2.escapeLast(state.output, "[");
         decrement("brackets");
       }
       while (state.parens > 0) {
         if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
-        state.output = utils.escapeLast(state.output, "(");
+        state.output = utils2.escapeLast(state.output, "(");
         decrement("parens");
       }
       while (state.braces > 0) {
         if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
-        state.output = utils.escapeLast(state.output, "{");
+        state.output = utils2.escapeLast(state.output, "{");
         decrement("braces");
       }
       if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
@@ -355951,7 +356364,7 @@ var require_parse2 = __commonJS({
           }
         }
       };
-      const output = utils.removePrefix(input, state);
+      const output = utils2.removePrefix(input, state);
       let source2 = create(output);
       if (source2 && opts.strictSlashes !== true) {
         source2 += `${SLASH_LITERAL}?`;
@@ -355968,7 +356381,7 @@ var require_picomatch = __commonJS({
     "use strict";
     var scan = require_scan();
     var parse6 = require_parse2();
-    var utils = require_utils3();
+    var utils2 = require_utils3();
     var constants2 = require_constants();
     var isObject2 = (val) => val && typeof val === "object" && !Array.isArray(val);
     var picomatch3 = (glob2, options3, returnState = false) => {
@@ -356032,7 +356445,7 @@ var require_picomatch = __commonJS({
         return { isMatch: false, output: "" };
       }
       const opts = options3 || {};
-      const format = opts.format || (posix2 ? utils.toPosixSlashes : null);
+      const format = opts.format || (posix2 ? utils2.toPosixSlashes : null);
       let match2 = input === glob2;
       let output = match2 && format ? format(input) : input;
       if (match2 === false) {
@@ -356050,7 +356463,7 @@ var require_picomatch = __commonJS({
     };
     picomatch3.matchBase = (input, glob2, options3) => {
       const regex = glob2 instanceof RegExp ? glob2 : picomatch3.makeRe(glob2, options3);
-      return regex.test(utils.basename(input));
+      return regex.test(utils2.basename(input));
     };
     picomatch3.isMatch = (str3, patterns, options3) => picomatch3(patterns, options3)(str3);
     picomatch3.parse = (pattern, options3) => {
@@ -356107,10 +356520,10 @@ var require_picomatch2 = __commonJS({
   "node_modules/picomatch/index.js"(exports, module) {
     "use strict";
     var pico = require_picomatch();
-    var utils = require_utils3();
+    var utils2 = require_utils3();
     function picomatch3(glob2, options3, returnState = false) {
       if (options3 && (options3.windows === null || options3.windows === void 0)) {
-        options3 = { ...options3, windows: utils.isWindows() };
+        options3 = { ...options3, windows: utils2.isWindows() };
       }
       return pico(glob2, options3, returnState);
     }
@@ -368890,9 +369303,7 @@ var QueryOptimizer = class {
    * Execute a query and return a single result
    */
   async executeQuerySingle(db, query, params = []) {
-    return this.executeOptimized(db, query, params, (stmt) => {
-      return stmt.step() ? stmt.getAsObject() : null;
-    });
+    return this.executeOptimized(db, query, params, (stmt) => stmt.step() ? stmt.getAsObject() : null);
   }
   /**
    * Execute a modification query (INSERT, UPDATE, DELETE)
@@ -369959,9 +370370,7 @@ var DatabaseSchemaValidator = class {
    * Check if column types are compatible
    */
   isTypeCompatible(expected, actual) {
-    const normalizeType = (type2) => {
-      return type2.toUpperCase().replace(/\(\d+\)/g, "").replace(/\s+/g, " ").trim();
-    };
+    const normalizeType = (type2) => type2.toUpperCase().replace(/\(\d+\)/g, "").replace(/\s+/g, " ").trim();
     const expectedNorm = normalizeType(expected);
     const actualNorm = normalizeType(actual);
     if (expectedNorm === actualNorm) return true;
@@ -370507,7 +370916,7 @@ var FSSLinkDatabase = class {
         defaultGeminiConfig.created_at
       ]);
       const defaultLMStudioConfig = {
-        auth_type: "lm_studio",
+        auth_type: "lm-studio",
         model_name: "qwen3-coder:latest",
         endpoint_url: "http://localhost:1234/v1",
         api_key: null,
@@ -370590,11 +370999,11 @@ var FSSLinkDatabase = class {
     if ((activeResult?.count || 0) === 0) {
       const bestModel = safeQueryFirst(this.db, `
         SELECT id FROM model_configs 
-        WHERE auth_type IN ('ollama', 'lmstudio', 'gemini-api-key', 'openai-api-key')
+        WHERE auth_type IN ('ollama', 'lm-studio', 'gemini-api-key', 'openai-api-key')
         ORDER BY 
           CASE auth_type 
             WHEN 'ollama' THEN 1 
-            WHEN 'lmstudio' THEN 2 
+            WHEN 'lm-studio' THEN 2 
             WHEN 'gemini-api-key' THEN 3 
             WHEN 'openai-api-key' THEN 4 
             ELSE 5 
@@ -370837,18 +371246,14 @@ var FSSLinkDatabase = class {
    */
   async getSchemaVersion() {
     await this.ensureInitialized();
-    return await this.pool.withConnection(async (db) => {
-      return this.migrationManager.getCurrentVersion(db);
-    });
+    return await this.pool.withConnection(async (db) => this.migrationManager.getCurrentVersion(db));
   }
   /**
    * Get migration history
    */
   async getMigrationHistory() {
     await this.ensureInitialized();
-    return await this.pool.withConnection(async (db) => {
-      return this.migrationManager.getMigrationHistory(db);
-    });
+    return await this.pool.withConnection(async (db) => this.migrationManager.getMigrationHistory(db));
   }
   /**
    * Force database migration (for debugging/maintenance)
@@ -370874,18 +371279,14 @@ var FSSLinkDatabase = class {
    */
   async createBackup(description) {
     await this.ensureInitialized();
-    return await this.pool.withConnection(async (db) => {
-      return this.backupManager.createManualBackup(db, description);
-    });
+    return await this.pool.withConnection(async (db) => this.backupManager.createManualBackup(db, description));
   }
   /**
    * Create an automatic backup
    */
   async createAutoBackup() {
     await this.ensureInitialized();
-    return await this.pool.withConnection(async (db) => {
-      return this.backupManager.createAutoBackup(db);
-    });
+    return await this.pool.withConnection(async (db) => this.backupManager.createAutoBackup(db));
   }
   /**
    * List all available backups
@@ -371174,9 +371575,7 @@ var FSSLinkDatabase = class {
    * Get comprehensive database statistics
    */
   async getDatabaseStats() {
-    return await this.pool.withConnection(async (db) => {
-      return await this.queryOptimizer.getDatabaseStats(db);
-    });
+    return await this.pool.withConnection(async (db) => await this.queryOptimizer.getDatabaseStats(db));
   }
   /**
    * Run VACUUM to reclaim space and defragment
@@ -371190,14 +371589,12 @@ var FSSLinkDatabase = class {
    * Collect comprehensive database metrics
    */
   async collectMetrics() {
-    return await this.pool.withConnection(async (db) => {
-      return await this.metricsCollector.collectMetrics(
-        db,
-        this.queryOptimizer,
-        this.pool,
-        this.backupManager
-      );
-    });
+    return await this.pool.withConnection(async (db) => await this.metricsCollector.collectMetrics(
+      db,
+      this.queryOptimizer,
+      this.pool,
+      this.backupManager
+    ));
   }
   /**
    * Get historical metrics for trend analysis
@@ -371290,41 +371687,31 @@ var FSSLinkDatabase = class {
    * Validate database schema against expected structure
    */
   async validateSchema() {
-    return await this.pool.withConnection(async (db) => {
-      return await this.schemaValidator.validateSchema(db);
-    });
+    return await this.pool.withConnection(async (db) => await this.schemaValidator.validateSchema(db));
   }
   /**
    * Validate specific table schema
    */
   async validateTableSchema(tableName) {
-    return await this.pool.withConnection(async (db) => {
-      return await this.schemaValidator.validateTableSchema(db, tableName);
-    });
+    return await this.pool.withConnection(async (db) => await this.schemaValidator.validateTableSchema(db, tableName));
   }
   /**
    * Check if database needs migration based on schema validation
    */
   async needsSchemaMigration() {
-    return await this.pool.withConnection(async (db) => {
-      return await this.schemaValidator.needsMigration(db);
-    });
+    return await this.pool.withConnection(async (db) => await this.schemaValidator.needsMigration(db));
   }
   /**
    * Get missing tables from schema
    */
   async getMissingTables() {
-    return await this.pool.withConnection(async (db) => {
-      return await this.schemaValidator.getMissingTables(db);
-    });
+    return await this.pool.withConnection(async (db) => await this.schemaValidator.getMissingTables(db));
   }
   /**
    * Get missing indexes from schema
    */
   async getMissingIndexes() {
-    return await this.pool.withConnection(async (db) => {
-      return await this.schemaValidator.getMissingIndexes(db);
-    });
+    return await this.pool.withConnection(async (db) => await this.schemaValidator.getMissingIndexes(db));
   }
   /**
    * Get formatted schema validation report
@@ -372392,13 +372779,13 @@ import {
 import { fileURLToPath as fileURLToPath3 } from "url";
 import path59 from "path";
 var __filename = fileURLToPath3(import.meta.url);
-var __dirname2 = path59.dirname(__filename);
+var __dirname = path59.dirname(__filename);
 var packageJson;
 async function getPackageJson() {
   if (packageJson) {
     return packageJson;
   }
-  const result = await readPackageUp({ cwd: __dirname2 });
+  const result = await readPackageUp({ cwd: __dirname });
   if (!result) {
     return;
   }
@@ -372409,7 +372796,7 @@ async function getPackageJson() {
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "1.0.60";
+  return "1.0.62";
 }
 
 // packages/cli/src/ui/commands/aboutCommand.ts
@@ -372461,7 +372848,7 @@ import open4 from "open";
 import process11 from "node:process";
 
 // packages/cli/src/generated/git-commit.ts
-var GIT_COMMIT_INFO = "786c67ef";
+var GIT_COMMIT_INFO = "81a9bcbc";
 
 // packages/cli/src/ui/commands/bugCommand.ts
 init_dist2();
@@ -394053,8 +394440,8 @@ function ok() {
 }
 
 // node_modules/highlight.js/es/core.js
-var import_core2 = __toESM(require_core3(), 1);
-var core_default = import_core2.default;
+var import_core = __toESM(require_core3(), 1);
+var core_default = import_core.default;
 
 // node_modules/lowlight/lib/index.js
 var emptyOptions = {};
@@ -403901,7 +404288,7 @@ import { exec as exec7, execSync as execSync6, spawn as spawn6 } from "node:chil
 import os29 from "node:os";
 import path78 from "node:path";
 import fs66 from "node:fs";
-import { readFile as readFile11 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 import { promisify as promisify6 } from "util";
 var execAsync5 = promisify6(exec7);
 function getContainerPath(hostPath) {
@@ -403936,7 +404323,7 @@ async function shouldUseCurrentUserInSandbox() {
   }
   if (os29.platform() === "linux") {
     try {
-      const osReleaseContent = await readFile11("/etc/os-release", "utf8");
+      const osReleaseContent = await readFile12("/etc/os-release", "utf8");
       if (osReleaseContent.includes("ID=debian") || osReleaseContent.includes("ID=ubuntu") || osReleaseContent.match(/^ID_LIKE=.*debian.*/m) || // Covers derivatives
       osReleaseContent.match(/^ID_LIKE=.*ubuntu.*/m)) {
         console.error(
@@ -404867,9 +405254,6 @@ async function checkForUpdates() {
   }
 }
 
-// packages/cli/src/gemini.tsx
-init_dist2();
-
 // packages/cli/src/zed-integration/zedIntegration.ts
 init_dist2();