@fuzzle/opencode-accountant 0.4.6-next.1 → 0.4.6

package/dist/index.js

@@ -4222,6 +4222,606 @@ var require_brace_expansion = __commonJS((exports, module) => {
   }
 });
 
+// node_modules/convert-csv-to-json/src/util/fileUtils.js
+var require_fileUtils = __commonJS((exports, module) => {
+  var fs8 = __require("fs");
+
+  class FileUtils {
+    readFile(fileInputName, encoding) {
+      return fs8.readFileSync(fileInputName, encoding).toString();
+    }
+    readFileAsync(fileInputName, encoding = "utf8") {
+      if (fs8.promises && typeof fs8.promises.readFile === "function") {
+        return fs8.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
+      }
+      return new Promise((resolve2, reject) => {
+        fs8.readFile(fileInputName, encoding, (err, data) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve2(data.toString());
+        });
+      });
+    }
+    writeFile(json3, fileOutputName) {
+      fs8.writeFile(fileOutputName, json3, function(err) {
+        if (err) {
+          throw err;
+        } else {
+          console.log("File saved: " + fileOutputName);
+        }
+      });
+    }
+    writeFileAsync(json3, fileOutputName) {
+      if (fs8.promises && typeof fs8.promises.writeFile === "function") {
+        return fs8.promises.writeFile(fileOutputName, json3);
+      }
+      return new Promise((resolve2, reject) => {
+        fs8.writeFile(fileOutputName, json3, (err) => {
+          if (err)
+            return reject(err);
+          resolve2();
+        });
+      });
+    }
+  }
+  module.exports = new FileUtils;
+});
+
+// node_modules/convert-csv-to-json/src/util/stringUtils.js
+var require_stringUtils = __commonJS((exports, module) => {
+  class StringUtils {
+    static PATTERNS = {
+      INTEGER: /^-?\d+$/,
+      FLOAT: /^-?\d*\.\d+$/,
+      WHITESPACE: /\s/g
+    };
+    static BOOLEAN_VALUES = {
+      TRUE: "true",
+      FALSE: "false"
+    };
+    trimPropertyName(shouldTrimAll, propertyName) {
+      if (!propertyName) {
+        return "";
+      }
+      return shouldTrimAll ? propertyName.replace(StringUtils.PATTERNS.WHITESPACE, "") : propertyName.trim();
+    }
+    getValueFormatByType(value) {
+      if (this.isEmpty(value)) {
+        return String();
+      }
+      if (this.isBoolean(value)) {
+        return this.convertToBoolean(value);
+      }
+      if (this.isInteger(value)) {
+        return this.convertInteger(value);
+      }
+      if (this.isFloat(value)) {
+        return this.convertFloat(value);
+      }
+      return String(value);
+    }
+    hasContent(values = []) {
+      return Array.isArray(values) && values.some((value) => Boolean(value));
+    }
+    isEmpty(value) {
+      return value === undefined || value === "";
+    }
+    isBoolean(value) {
+      const normalizedValue = value.toLowerCase();
+      return normalizedValue === StringUtils.BOOLEAN_VALUES.TRUE || normalizedValue === StringUtils.BOOLEAN_VALUES.FALSE;
+    }
+    isInteger(value) {
+      return StringUtils.PATTERNS.INTEGER.test(value);
+    }
+    isFloat(value) {
+      return StringUtils.PATTERNS.FLOAT.test(value);
+    }
+    hasLeadingZero(value) {
+      const isPositiveWithLeadingZero = value.length > 1 && value[0] === "0";
+      const isNegativeWithLeadingZero = value.length > 2 && value[0] === "-" && value[1] === "0";
+      return isPositiveWithLeadingZero || isNegativeWithLeadingZero;
+    }
+    convertToBoolean(value) {
+      return JSON.parse(value.toLowerCase());
+    }
+    convertInteger(value) {
+      if (this.hasLeadingZero(value)) {
+        return String(value);
+      }
+      const num = Number(value);
+      return Number.isSafeInteger(num) ? num : String(value);
+    }
+    convertFloat(value) {
+      const num = Number(value);
+      return Number.isFinite(num) ? num : String(value);
+    }
+  }
+  module.exports = new StringUtils;
+});
+
+// node_modules/convert-csv-to-json/src/util/jsonUtils.js
+var require_jsonUtils = __commonJS((exports, module) => {
+  class JsonUtil {
+    validateJson(json3) {
+      try {
+        JSON.parse(json3);
+      } catch (err) {
+        throw Error(`Parsed csv has generated an invalid json!!!
+` + err);
+      }
+    }
+  }
+  module.exports = new JsonUtil;
+});
+
+// node_modules/convert-csv-to-json/src/csvToJson.js
+var require_csvToJson = __commonJS((exports, module) => {
+  var fileUtils = require_fileUtils();
+  var stringUtils = require_stringUtils();
+  var jsonUtils = require_jsonUtils();
+  var newLine = /\r?\n/;
+  var defaultFieldDelimiter = ";";
+
+  class CsvToJson {
+    formatValueByType(active) {
+      this.printValueFormatByType = active;
+      return this;
+    }
+    supportQuotedField(active) {
+      this.isSupportQuotedField = active;
+      return this;
+    }
+    fieldDelimiter(delimiter) {
+      this.delimiter = delimiter;
+      return this;
+    }
+    trimHeaderFieldWhiteSpace(active) {
+      this.isTrimHeaderFieldWhiteSpace = active;
+      return this;
+    }
+    indexHeader(indexHeaderValue) {
+      if (isNaN(indexHeaderValue)) {
+        throw new Error("The index Header must be a Number!");
+      }
+      this.indexHeaderValue = indexHeaderValue;
+      return this;
+    }
+    parseSubArray(delimiter = "*", separator = ",") {
+      this.parseSubArrayDelimiter = delimiter;
+      this.parseSubArraySeparator = separator;
+    }
+    encoding(encoding) {
+      this.encoding = encoding;
+      return this;
+    }
+    generateJsonFileFromCsv(fileInputName, fileOutputName) {
+      let jsonStringified = this.getJsonFromCsvStringified(fileInputName);
+      fileUtils.writeFile(jsonStringified, fileOutputName);
+    }
+    getJsonFromCsvStringified(fileInputName) {
+      let json3 = this.getJsonFromCsv(fileInputName);
+      let jsonStringified = JSON.stringify(json3, undefined, 1);
+      jsonUtils.validateJson(jsonStringified);
+      return jsonStringified;
+    }
+    getJsonFromCsv(fileInputName) {
+      let parsedCsv = fileUtils.readFile(fileInputName, this.encoding);
+      return this.csvToJson(parsedCsv);
+    }
+    csvStringToJson(csvString) {
+      return this.csvToJson(csvString);
+    }
+    csvStringToJsonStringified(csvString) {
+      let json3 = this.csvStringToJson(csvString);
+      let jsonStringified = JSON.stringify(json3, undefined, 1);
+      jsonUtils.validateJson(jsonStringified);
+      return jsonStringified;
+    }
+    csvToJson(parsedCsv) {
+      this.validateInputConfig();
+      let lines = parsedCsv.split(newLine);
+      let fieldDelimiter = this.getFieldDelimiter();
+      let index = this.getIndexHeader();
+      let headers;
+      if (this.isSupportQuotedField) {
+        headers = this.split(lines[index]);
+      } else {
+        headers = lines[index].split(fieldDelimiter);
+      }
+      while (!stringUtils.hasContent(headers) && index <= lines.length) {
+        index = index + 1;
+        headers = lines[index].split(fieldDelimiter);
+      }
+      let jsonResult = [];
+      for (let i2 = index + 1;i2 < lines.length; i2++) {
+        let currentLine;
+        if (this.isSupportQuotedField) {
+          currentLine = this.split(lines[i2]);
+        } else {
+          currentLine = lines[i2].split(fieldDelimiter);
+        }
+        if (stringUtils.hasContent(currentLine)) {
+          jsonResult.push(this.buildJsonResult(headers, currentLine));
+        }
+      }
+      return jsonResult;
+    }
+    getFieldDelimiter() {
+      if (this.delimiter) {
+        return this.delimiter;
+      }
+      return defaultFieldDelimiter;
+    }
+    getIndexHeader() {
+      if (this.indexHeaderValue !== null && !isNaN(this.indexHeaderValue)) {
+        return this.indexHeaderValue;
+      }
+      return 0;
+    }
+    buildJsonResult(headers, currentLine) {
+      let jsonObject = {};
+      for (let j = 0;j < headers.length; j++) {
+        let propertyName = stringUtils.trimPropertyName(this.isTrimHeaderFieldWhiteSpace, headers[j]);
+        let value = currentLine[j];
+        if (this.isParseSubArray(value)) {
+          value = this.buildJsonSubArray(value);
+        }
+        if (this.printValueFormatByType && !Array.isArray(value)) {
+          value = stringUtils.getValueFormatByType(currentLine[j]);
+        }
+        jsonObject[propertyName] = value;
+      }
+      return jsonObject;
+    }
+    buildJsonSubArray(value) {
+      let extractedValues = value.substring(value.indexOf(this.parseSubArrayDelimiter) + 1, value.lastIndexOf(this.parseSubArrayDelimiter));
+      extractedValues.trim();
+      value = extractedValues.split(this.parseSubArraySeparator);
+      if (this.printValueFormatByType) {
+        for (let i2 = 0;i2 < value.length; i2++) {
+          value[i2] = stringUtils.getValueFormatByType(value[i2]);
+        }
+      }
+      return value;
+    }
+    isParseSubArray(value) {
+      if (this.parseSubArrayDelimiter) {
+        if (value && (value.indexOf(this.parseSubArrayDelimiter) === 0 && value.lastIndexOf(this.parseSubArrayDelimiter) === value.length - 1)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    validateInputConfig() {
+      if (this.isSupportQuotedField) {
+        if (this.getFieldDelimiter() === '"') {
+          throw new Error('When SupportQuotedFields is enabled you cannot defined the field delimiter as quote -> ["]');
+        }
+        if (this.parseSubArraySeparator === '"') {
+          throw new Error('When SupportQuotedFields is enabled you cannot defined the field parseSubArraySeparator as quote -> ["]');
+        }
+        if (this.parseSubArrayDelimiter === '"') {
+          throw new Error('When SupportQuotedFields is enabled you cannot defined the field parseSubArrayDelimiter as quote -> ["]');
+        }
+      }
+    }
+    hasQuotes(line) {
+      return line.includes('"');
+    }
+    split(line) {
+      if (line.length == 0) {
+        return [];
+      }
+      let delim = this.getFieldDelimiter();
+      let subSplits = [""];
+      if (this.hasQuotes(line)) {
+        let chars = line.split("");
+        let subIndex = 0;
+        let startQuote = false;
+        let isDouble = false;
+        chars.forEach((c, i2, arr) => {
+          if (isDouble) {
+            subSplits[subIndex] += c;
+            isDouble = false;
+            return;
+          }
+          if (c != '"' && c != delim) {
+            subSplits[subIndex] += c;
+          } else if (c == delim && startQuote) {
+            subSplits[subIndex] += c;
+          } else if (c == delim) {
+            subIndex++;
+            subSplits[subIndex] = "";
+            return;
+          } else {
+            if (arr[i2 + 1] === '"') {
+              isDouble = true;
+            } else {
+              if (!startQuote) {
+                startQuote = true;
+              } else {
+                startQuote = false;
+              }
+            }
+          }
+        });
+        if (startQuote) {
+          throw new Error("Row contains mismatched quotes!");
+        }
+        return subSplits;
+      } else {
+        return line.split(delim);
+      }
+    }
+  }
+  module.exports = new CsvToJson;
+});
+
+// node_modules/convert-csv-to-json/src/csvToJsonAsync.js
+var require_csvToJsonAsync = __commonJS((exports, module) => {
+  var fileUtils = require_fileUtils();
+  var csvToJson = require_csvToJson();
+
+  class CsvToJsonAsync {
+    constructor() {
+      this.csvToJson = csvToJson;
+    }
+    formatValueByType(active) {
+      this.csvToJson.formatValueByType(active);
+      return this;
+    }
+    supportQuotedField(active) {
+      this.csvToJson.supportQuotedField(active);
+      return this;
+    }
+    fieldDelimiter(delimiter) {
+      this.csvToJson.fieldDelimiter(delimiter);
+      return this;
+    }
+    trimHeaderFieldWhiteSpace(active) {
+      this.csvToJson.trimHeaderFieldWhiteSpace(active);
+      return this;
+    }
+    indexHeader(indexHeader) {
+      this.csvToJson.indexHeader(indexHeader);
+      return this;
+    }
+    parseSubArray(delimiter = "*", separator = ",") {
+      this.csvToJson.parseSubArray(delimiter, separator);
+      return this;
+    }
+    encoding(encoding) {
+      this.csvToJson.encoding = encoding;
+      return this;
+    }
+    async generateJsonFileFromCsv(fileInputName, fileOutputName) {
+      const jsonStringified = await this.getJsonFromCsvStringified(fileInputName);
+      await fileUtils.writeFileAsync(jsonStringified, fileOutputName);
+    }
+    async getJsonFromCsvStringified(fileInputName) {
+      const json3 = await this.getJsonFromCsvAsync(fileInputName);
+      return JSON.stringify(json3, undefined, 1);
+    }
+    async getJsonFromCsvAsync(inputFileNameOrCsv, options = {}) {
+      if (inputFileNameOrCsv === null || inputFileNameOrCsv === undefined) {
+        throw new Error("inputFileNameOrCsv is not defined!!!");
+      }
+      if (options.raw) {
+        if (inputFileNameOrCsv === "") {
+          return [];
+        }
+        return this.csvToJson.csvToJson(inputFileNameOrCsv);
+      }
+      const parsedCsv = await fileUtils.readFileAsync(inputFileNameOrCsv, this.csvToJson.encoding || "utf8");
+      return this.csvToJson.csvToJson(parsedCsv);
+    }
+    csvStringToJsonAsync(csvString, options = { raw: true }) {
+      return this.getJsonFromCsvAsync(csvString, options);
+    }
+    async csvStringToJsonStringifiedAsync(csvString) {
+      const json3 = await this.csvStringToJsonAsync(csvString);
+      return JSON.stringify(json3, undefined, 1);
+    }
+  }
+  module.exports = new CsvToJsonAsync;
+});
+
+// node_modules/convert-csv-to-json/src/browserApi.js
+var require_browserApi = __commonJS((exports, module) => {
+  var csvToJson = require_csvToJson();
+
+  class BrowserApi {
+    constructor() {
+      this.csvToJson = csvToJson;
+    }
+    formatValueByType(active = true) {
+      this.csvToJson.formatValueByType(active);
+      return this;
+    }
+    supportQuotedField(active = false) {
+      this.csvToJson.supportQuotedField(active);
+      return this;
+    }
+    fieldDelimiter(delimiter) {
+      this.csvToJson.fieldDelimiter(delimiter);
+      return this;
+    }
+    trimHeaderFieldWhiteSpace(active = false) {
+      this.csvToJson.trimHeaderFieldWhiteSpace(active);
+      return this;
+    }
+    indexHeader(index) {
+      this.csvToJson.indexHeader(index);
+      return this;
+    }
+    parseSubArray(delimiter = "*", separator = ",") {
+      this.csvToJson.parseSubArray(delimiter, separator);
+      return this;
+    }
+    csvStringToJson(csvString) {
+      if (csvString === undefined || csvString === null) {
+        throw new Error("csvString is not defined!!!");
+      }
+      return this.csvToJson.csvToJson(csvString);
+    }
+    csvStringToJsonStringified(csvString) {
+      if (csvString === undefined || csvString === null) {
+        throw new Error("csvString is not defined!!!");
+      }
+      return this.csvToJson.csvStringToJsonStringified(csvString);
+    }
+    csvStringToJsonAsync(csvString) {
+      return Promise.resolve(this.csvStringToJson(csvString));
+    }
+    csvStringToJsonStringifiedAsync(csvString) {
+      return Promise.resolve(this.csvStringToJsonStringified(csvString));
+    }
+    parseFile(file2, options = {}) {
+      if (!file2) {
+        return Promise.reject(new Error("file is not defined!!!"));
+      }
+      return new Promise((resolve2, reject) => {
+        if (typeof FileReader === "undefined") {
+          reject(new Error("FileReader is not available in this environment"));
+          return;
+        }
+        const reader = new FileReader;
+        reader.onerror = () => reject(reader.error || new Error("Failed to read file"));
+        reader.onload = () => {
+          try {
+            const text = reader.result;
+            const result = this.csvToJson.csvToJson(String(text));
+            resolve2(result);
+          } catch (err) {
+            reject(err);
+          }
+        };
+        if (options.encoding) {
+          reader.readAsText(file2, options.encoding);
+        } else {
+          reader.readAsText(file2);
+        }
+      });
+    }
+  }
+  module.exports = new BrowserApi;
+});
+
+// node_modules/convert-csv-to-json/index.js
+var require_convert_csv_to_json = __commonJS((exports) => {
+  var csvToJson = require_csvToJson();
+  var encodingOps = {
+    utf8: "utf8",
+    ucs2: "ucs2",
+    utf16le: "utf16le",
+    latin1: "latin1",
+    ascii: "ascii",
+    base64: "base64",
+    hex: "hex"
+  };
+  exports.formatValueByType = function(active = true) {
+    csvToJson.formatValueByType(active);
+    return this;
+  };
+  exports.supportQuotedField = function(active = false) {
+    csvToJson.supportQuotedField(active);
+    return this;
+  };
+  exports.fieldDelimiter = function(delimiter) {
+    csvToJson.fieldDelimiter(delimiter);
+    return this;
+  };
+  exports.trimHeaderFieldWhiteSpace = function(active = false) {
+    csvToJson.trimHeaderFieldWhiteSpace(active);
+    return this;
+  };
+  exports.indexHeader = function(index) {
+    csvToJson.indexHeader(index);
+    return this;
+  };
+  exports.parseSubArray = function(delimiter, separator) {
+    csvToJson.parseSubArray(delimiter, separator);
+    return this;
+  };
+  exports.customEncoding = function(encoding) {
+    csvToJson.encoding = encoding;
+    return this;
+  };
+  exports.utf8Encoding = function utf8Encoding() {
+    csvToJson.encoding = encodingOps.utf8;
+    return this;
+  };
+  exports.ucs2Encoding = function() {
+    csvToJson.encoding = encodingOps.ucs2;
+    return this;
+  };
+  exports.utf16leEncoding = function() {
+    csvToJson.encoding = encodingOps.utf16le;
+    return this;
+  };
+  exports.latin1Encoding = function() {
+    csvToJson.encoding = encodingOps.latin1;
+    return this;
+  };
+  exports.asciiEncoding = function() {
+    csvToJson.encoding = encodingOps.ascii;
+    return this;
+  };
+  exports.base64Encoding = function() {
+    this.csvToJson = encodingOps.base64;
+    return this;
+  };
+  exports.hexEncoding = function() {
+    this.csvToJson = encodingOps.hex;
+    return this;
+  };
+  exports.generateJsonFileFromCsv = function(inputFileName, outputFileName) {
+    if (!inputFileName) {
+      throw new Error("inputFileName is not defined!!!");
+    }
+    if (!outputFileName) {
+      throw new Error("outputFileName is not defined!!!");
+    }
+    csvToJson.generateJsonFileFromCsv(inputFileName, outputFileName);
+  };
+  exports.getJsonFromCsv = function(inputFileName) {
+    if (!inputFileName) {
+      throw new Error("inputFileName is not defined!!!");
+    }
+    return csvToJson.getJsonFromCsv(inputFileName);
+  };
+  var csvToJsonAsync = require_csvToJsonAsync();
+  Object.assign(exports, {
+    getJsonFromCsvAsync: function(input, options) {
+      return csvToJsonAsync.getJsonFromCsvAsync(input, options);
+    },
+    csvStringToJsonAsync: function(input, options) {
+      return csvToJsonAsync.csvStringToJsonAsync(input, options);
+    },
+    csvStringToJsonStringifiedAsync: function(input) {
+      return csvToJsonAsync.csvStringToJsonStringifiedAsync(input);
+    },
+    generateJsonFileFromCsvAsync: function(input, output) {
+      return csvToJsonAsync.generateJsonFileFromCsv(input, output);
+    }
+  });
+  exports.csvStringToJson = function(csvString) {
+    return csvToJson.csvStringToJson(csvString);
+  };
+  exports.csvStringToJsonStringified = function(csvString) {
+    if (csvString === undefined || csvString === null) {
+      throw new Error("csvString is not defined!!!");
+    }
+    return csvToJson.csvStringToJsonStringified(csvString);
+  };
+  exports.jsonToCsv = function(inputFileName, outputFileName) {
+    csvToJson.generateJsonFileFromCsv(inputFileName, outputFileName);
+  };
+  exports.browser = require_browserApi();
+});
+
 // src/utils/accountSuggester.ts
 var exports_accountSuggester = {};
 __export(exports_accountSuggester, {
@@ -4314,7 +4914,7 @@ function buildBatchSuggestionPrompt(postings, context) {
     prompt += `## Example Classification Patterns from Rules
 
 `;
-    const sampleSize = Math.min(EXAMPLE_PATTERN_SAMPLE_SIZE, context.existingRules.length);
+    const sampleSize = Math.min(10, context.existingRules.length);
     for (let i2 = 0;i2 < sampleSize; i2++) {
       const pattern = context.existingRules[i2];
       prompt += `- If description matches "${pattern.condition}" \u2192 ${pattern.account}
@@ -4492,7 +5092,7 @@ function generateMockSuggestions(postings) {
   });
   return response;
 }
-var EXAMPLE_PATTERN_SAMPLE_SIZE = 10, suggestionCache;
+var suggestionCache;
 var init_accountSuggester = __esm(() => {
   init_agentLoader();
   suggestionCache = {};
@@ -4500,7 +5100,7 @@ var init_accountSuggester = __esm(() => {
 
 // src/index.ts
 init_agentLoader();
-import { dirname as dirname4, join as join12 } from "path";
+import { dirname as dirname5, join as join12 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // node_modules/zod/v4/classic/external.js
@@ -16825,7 +17425,7 @@ function tool(input) {
 tool.schema = exports_external;
 // src/tools/fetch-currency-prices.ts
 var {$ } = globalThis.Bun;
-import * as path4 from "path";
+import * as path3 from "path";
 
 // src/utils/agentRestriction.ts
 function checkAccountantAgent(agent, toolPrompt, additionalFields) {
@@ -16842,32 +17442,10 @@ function checkAccountantAgent(agent, toolPrompt, additionalFields) {
   return JSON.stringify(errorResponse);
 }
 
-// src/utils/yamlLoader.ts
+// src/utils/pricesConfig.ts
 init_js_yaml();
 import * as fs from "fs";
 import * as path from "path";
-function loadYamlConfig(directory, configFile, validator, notFoundMessage) {
-  const configPath = path.join(directory, configFile);
-  if (!fs.existsSync(configPath)) {
-    throw new Error(notFoundMessage || `Configuration file not found: ${configFile}. Please create this file to configure the feature.`);
-  }
-  let parsed;
-  try {
-    const content = fs.readFileSync(configPath, "utf-8");
-    parsed = jsYaml.load(content);
-  } catch (err) {
-    if (err instanceof jsYaml.YAMLException) {
-      throw new Error(`Failed to parse ${configFile}: ${err.message}`);
-    }
-    throw err;
-  }
-  if (typeof parsed !== "object" || parsed === null) {
-    throw new Error(`Invalid config: ${configFile} must contain a YAML object`);
-  }
-  return validator(parsed);
-}
-
-// src/utils/pricesConfig.ts
 var CONFIG_FILE = "config/prices.yaml";
 var REQUIRED_CURRENCY_FIELDS = ["source", "pair", "file"];
 function getDefaultBackfillDate() {
@@ -16893,84 +17471,48 @@ function validateCurrencyConfig(name, config2) {
   };
 }
 function loadPricesConfig(directory) {
-  return loadYamlConfig(directory, CONFIG_FILE, (parsedObj) => {
-    if (!parsedObj.currencies || typeof parsedObj.currencies !== "object") {
-      throw new Error(`Invalid config: 'currencies' section is required`);
-    }
-    const currenciesObj = parsedObj.currencies;
-    if (Object.keys(currenciesObj).length === 0) {
-      throw new Error(`Invalid config: 'currencies' section must contain at least one currency`);
-    }
-    const currencies = {};
-    for (const [name, config2] of Object.entries(currenciesObj)) {
-      currencies[name] = validateCurrencyConfig(name, config2);
-    }
-    return { currencies };
-  }, `Configuration file not found: ${CONFIG_FILE}. Please refer to the plugin's GitHub repository for setup instructions.`);
-}
-
-// src/utils/journalUtils.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-
-// src/utils/fileUtils.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-function findCsvFiles(baseDir, options = {}) {
-  if (!fs2.existsSync(baseDir)) {
-    return [];
+  const configPath = path.join(directory, CONFIG_FILE);
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${CONFIG_FILE}. Please refer to the plugin's GitHub repository for setup instructions.`);
   }
-  let searchDir = baseDir;
-  if (options.subdir) {
-    searchDir = path2.join(searchDir, options.subdir);
-    if (options.subsubdir) {
-      searchDir = path2.join(searchDir, options.subsubdir);
+  let parsed;
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    parsed = jsYaml.load(content);
+  } catch (err) {
+    if (err instanceof jsYaml.YAMLException) {
+      throw new Error(`Failed to parse ${CONFIG_FILE}: ${err.message}`);
     }
+    throw err;
   }
-  if (!fs2.existsSync(searchDir)) {
-    return [];
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`Invalid config: ${CONFIG_FILE} must contain a YAML object`);
   }
-  const csvFiles = [];
-  if (options.recursive) {
-    let scanDirectory = function(dir) {
-      const entries = fs2.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path2.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          scanDirectory(fullPath);
-        } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".csv")) {
-          csvFiles.push(options.fullPaths ? fullPath : entry.name);
-        }
-      }
-    };
-    scanDirectory(searchDir);
-  } else {
-    const entries = fs2.readdirSync(searchDir);
-    for (const name of entries) {
-      if (!name.toLowerCase().endsWith(".csv"))
-        continue;
-      const fullPath = path2.join(searchDir, name);
-      if (fs2.statSync(fullPath).isFile()) {
-        csvFiles.push(options.fullPaths ? fullPath : name);
-      }
-    }
+  const parsedObj = parsed;
+  if (!parsedObj.currencies || typeof parsedObj.currencies !== "object") {
+    throw new Error(`Invalid config: 'currencies' section is required`);
   }
-  return csvFiles.sort();
-}
-function ensureDirectory(dirPath) {
-  if (!fs2.existsSync(dirPath)) {
-    fs2.mkdirSync(dirPath, { recursive: true });
+  const currenciesObj = parsedObj.currencies;
+  if (Object.keys(currenciesObj).length === 0) {
+    throw new Error(`Invalid config: 'currencies' section must contain at least one currency`);
+  }
+  const currencies = {};
+  for (const [name, config2] of Object.entries(currenciesObj)) {
+    currencies[name] = validateCurrencyConfig(name, config2);
   }
+  return { currencies };
 }
 
 // src/utils/journalUtils.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
 function extractDateFromPriceLine(line) {
   return line.split(" ")[1];
 }
 function updatePriceJournal(journalPath, newPriceLines) {
   let existingLines = [];
-  if (fs3.existsSync(journalPath)) {
-    existingLines = fs3.readFileSync(journalPath, "utf-8").split(`
+  if (fs2.existsSync(journalPath)) {
+    existingLines = fs2.readFileSync(journalPath, "utf-8").split(`
 `).filter((line) => line.trim() !== "");
   }
   const priceMap = new Map;
@@ -16985,25 +17527,54 @@ function updatePriceJournal(journalPath, newPriceLines) {
       priceMap.set(date5, line);
   }
   const sortedLines = Array.from(priceMap.entries()).sort((a, b) => a[0].localeCompare(b[0])).map(([, line]) => line);
-  fs3.writeFileSync(journalPath, sortedLines.join(`
+  fs2.writeFileSync(journalPath, sortedLines.join(`
 `) + `
 `);
 }
+function findCsvFiles(directory, provider, currency) {
+  const csvFiles = [];
+  if (!fs2.existsSync(directory)) {
+    return csvFiles;
+  }
+  let searchPath = directory;
+  if (provider) {
+    searchPath = path2.join(searchPath, provider);
+    if (currency) {
+      searchPath = path2.join(searchPath, currency);
+    }
+  }
+  if (!fs2.existsSync(searchPath)) {
+    return csvFiles;
+  }
+  function scanDirectory(dir) {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scanDirectory(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".csv")) {
+        csvFiles.push(fullPath);
+      }
+    }
+  }
+  scanDirectory(searchPath);
+  return csvFiles.sort();
+}
 function ensureYearJournalExists(directory, year) {
-  const ledgerDir = path3.join(directory, "ledger");
-  const yearJournalPath = path3.join(ledgerDir, `${year}.journal`);
-  const mainJournalPath = path3.join(directory, ".hledger.journal");
-  if (!fs3.existsSync(ledgerDir)) {
-    fs3.mkdirSync(ledgerDir, { recursive: true });
-  }
-  if (!fs3.existsSync(yearJournalPath)) {
-    fs3.writeFileSync(yearJournalPath, `; ${year} transactions
+  const ledgerDir = path2.join(directory, "ledger");
+  const yearJournalPath = path2.join(ledgerDir, `${year}.journal`);
+  const mainJournalPath = path2.join(directory, ".hledger.journal");
+  if (!fs2.existsSync(ledgerDir)) {
+    fs2.mkdirSync(ledgerDir, { recursive: true });
+  }
+  if (!fs2.existsSync(yearJournalPath)) {
+    fs2.writeFileSync(yearJournalPath, `; ${year} transactions
 `);
   }
-  if (!fs3.existsSync(mainJournalPath)) {
+  if (!fs2.existsSync(mainJournalPath)) {
     throw new Error(`.hledger.journal not found at ${mainJournalPath}. Create it first with appropriate includes.`);
   }
-  const mainJournalContent = fs3.readFileSync(mainJournalPath, "utf-8");
+  const mainJournalContent = fs2.readFileSync(mainJournalPath, "utf-8");
   const includeDirective = `include ledger/${year}.journal`;
   const lines = mainJournalContent.split(`
 `);
@@ -17015,7 +17586,7 @@ function ensureYearJournalExists(directory, year) {
     const newContent = mainJournalContent.trimEnd() + `
 ` + includeDirective + `
 `;
-    fs3.writeFileSync(mainJournalPath, newContent);
+    fs2.writeFileSync(mainJournalPath, newContent);
   }
   return yearJournalPath;
 }
@@ -17077,7 +17648,7 @@ function parsePriceLine(line) {
     formattedLine: line
   };
 }
-function filterAndSortPriceLinesByDateRange(priceLines, startDate, endDate) {
+function filterPriceLinesByDateRange(priceLines, startDate, endDate) {
   return priceLines.map(parsePriceLine).filter((parsed) => {
     if (!parsed)
       return false;
@@ -17113,7 +17684,7 @@ async function fetchCurrencyPrices(directory, agent, backfill, priceFetcher = de
         });
         continue;
       }
-      const priceLines = filterAndSortPriceLinesByDateRange(rawPriceLines, startDate, endDate);
+      const priceLines = filterPriceLinesByDateRange(rawPriceLines, startDate, endDate);
       if (priceLines.length === 0) {
         results.push({
           ticker,
@@ -17121,7 +17692,7 @@ async function fetchCurrencyPrices(directory, agent, backfill, priceFetcher = de
         });
         continue;
       }
-      const journalPath = path4.join(directory, "ledger", "currencies", currencyConfig.file);
+      const journalPath = path3.join(directory, "ledger", "currencies", currencyConfig.file);
       updatePriceJournal(journalPath, priceLines);
       const latestPriceLine = priceLines[priceLines.length - 1];
       results.push({
@@ -17154,6 +17725,9 @@ import * as fs5 from "fs";
 import * as path6 from "path";
 
 // src/utils/importConfig.ts
+init_js_yaml();
+import * as fs3 from "fs";
+import * as path4 from "path";
 var CONFIG_FILE2 = "config/import/providers.yaml";
 var REQUIRED_PATH_FIELDS = [
   "import",
@@ -17276,27 +17850,43 @@ function validateProviderConfig(name, config2) {
   return { detect, currencies };
 }
 function loadImportConfig(directory) {
-  return loadYamlConfig(directory, CONFIG_FILE2, (parsedObj) => {
-    if (!parsedObj.paths) {
-      throw new Error("Invalid config: 'paths' section is required");
-    }
-    const paths = validatePaths(parsedObj.paths);
-    if (!parsedObj.providers || typeof parsedObj.providers !== "object") {
-      throw new Error("Invalid config: 'providers' section is required");
-    }
-    const providersObj = parsedObj.providers;
-    if (Object.keys(providersObj).length === 0) {
-      throw new Error("Invalid config: 'providers' section must contain at least one provider");
-    }
-    const providers = {};
-    for (const [name, config2] of Object.entries(providersObj)) {
-      providers[name] = validateProviderConfig(name, config2);
-    }
-    if (!paths.logs) {
-      paths.logs = ".memory";
+  const configPath = path4.join(directory, CONFIG_FILE2);
+  if (!fs3.existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${CONFIG_FILE2}. Please create this file to configure statement imports.`);
+  }
+  let parsed;
+  try {
+    const content = fs3.readFileSync(configPath, "utf-8");
+    parsed = jsYaml.load(content);
+  } catch (err) {
+    if (err instanceof jsYaml.YAMLException) {
+      throw new Error(`Failed to parse ${CONFIG_FILE2}: ${err.message}`);
     }
-    return { paths, providers };
-  }, `Configuration file not found: ${CONFIG_FILE2}. Please create this file to configure statement imports.`);
+    throw err;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`Invalid config: ${CONFIG_FILE2} must contain a YAML object`);
+  }
+  const parsedObj = parsed;
+  if (!parsedObj.paths) {
+    throw new Error("Invalid config: 'paths' section is required");
+  }
+  const paths = validatePaths(parsedObj.paths);
+  if (!parsedObj.providers || typeof parsedObj.providers !== "object") {
+    throw new Error("Invalid config: 'providers' section is required");
+  }
+  const providersObj = parsedObj.providers;
+  if (Object.keys(providersObj).length === 0) {
+    throw new Error("Invalid config: 'providers' section must contain at least one provider");
+  }
+  const providers = {};
+  for (const [name, config2] of Object.entries(providersObj)) {
+    providers[name] = validateProviderConfig(name, config2);
+  }
+  if (!paths.logs) {
+    paths.logs = ".memory";
+  }
+  return { paths, providers };
 }
 
 // src/utils/providerDetector.ts
@@ -17404,83 +17994,22 @@ function detectProvider(filename, content, config2) {
   return null;
 }
 
-// src/utils/importContext.ts
+// src/utils/fileUtils.ts
 import * as fs4 from "fs";
 import * as path5 from "path";
-import { randomUUID } from "crypto";
-function getContextPath(directory, contextId) {
-  return path5.join(directory, ".memory", `${contextId}.json`);
-}
-function ensureMemoryDir(directory) {
-  const memoryDir = path5.join(directory, ".memory");
-  if (!fs4.existsSync(memoryDir)) {
-    fs4.mkdirSync(memoryDir, { recursive: true });
-  }
-}
-function createContext(directory, params) {
-  const now = new Date().toISOString();
-  const context = {
-    id: randomUUID(),
-    createdAt: now,
-    updatedAt: now,
-    filename: params.filename,
-    filePath: params.filePath,
-    provider: params.provider,
-    currency: params.currency,
-    accountNumber: params.accountNumber,
-    originalFilename: params.originalFilename,
-    fromDate: params.fromDate,
-    untilDate: params.untilDate,
-    openingBalance: params.openingBalance,
-    closingBalance: params.closingBalance,
-    account: params.account
-  };
-  ensureMemoryDir(directory);
-  const contextPath = getContextPath(directory, context.id);
-  fs4.writeFileSync(contextPath, JSON.stringify(context, null, 2), "utf-8");
-  return context;
-}
-function validateContext(context, contextId) {
-  const requiredFields = [
-    "id",
-    "filename",
-    "filePath",
-    "provider",
-    "currency"
-  ];
-  for (const field of requiredFields) {
-    if (!context[field]) {
-      throw new Error(`Invalid context ${contextId}: missing required field '${field}'`);
-    }
+function findCSVFiles(importsDir) {
+  if (!fs4.existsSync(importsDir)) {
+    return [];
   }
+  return fs4.readdirSync(importsDir).filter((file2) => file2.toLowerCase().endsWith(".csv")).filter((file2) => {
+    const fullPath = path5.join(importsDir, file2);
+    return fs4.statSync(fullPath).isFile();
+  });
 }
-function loadContext(directory, contextId) {
-  const contextPath = getContextPath(directory, contextId);
-  if (!fs4.existsSync(contextPath)) {
-    throw new Error(`Context not found: ${contextId}`);
-  }
-  const content = fs4.readFileSync(contextPath, "utf-8");
-  let context;
-  try {
-    context = JSON.parse(content);
-  } catch (err) {
-    throw new Error(`Malformed context file ${contextId}: ${err instanceof Error ? err.message : String(err)}`);
+function ensureDirectory(dirPath) {
+  if (!fs4.existsSync(dirPath)) {
+    fs4.mkdirSync(dirPath, { recursive: true });
   }
-  validateContext(context, contextId);
-  return context;
-}
-function updateContext(directory, contextId, updates) {
-  const context = loadContext(directory, contextId);
-  const updatedContext = {
-    ...context,
-    ...updates,
-    id: context.id,
-    createdAt: context.createdAt,
-    updatedAt: new Date().toISOString()
-  };
-  const contextPath = getContextPath(directory, contextId);
-  fs4.writeFileSync(contextPath, JSON.stringify(updatedContext, null, 2), "utf-8");
-  return updatedContext;
 }
 
 // src/tools/classify-statements.ts
@@ -17549,20 +18078,7 @@ function planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2) {
   }
   return { plannedMoves, collisions };
 }
-function extractMetadata2(detection) {
-  const metadata = detection.metadata;
-  if (!metadata) {
-    return {};
-  }
-  return {
-    accountNumber: metadata["account-number"],
-    fromDate: metadata["from-date"],
-    untilDate: metadata["until-date"],
-    openingBalance: metadata["opening-balance"],
-    closingBalance: metadata["closing-balance"]
-  };
-}
-function executeMoves(plannedMoves, config2, unrecognizedDir, directory) {
+function executeMoves(plannedMoves, config2, unrecognizedDir) {
   const classified = [];
   const unrecognized = [];
   for (const move of plannedMoves) {
@@ -17570,27 +18086,12 @@ function executeMoves(plannedMoves, config2, unrecognizedDir, directory) {
       const targetDir = path6.dirname(move.targetPath);
       ensureDirectory(targetDir);
       fs5.renameSync(move.sourcePath, move.targetPath);
-      const targetPath = path6.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename);
-      const metadata = extractMetadata2(move.detection);
-      const context = createContext(directory, {
-        filename: move.targetFilename,
-        filePath: targetPath,
-        provider: move.detection.provider,
-        currency: move.detection.currency,
-        originalFilename: move.detection.outputFilename ? move.filename : undefined,
-        accountNumber: metadata.accountNumber,
-        fromDate: metadata.fromDate,
-        untilDate: metadata.untilDate,
-        openingBalance: metadata.openingBalance,
-        closingBalance: metadata.closingBalance
-      });
       classified.push({
         filename: move.targetFilename,
         originalFilename: move.detection.outputFilename ? move.filename : undefined,
         provider: move.detection.provider,
         currency: move.detection.currency,
-        targetPath,
-        contextId: context.id
+        targetPath: path6.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename)
       });
     } else {
       ensureDirectory(unrecognizedDir);
@@ -17621,7 +18122,7 @@ async function classifyStatements(directory, agent, configLoader = loadImportCon
   const importsDir = path6.join(directory, config2.paths.import);
   const pendingDir = path6.join(directory, config2.paths.pending);
   const unrecognizedDir = path6.join(directory, config2.paths.unrecognized);
-  const csvFiles = findCsvFiles(importsDir);
+  const csvFiles = findCSVFiles(importsDir);
   if (csvFiles.length === 0) {
     return buildSuccessResult2([], [], `No CSV files found in ${config2.paths.import}`);
   }
@@ -17629,19 +18130,11 @@ async function classifyStatements(directory, agent, configLoader = loadImportCon
   if (collisions.length > 0) {
     return buildCollisionError(collisions);
   }
-  const { classified, unrecognized } = executeMoves(plannedMoves, config2, unrecognizedDir, directory);
+  const { classified, unrecognized } = executeMoves(plannedMoves, config2, unrecognizedDir);
   return buildSuccessResult2(classified, unrecognized);
 }
 var classify_statements_default = tool({
-  description: `ACCOUNTANT AGENT ONLY: Classifies bank statement CSV files from the imports directory by detecting their provider and currency, then moves them to the appropriate pending import directories.
-
-For each CSV file:
-- Detects the provider and currency using rules from providers.yaml
-- Creates an import context (.memory/{uuid}.json) to track the file through the pipeline
-- Extracts metadata (account number, dates, balances) from CSV headers
-- Moves the file to import/pending/{provider}/{currency}/
-- Checks for file collisions before any moves (atomic: all-or-nothing)
-- Unrecognized files are moved to import/unrecognized/`,
+  description: "ACCOUNTANT AGENT ONLY: Classifies bank statement CSV files from the imports directory by detecting their provider and currency, then moves them to the appropriate pending import directories.",
   args: {},
   async execute(_params, context) {
     const { directory, agent } = context;
@@ -19981,7 +20474,7 @@ class LRUCache {
 // node_modules/path-scurry/dist/esm/index.js
 import { posix, win32 } from "path";
 import { fileURLToPath } from "url";
-import { lstatSync, readdir as readdirCB, readdirSync as readdirSync2, readlinkSync, realpathSync as rps } from "fs";
+import { lstatSync, readdir as readdirCB, readdirSync as readdirSync3, readlinkSync, realpathSync as rps } from "fs";
 import * as actualFS from "fs";
 import { lstat, readdir, readlink, realpath } from "fs/promises";
 
@@ -20653,7 +21146,7 @@ var realpathSync = rps.native;
 var defaultFS = {
   lstatSync,
   readdir: readdirCB,
-  readdirSync: readdirSync2,
+  readdirSync: readdirSync3,
   readlinkSync,
   realpathSync,
   promises: {
@@ -22963,12 +23456,7 @@ function loadRulesMapping(rulesDir) {
     if (!stat.isFile()) {
       continue;
     }
-    let content;
-    try {
-      content = fs6.readFileSync(rulesFilePath, "utf-8");
-    } catch {
-      continue;
-    }
+    const content = fs6.readFileSync(rulesFilePath, "utf-8");
     const sourcePath = parseSourceDirective(content);
     if (!sourcePath) {
       continue;
@@ -23011,30 +23499,18 @@ function findRulesForCsv(csvPath, mapping) {
 
 // src/utils/hledgerExecutor.ts
 var {$: $2 } = globalThis.Bun;
-var STDERR_TRUNCATE_LENGTH = 500;
 async function defaultHledgerExecutor(cmdArgs) {
   try {
     const result = await $2`hledger ${cmdArgs}`.quiet().nothrow();
-    const stdout = result.stdout.toString();
-    const stderr = result.stderr.toString();
-    if (result.exitCode !== 0 && stderr) {
-      process.stderr.write(`[hledger] command failed (exit ${result.exitCode}): hledger ${cmdArgs.join(" ")}
-`);
-      process.stderr.write(`[hledger] stderr: ${stderr.slice(0, STDERR_TRUNCATE_LENGTH)}
-`);
-    }
     return {
-      stdout,
-      stderr,
+      stdout: result.stdout.toString(),
+      stderr: result.stderr.toString(),
       exitCode: result.exitCode
     };
   } catch (error45) {
-    const errorMessage = error45 instanceof Error ? error45.message : String(error45);
-    process.stderr.write(`[hledger] exception: ${errorMessage}
-`);
     return {
       stdout: "",
-      stderr: errorMessage,
+      stderr: error45 instanceof Error ? error45.message : String(error45),
       exitCode: 1
     };
   }
@@ -23225,7 +23701,7 @@ function parseRulesFile(rulesContent) {
 }
 
 // src/utils/csvParser.ts
-var import_papaparse2 = __toESM(require_papaparse(), 1);
+var import_convert_csv_to_json = __toESM(require_convert_csv_to_json(), 1);
 import * as fs8 from "fs";
 
 // src/utils/balanceUtils.ts
@@ -23274,7 +23750,6 @@ function balancesMatch(balance1, balance2) {
 }
 
 // src/utils/csvParser.ts
-var AMOUNT_MATCH_TOLERANCE = 0.001;
 function parseCsvFile(csvPath, config2) {
   const csvContent = fs8.readFileSync(csvPath, "utf-8");
   const lines = csvContent.split(`
@@ -23283,26 +23758,22 @@ function parseCsvFile(csvPath, config2) {
   if (headerIndex >= lines.length) {
     return [];
   }
-  const csvWithHeader = lines.slice(headerIndex).join(`
+  const headerLine = lines[headerIndex];
+  const dataLines = lines.slice(headerIndex + 1).filter((line) => line.trim() !== "");
+  const csvWithHeader = [headerLine, ...dataLines].join(`
 `);
-  const useFieldNames = config2.fieldNames.length > 0;
-  const result = import_papaparse2.default.parse(csvWithHeader, {
-    header: !useFieldNames,
-    delimiter: config2.separator,
-    skipEmptyLines: true
-  });
-  if (useFieldNames) {
-    const rawRows = result.data;
-    const dataRows = rawRows.slice(1);
-    return dataRows.map((values) => {
-      const row = {};
-      for (let i2 = 0;i2 < config2.fieldNames.length && i2 < values.length; i2++) {
-        row[config2.fieldNames[i2]] = values[i2];
-      }
-      return row;
-    });
+  const rawRows = import_convert_csv_to_json.default.indexHeader(0).fieldDelimiter(config2.separator).supportQuotedField(true).csvStringToJson(csvWithHeader);
+  const fieldNames = config2.fieldNames.length > 0 ? config2.fieldNames : Object.keys(rawRows[0] || {});
+  const mappedRows = [];
+  for (const parsedRow of rawRows) {
+    const row = {};
+    const values = Object.values(parsedRow);
+    for (let i2 = 0;i2 < fieldNames.length && i2 < values.length; i2++) {
+      row[fieldNames[i2]] = values[i2];
+    }
+    mappedRows.push(row);
   }
-  return result.data;
+  return mappedRows;
 }
 function getRowAmount(row, amountFields) {
   if (amountFields.single) {
@@ -23380,7 +23851,7 @@ function findMatchingCsvRow(posting, csvRows, config2) {
     const rowAmount = getRowAmount(row, config2.amountFields);
     if (rowDate !== posting.date)
       return false;
-    if (Math.abs(rowAmount - postingAmount) > AMOUNT_MATCH_TOLERANCE)
+    if (Math.abs(rowAmount - postingAmount) > 0.001)
       return false;
     return true;
   });
@@ -23414,21 +23885,11 @@ function findMatchingCsvRow(posting, csvRows, config2) {
 
 // src/tools/import-statements.ts
 function buildErrorResult3(error45, hint) {
-  const result = {
+  return JSON.stringify({
     success: false,
     error: error45,
-    hint,
-    files: [],
-    summary: {
-      filesProcessed: 0,
-      filesWithErrors: 0,
-      filesWithoutRules: 0,
-      totalTransactions: 0,
-      matched: 0,
-      unknown: 0
-    }
-  };
-  return JSON.stringify(result);
+    hint
+  });
 }
 function buildErrorResultWithDetails(error45, files, summary, hint) {
   return JSON.stringify({
@@ -23607,12 +24068,17 @@ async function importStatements(directory, agent, options, configLoader = loadIm
   const rulesDir = path9.join(directory, config2.paths.rules);
   const doneDir = path9.join(directory, config2.paths.done);
   const rulesMapping = loadRulesMapping(rulesDir);
-  const importContext = loadContext(directory, options.contextId);
-  const csvPath = path9.join(directory, importContext.filePath);
-  if (!fs9.existsSync(csvPath)) {
-    return buildErrorResult3(`CSV file not found: ${importContext.filePath}`, "The file may have been moved or deleted");
+  const csvFiles = findCsvFiles(pendingDir, options.provider, options.currency);
+  if (csvFiles.length === 0) {
+    return buildSuccessResult3([], {
+      filesProcessed: 0,
+      filesWithErrors: 0,
+      filesWithoutRules: 0,
+      totalTransactions: 0,
+      matched: 0,
+      unknown: 0
+    }, "No CSV files found to process");
   }
-  const csvFiles = [csvPath];
   const fileResults = [];
   let totalTransactions = 0;
   let totalMatched = 0;
@@ -23703,16 +24169,6 @@ async function importStatements(directory, agent, options, configLoader = loadIm
       unknown: totalUnknown
     }, importResult.hint);
   }
-  if (fileResults.length > 0) {
-    const firstResult = fileResults[0];
-    const newFilePath = path9.join(config2.paths.done, path9.relative(pendingDir, path9.join(directory, firstResult.csv)));
-    updateContext(directory, options.contextId, {
-      filePath: newFilePath,
-      rulesFile: firstResult.rulesFile || undefined,
-      yearJournal: firstResult.transactionYear ? `ledger/${firstResult.transactionYear}.journal` : undefined,
-      transactionCount: firstResult.totalTransactions
-    });
-  }
   return buildSuccessResult3(fileResults.map((f) => ({
     ...f,
     imported: true
@@ -23748,13 +24204,15 @@ This tool processes CSV files in the pending import directory and uses hledger's
 
 Note: This tool is typically called via import-pipeline for the full workflow.`,
   args: {
-    contextId: tool.schema.string().describe("Context ID from classify step. Used to locate the specific CSV file to process."),
+    provider: tool.schema.string().optional().describe('Filter by provider (e.g., "revolut", "ubs"). If omitted, process all providers.'),
+    currency: tool.schema.string().optional().describe('Filter by currency (e.g., "chf", "eur"). If omitted, process all currencies for the provider.'),
     checkOnly: tool.schema.boolean().optional().describe("If true (default), only check for unknown accounts without importing. Set to false to perform actual import.")
   },
   async execute(params, context) {
     const { directory, agent } = context;
     return importStatements(directory, agent, {
-      contextId: params.contextId,
+      provider: params.provider,
+      currency: params.currency,
       checkOnly: params.checkOnly
     });
   }
@@ -23763,19 +24221,10 @@ Note: This tool is typically called via import-pipeline for the full workflow.`,
 import * as fs10 from "fs";
 import * as path10 from "path";
 function buildErrorResult4(params) {
-  const result = {
+  return JSON.stringify({
     success: false,
-    account: params.account ?? "",
-    expectedBalance: params.expectedBalance ?? "",
-    actualBalance: params.actualBalance ?? "",
-    lastTransactionDate: params.lastTransactionDate ?? "",
-    csvFile: params.csvFile ?? "",
-    difference: params.difference,
-    metadata: params.metadata,
-    error: params.error,
-    hint: params.hint
-  };
-  return JSON.stringify(result);
+    ...params
+  });
 }
 function loadConfiguration(directory, configLoader) {
   try {
@@ -23790,87 +24239,69 @@ function loadConfiguration(directory, configLoader) {
     };
   }
 }
-function verifyCsvExists(directory, importContext) {
-  const csvFile = path10.join(directory, importContext.filePath);
-  if (!fs10.existsSync(csvFile)) {
+function findCsvToReconcile(doneDir, options) {
+  const csvFiles = findCsvFiles(doneDir, options.provider, options.currency);
+  if (csvFiles.length === 0) {
+    const providerFilter = options.provider ? ` --provider=${options.provider}` : "";
+    const currencyFilter = options.currency ? ` --currency=${options.currency}` : "";
     return {
       error: buildErrorResult4({
-        error: `CSV file not found: ${importContext.filePath}`,
-        hint: `The file may have been moved or deleted. Context ID: ${importContext.id}`
+        error: `No CSV files found in ${doneDir}`,
+        hint: `Run: import-statements${providerFilter}${currencyFilter}`
       })
     };
   }
-  return { csvFile, relativePath: importContext.filePath };
-}
-function getBalanceFromContext(importContext) {
-  if (!importContext.closingBalance)
-    return;
-  let balance = importContext.closingBalance;
-  if (importContext.currency && !balance.includes(importContext.currency.toUpperCase())) {
-    balance = `${importContext.currency.toUpperCase()} ${balance}`;
-  }
-  return balance;
-}
-function getBalanceFromCsvMetadata(metadata) {
-  if (!metadata?.["closing-balance"])
-    return;
-  let balance = metadata["closing-balance"];
-  const currency = metadata.currency;
-  if (currency && balance && !balance.includes(currency)) {
-    balance = `${currency} ${balance}`;
-  }
-  return balance;
-}
-function getBalanceFromCsvAnalysis(csvFile, rulesDir) {
-  const csvAnalysis = tryExtractClosingBalanceFromCSV(csvFile, rulesDir);
-  if (csvAnalysis && csvAnalysis.confidence === "high") {
-    return csvAnalysis.balance;
-  }
-  return;
+  const csvFile = csvFiles[csvFiles.length - 1];
+  const relativePath = path10.relative(path10.dirname(path10.dirname(doneDir)), csvFile);
+  return { csvFile, relativePath };
 }
-function extractCsvMetadata(csvFile, config2) {
+function determineClosingBalance(csvFile, config2, options, relativeCsvPath, rulesDir) {
+  let metadata;
   try {
     const content = fs10.readFileSync(csvFile, "utf-8");
     const filename = path10.basename(csvFile);
     const detectionResult = detectProvider(filename, content, config2);
-    if (detectionResult?.metadata) {
-      const m = detectionResult.metadata;
-      return {
-        "from-date": m["from-date"],
-        "until-date": m["until-date"],
-        "opening-balance": m["opening-balance"],
-        "closing-balance": m["closing-balance"],
-        currency: m["currency"],
-        "account-number": m["account-number"]
-      };
+    metadata = detectionResult?.metadata;
+  } catch {
+    metadata = undefined;
+  }
+  let closingBalance = options.closingBalance;
+  if (!closingBalance && metadata?.["closing-balance"]) {
+    const closingBalanceValue = metadata["closing-balance"];
+    const currency = metadata.currency;
+    closingBalance = closingBalanceValue;
+    if (currency && closingBalance && !closingBalance.includes(currency)) {
+      closingBalance = `${currency} ${closingBalance}`;
     }
-  } catch {}
-  return;
-}
-function determineClosingBalance(csvFile, config2, importContext, manualClosingBalance, relativeCsvPath, rulesDir) {
-  const metadata = extractCsvMetadata(csvFile, config2);
-  const closingBalance = manualClosingBalance || getBalanceFromContext(importContext) || getBalanceFromCsvMetadata(metadata);
-  if (closingBalance) {
-    return { closingBalance, metadata };
   }
-  const analysisBalance = getBalanceFromCsvAnalysis(csvFile, rulesDir);
-  if (analysisBalance) {
-    return { closingBalance: analysisBalance, metadata, fromCSVAnalysis: true };
+  if (!closingBalance) {
+    const csvAnalysis = tryExtractClosingBalanceFromCSV(csvFile, rulesDir);
+    if (csvAnalysis && csvAnalysis.confidence === "high") {
+      closingBalance = csvAnalysis.balance;
+      return { closingBalance, metadata, fromCSVAnalysis: true };
+    }
   }
-  const currency = importContext.currency?.toUpperCase() || "CHF";
-  const exampleBalance = `${currency} <amount>`;
-  const retryCmd = buildRetryCommand(importContext.id, exampleBalance);
-  return {
-    error: buildErrorResult4({
-      csvFile: relativeCsvPath,
-      error: "No closing balance found in CSV metadata or data",
-      hint: `Provide closingBalance parameter manually. Example retry: ${retryCmd}`,
-      metadata
-    })
-  };
+  if (!closingBalance) {
+    const retryCmd = buildRetryCommand(options, "CHF 2324.79", options.account);
+    return {
+      error: buildErrorResult4({
+        csvFile: relativeCsvPath,
+        error: "No closing balance found in CSV metadata or data",
+        hint: `Provide closingBalance parameter manually. Example retry: ${retryCmd}`,
+        metadata
+      })
+    };
+  }
+  return { closingBalance, metadata };
 }
-function buildRetryCommand(contextId, closingBalance, account) {
-  const parts = ["reconcile-statement", `--contextId ${contextId}`];
+function buildRetryCommand(options, closingBalance, account) {
+  const parts = ["import-pipeline"];
+  if (options.provider) {
+    parts.push(`--provider ${options.provider}`);
+  }
+  if (options.currency) {
+    parts.push(`--currency ${options.currency}`);
+  }
   if (closingBalance) {
     parts.push(`--closingBalance "${closingBalance}"`);
   }
@@ -23879,17 +24310,19 @@ function buildRetryCommand(contextId, closingBalance, account) {
   }
   return parts.join(" ");
 }
-function determineAccount(csvFile, rulesDir, importContext, manualAccount, relativeCsvPath, metadata) {
-  let account = manualAccount;
-  const rulesMapping = loadRulesMapping(rulesDir);
-  const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+function determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata) {
+  let account = options.account;
   if (!account) {
+    const rulesMapping = loadRulesMapping(rulesDir);
+    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
     if (rulesFile) {
       account = getAccountFromRulesFile(rulesFile) ?? undefined;
     }
   }
   if (!account) {
-    const rulesHint = rulesFile ? `Add 'account1 assets:bank:...' to ${rulesFile} or retry with: ${buildRetryCommand(importContext.id, undefined, "assets:bank:...")}` : `Create a rules file in ${rulesDir} with 'account1' directive or retry with: ${buildRetryCommand(importContext.id, undefined, "assets:bank:...")}`;
+    const rulesMapping = loadRulesMapping(rulesDir);
+    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+    const rulesHint = rulesFile ? `Add 'account1 assets:bank:...' to ${rulesFile} or retry with: ${buildRetryCommand(options, undefined, "assets:bank:...")}` : `Create a rules file in ${rulesDir} with 'account1' directive or retry with: ${buildRetryCommand(options, undefined, "assets:bank:...")}`;
     return {
       error: buildErrorResult4({
         csvFile: relativeCsvPath,
@@ -23970,33 +24403,25 @@ async function reconcileStatement(directory, agent, options, configLoader = load
   if (restrictionError) {
     return restrictionError;
   }
-  let importContext;
-  try {
-    importContext = loadContext(directory, options.contextId);
-  } catch {
-    return buildErrorResult4({
-      error: `Failed to load import context: ${options.contextId}`,
-      hint: "Ensure the context ID is valid and the context file exists in .memory/"
-    });
-  }
   const configResult = loadConfiguration(directory, configLoader);
   if ("error" in configResult) {
     return configResult.error;
   }
   const { config: config2 } = configResult;
+  const doneDir = path10.join(directory, config2.paths.done);
   const rulesDir = path10.join(directory, config2.paths.rules);
   const mainJournalPath = path10.join(directory, ".hledger.journal");
-  const csvResult = verifyCsvExists(directory, importContext);
+  const csvResult = findCsvToReconcile(doneDir, options);
   if ("error" in csvResult) {
     return csvResult.error;
   }
   const { csvFile, relativePath: relativeCsvPath } = csvResult;
-  const balanceResult = determineClosingBalance(csvFile, config2, importContext, options.closingBalance, relativeCsvPath, rulesDir);
+  const balanceResult = determineClosingBalance(csvFile, config2, options, relativeCsvPath, rulesDir);
   if ("error" in balanceResult) {
     return balanceResult.error;
   }
   const { closingBalance, metadata, fromCSVAnalysis } = balanceResult;
-  const accountResult = determineAccount(csvFile, rulesDir, importContext, options.account, relativeCsvPath, metadata);
+  const accountResult = determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata);
   if ("error" in accountResult) {
     return accountResult.error;
   }
@@ -24083,30 +24508,30 @@ var reconcile_statement_default = tool({
 This tool validates that the imported transactions result in the correct closing balance.
 
 **Workflow:**
-1. Loads import context to find the CSV file
-2. Extracts closing balance from context/CSV metadata (or uses manual override)
+1. Finds the most recently imported CSV in the done directory
+2. Extracts closing balance from CSV metadata (or uses manual override)
 3. Determines the account from the matching rules file (or uses manual override)
 4. Queries hledger for the actual balance as of the last transaction date
 5. Compares expected vs actual balance
 
 **Balance Sources:**
-- Automatic: From import context or CSV header metadata (e.g., UBS files have "Closing balance:" row)
+- Automatic: Extracted from CSV header metadata (e.g., UBS files have "Closing balance:" row)
 - Manual: Provided via closingBalance parameter (required for providers like Revolut)
 
 **Account Detection:**
 - Automatic: Parsed from account1 directive in matching rules file
-- Manual: Provided via account parameter
-
-Note: This tool requires a contextId from a prior classify/import step.`,
+- Manual: Provided via account parameter`,
   args: {
-    contextId: tool.schema.string().describe("Context ID from classify/import step (required)"),
+    provider: tool.schema.string().optional().describe('Filter by provider (e.g., "ubs", "revolut")'),
+    currency: tool.schema.string().optional().describe('Filter by currency (e.g., "chf", "eur")'),
     closingBalance: tool.schema.string().optional().describe('Manual closing balance (e.g., "CHF 2324.79"). Required if not in CSV metadata.'),
     account: tool.schema.string().optional().describe('Manual account (e.g., "assets:bank:ubs:checking"). Auto-detected from rules file if not provided.')
   },
   async execute(params, context) {
     const { directory, agent } = context;
     return reconcileStatement(directory, agent, {
-      contextId: params.contextId,
+      provider: params.provider,
+      currency: params.currency,
       closingBalance: params.closingBalance,
       account: params.account
     });
@@ -24233,7 +24658,6 @@ function ensureAccountDeclarations(yearJournalPath, accounts) {
 // src/utils/logger.ts
 import fs12 from "fs/promises";
 import path11 from "path";
-var LOG_LINE_LIMIT = 50;
 
 class MarkdownLogger {
   buffer = [];
@@ -24241,7 +24665,6 @@ class MarkdownLogger {
   context = {};
   autoFlush;
   sectionDepth = 0;
-  pendingFlush = null;
   constructor(config2) {
     this.autoFlush = config2.autoFlush ?? true;
     this.context = config2.context || {};
@@ -24316,9 +24739,9 @@ class MarkdownLogger {
       this.buffer.push("");
       const lines = output.trim().split(`
 `);
-      if (lines.length > LOG_LINE_LIMIT) {
-        this.buffer.push(...lines.slice(0, LOG_LINE_LIMIT));
-        this.buffer.push(`... (${lines.length - LOG_LINE_LIMIT} more lines omitted)`);
+      if (lines.length > 50) {
+        this.buffer.push(...lines.slice(0, 50));
+        this.buffer.push(`... (${lines.length - 50} more lines omitted)`);
       } else {
         this.buffer.push(output.trim());
       }
@@ -24340,9 +24763,6 @@ class MarkdownLogger {
     this.context[key] = value;
   }
   async flush() {
-    if (this.pendingFlush) {
-      await this.pendingFlush;
-    }
     if (this.buffer.length === 0)
       return;
     try {
@@ -24355,7 +24775,7 @@ class MarkdownLogger {
     return this.logPath;
   }
   flushAsync() {
-    this.pendingFlush = this.flush().catch(() => {});
+    this.flush().catch(() => {});
   }
   getTimestamp() {
     return new Date().toISOString().replace(/:/g, "-").split(".")[0];
@@ -24421,28 +24841,16 @@ async function executeClassifyStep(context, logger) {
     logger?.info("Classification skipped (skipClassify: true)");
     context.result.steps.classify = buildStepResult(true, "Classification skipped (skipClassify: true)");
     logger?.endSection();
-    return [];
+    return;
   }
   const classifyResult = await classifyStatements(context.directory, context.agent, context.configLoader);
   const classifyParsed = JSON.parse(classifyResult);
   const success2 = classifyParsed.success !== false;
-  const contextIds = [];
-  if (classifyParsed.classified?.length > 0) {
-    for (const file2 of classifyParsed.classified) {
-      if (file2.contextId) {
-        contextIds.push(file2.contextId);
-      }
-    }
-  }
   let message = success2 ? "Classification complete" : "Classification had issues";
   if (classifyParsed.unrecognized?.length > 0) {
     message = `Classification complete with ${classifyParsed.unrecognized.length} unrecognized file(s)`;
     logger?.warn(`${classifyParsed.unrecognized.length} unrecognized file(s)`);
   }
-  if (contextIds.length > 0) {
-    message += ` (${contextIds.length} context(s) created)`;
-    logger?.info(`Created ${contextIds.length} import context(s)`);
-  }
   logger?.logStep("Classify", success2 ? "success" : "error", message);
   const details = {
     success: success2,
@@ -24450,18 +24858,23 @@ async function executeClassifyStep(context, logger) {
     classified: classifyParsed
   };
   context.result.steps.classify = buildStepResult(success2, message, details);
-  context.result.contexts = contextIds;
   logger?.endSection();
-  return contextIds;
 }
-async function executeAccountDeclarationsStep(context, contextId, logger) {
+async function executeAccountDeclarationsStep(context, logger) {
   logger?.startSection("Step 2: Check Account Declarations");
   logger?.logStep("Check Accounts", "start");
   const config2 = context.configLoader(context.directory);
+  const pendingDir = path12.join(context.directory, config2.paths.pending);
   const rulesDir = path12.join(context.directory, config2.paths.rules);
-  const importCtx = loadContext(context.directory, contextId);
-  const csvPath = path12.join(context.directory, importCtx.filePath);
-  const csvFiles = [csvPath];
+  const csvFiles = findCsvFiles(pendingDir, context.options.provider, context.options.currency);
+  if (csvFiles.length === 0) {
+    context.result.steps.accountDeclarations = buildStepResult(true, "No CSV files to process", {
+      accountsAdded: [],
+      journalUpdated: "",
+      rulesScanned: []
+    });
+    return;
+  }
   const rulesMapping = loadRulesMapping(rulesDir);
   const matchedRulesFiles = new Set;
   for (const csvFile of csvFiles) {
@@ -24536,11 +24949,12 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
   });
   logger?.endSection();
 }
-async function executeDryRunStep(context, contextId, logger) {
+async function executeDryRunStep(context, logger) {
   logger?.startSection("Step 3: Dry Run Import");
   logger?.logStep("Dry Run", "start");
   const dryRunResult = await importStatements(context.directory, context.agent, {
-    contextId,
+    provider: context.options.provider,
+    currency: context.options.currency,
     checkOnly: true
   }, context.configLoader, context.hledgerExecutor);
   const dryRunParsed = JSON.parse(dryRunResult);
@@ -24565,25 +24979,30 @@ async function executeDryRunStep(context, contextId, logger) {
           extractRulePatternsFromFile: extractRulePatternsFromFile2
         } = await Promise.resolve().then(() => (init_accountSuggester(), exports_accountSuggester));
         const config2 = context.configLoader(context.directory);
+        const pendingDir = path12.join(context.directory, config2.paths.pending);
         const rulesDir = path12.join(context.directory, config2.paths.rules);
-        const importCtx = loadContext(context.directory, contextId);
-        const csvPath = path12.join(context.directory, importCtx.filePath);
+        const csvFiles = findCsvFiles(pendingDir, context.options.provider, context.options.currency);
         const rulesMapping = loadRulesMapping(rulesDir);
         let yearJournalPath;
         let firstRulesFile;
-        const rulesFile = findRulesForCsv(csvPath, rulesMapping);
-        if (rulesFile) {
-          firstRulesFile = rulesFile;
-          try {
-            const result = await context.hledgerExecutor(["print", "-f", rulesFile]);
-            if (result.exitCode === 0) {
-              const years = extractTransactionYears(result.stdout);
-              if (years.size > 0) {
-                const transactionYear = Array.from(years)[0];
-                yearJournalPath = ensureYearJournalExists(context.directory, transactionYear);
+        for (const csvFile of csvFiles) {
+          const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+          if (rulesFile) {
+            firstRulesFile = rulesFile;
+            try {
+              const result = await context.hledgerExecutor(["print", "-f", rulesFile]);
+              if (result.exitCode === 0) {
+                const years = extractTransactionYears(result.stdout);
+                if (years.size > 0) {
+                  const transactionYear = Array.from(years)[0];
+                  yearJournalPath = ensureYearJournalExists(context.directory, transactionYear);
+                  break;
+                }
               }
+            } catch {
+              continue;
             }
-          } catch {}
+          }
         }
         const suggestionContext = {
           existingAccounts: yearJournalPath ? await loadExistingAccounts2(yearJournalPath) : [],
@@ -24656,12 +25075,12 @@ function formatUnknownPostingsLog(postings) {
 `;
   return log;
 }
-async function executeImportStep(context, contextId, logger) {
-  const importContext = loadContext(context.directory, contextId);
-  logger?.startSection(`Step 4: Import Transactions (${importContext.accountNumber || contextId})`);
+async function executeImportStep(context, logger) {
+  logger?.startSection("Step 4: Import Transactions");
   logger?.logStep("Import", "start");
   const importResult = await importStatements(context.directory, context.agent, {
-    contextId,
+    provider: context.options.provider,
+    currency: context.options.currency,
     checkOnly: false
   }, context.configLoader, context.hledgerExecutor);
   const importParsed = JSON.parse(importResult);
@@ -24672,13 +25091,6 @@ async function executeImportStep(context, contextId, logger) {
     summary: importParsed.summary,
     error: importParsed.error
   });
-  if (importParsed.success) {
-    updateContext(context.directory, contextId, {
-      rulesFile: importParsed.files?.[0]?.rulesFile,
-      yearJournal: importParsed.files?.[0]?.yearJournal,
-      transactionCount: importParsed.summary?.totalTransactions
-    });
-  }
   if (!importParsed.success) {
     logger?.error("Import failed", new Error(importParsed.error || "Unknown error"));
     logger?.endSection();
@@ -24687,12 +25099,12 @@ async function executeImportStep(context, contextId, logger) {
   }
   logger?.endSection();
 }
-async function executeReconcileStep(context, contextId, logger) {
-  const importContext = loadContext(context.directory, contextId);
-  logger?.startSection(`Step 5: Reconcile Balance (${importContext.accountNumber || contextId})`);
+async function executeReconcileStep(context, logger) {
+  logger?.startSection("Step 5: Reconcile Balance");
   logger?.logStep("Reconcile", "start");
   const reconcileResult = await reconcileStatement(context.directory, context.agent, {
-    contextId,
+    provider: context.options.provider,
+    currency: context.options.currency,
     closingBalance: context.options.closingBalance,
     account: context.options.account
   }, context.configLoader, context.hledgerExecutor);
@@ -24710,14 +25122,6 @@ async function executeReconcileStep(context, contextId, logger) {
     metadata: reconcileParsed.metadata,
     error: reconcileParsed.error
   });
-  if (reconcileParsed.success) {
-    updateContext(context.directory, contextId, {
-      reconciledAccount: reconcileParsed.account,
-      actualBalance: reconcileParsed.actualBalance,
-      lastTransactionDate: reconcileParsed.lastTransactionDate,
-      reconciled: true
-    });
-  }
   if (!reconcileParsed.success) {
     logger?.error("Reconciliation failed", new Error(reconcileParsed.error || "Balance mismatch"));
     logger?.endSection();
@@ -24756,31 +25160,21 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     result
   };
   try {
-    const contextIds = await executeClassifyStep(context, logger);
-    if (contextIds.length === 0) {
-      logger.info("No files classified, nothing to import");
-      return buildSuccessResult4(result, "No files to import");
-    }
-    let totalTransactions = 0;
-    for (const contextId of contextIds) {
-      const importContext = loadContext(context.directory, contextId);
-      logger.info(`Processing: ${importContext.filename} (${importContext.accountNumber || "unknown account"})`);
-      await executeAccountDeclarationsStep(context, contextId, logger);
-      await executeDryRunStep(context, contextId, logger);
-      await executeImportStep(context, contextId, logger);
-      await executeReconcileStep(context, contextId, logger);
-      totalTransactions += context.result.steps.import?.details?.summary?.totalTransactions || 0;
-    }
+    await executeClassifyStep(context, logger);
+    await executeAccountDeclarationsStep(context, logger);
+    await executeDryRunStep(context, logger);
+    await executeImportStep(context, logger);
+    await executeReconcileStep(context, logger);
+    const transactionCount = context.result.steps.import?.details?.summary?.totalTransactions || 0;
     logger.startSection("Summary");
     logger.info(`Import completed successfully`);
-    logger.info(`Contexts processed: ${contextIds.length}`);
-    logger.info(`Total transactions imported: ${totalTransactions}`);
+    logger.info(`Total transactions imported: ${transactionCount}`);
     if (context.result.steps.reconcile?.details?.actualBalance) {
       logger.info(`Balance: ${context.result.steps.reconcile.details.actualBalance}`);
     }
     logger.info(`Log file: ${logger.getLogPath()}`);
     logger.endSection();
-    return buildSuccessResult4(result, `Successfully imported ${totalTransactions} transaction(s) from ${contextIds.length} file(s)`);
+    return buildSuccessResult4(result, `Successfully imported ${transactionCount} transaction(s)`);
   } catch (error45) {
     logger.error("Pipeline step failed", error45);
     logger.info(`Log file: ${logger.getLogPath()}`);
@@ -24967,7 +25361,7 @@ You can now drop CSV files into import/incoming/ and run import-pipeline.`);
   }
 });
 // src/index.ts
-var __dirname2 = dirname4(fileURLToPath3(import.meta.url));
+var __dirname2 = dirname5(fileURLToPath3(import.meta.url));
 var AGENT_FILE = join12(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);