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

package/dist/index.js

@@ -2676,12 +2676,12 @@ var init_js_yaml = __esm(() => {
 });
 
 // src/utils/agentLoader.ts
-import { existsSync, readFileSync } from "fs";
+import * as fs from "fs";
 function loadAgent(filePath) {
-  if (!existsSync(filePath)) {
+  if (!fs.existsSync(filePath)) {
     return null;
   }
-  const content = readFileSync(filePath, "utf-8");
+  const content = fs.readFileSync(filePath, "utf-8");
   const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!match) {
     throw new Error(`Invalid frontmatter format in ${filePath}`);
@@ -4222,606 +4222,6 @@ 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, {
@@ -4831,7 +4231,7 @@ __export(exports_accountSuggester, {
   extractRulePatternsFromFile: () => extractRulePatternsFromFile,
   clearSuggestionCache: () => clearSuggestionCache
 });
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as crypto from "crypto";
 function clearSuggestionCache() {
   Object.keys(suggestionCache).forEach((key) => delete suggestionCache[key]);
@@ -4840,11 +4240,11 @@ function hashTransaction(posting) {
   const data = `${posting.description}|${posting.amount}|${posting.account}`;
   return crypto.createHash("md5").update(data).digest("hex");
 }
-async function loadExistingAccounts(yearJournalPath) {
-  if (!fs13.existsSync(yearJournalPath)) {
+function loadExistingAccounts(yearJournalPath) {
+  if (!fs14.existsSync(yearJournalPath)) {
     return [];
   }
-  const content = fs13.readFileSync(yearJournalPath, "utf-8");
+  const content = fs14.readFileSync(yearJournalPath, "utf-8");
   const lines = content.split(`
 `);
   const accounts = [];
@@ -4859,11 +4259,11 @@ async function loadExistingAccounts(yearJournalPath) {
   }
   return accounts.sort();
 }
-async function extractRulePatternsFromFile(rulesPath) {
-  if (!fs13.existsSync(rulesPath)) {
+function extractRulePatternsFromFile(rulesPath) {
+  if (!fs14.existsSync(rulesPath)) {
     return [];
   }
-  const content = fs13.readFileSync(rulesPath, "utf-8");
+  const content = fs14.readFileSync(rulesPath, "utf-8");
   const lines = content.split(`
 `);
   const patterns = [];
@@ -4914,7 +4314,7 @@ function buildBatchSuggestionPrompt(postings, context) {
     prompt += `## Example Classification Patterns from Rules
 
 `;
-    const sampleSize = Math.min(10, context.existingRules.length);
+    const sampleSize = Math.min(EXAMPLE_PATTERN_SAMPLE_SIZE, context.existingRules.length);
     for (let i2 = 0;i2 < sampleSize; i2++) {
       const pattern = context.existingRules[i2];
       prompt += `- If description matches "${pattern.condition}" \u2192 ${pattern.account}
@@ -5092,7 +4492,7 @@ function generateMockSuggestions(postings) {
   });
   return response;
 }
-var suggestionCache;
+var EXAMPLE_PATTERN_SAMPLE_SIZE = 10, suggestionCache;
 var init_accountSuggester = __esm(() => {
   init_agentLoader();
   suggestionCache = {};
@@ -5100,7 +4500,7 @@ var init_accountSuggester = __esm(() => {
 
 // src/index.ts
 init_agentLoader();
-import { dirname as dirname5, join as join12 } from "path";
+import { dirname as dirname4, join as join12 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // node_modules/zod/v4/classic/external.js
@@ -17425,7 +16825,7 @@ function tool(input) {
 tool.schema = exports_external;
 // src/tools/fetch-currency-prices.ts
 var {$ } = globalThis.Bun;
-import * as path3 from "path";
+import * as path4 from "path";
 
 // src/utils/agentRestriction.ts
 function checkAccountantAgent(agent, toolPrompt, additionalFields) {
@@ -17442,10 +16842,32 @@ function checkAccountantAgent(agent, toolPrompt, additionalFields) {
   return JSON.stringify(errorResponse);
 }
 
-// src/utils/pricesConfig.ts
+// src/utils/yamlLoader.ts
 init_js_yaml();
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as path from "path";
+function loadYamlConfig(directory, configFile, validator, notFoundMessage) {
+  const configPath = path.join(directory, configFile);
+  if (!fs2.existsSync(configPath)) {
+    throw new Error(notFoundMessage || `Configuration file not found: ${configFile}. Please create this file to configure the feature.`);
+  }
+  let parsed;
+  try {
+    const content = fs2.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() {
@@ -17471,48 +16893,84 @@ function validateCurrencyConfig(name, config2) {
   };
 }
 function loadPricesConfig(directory) {
-  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 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}`);
+  return loadYamlConfig(directory, CONFIG_FILE, (parsedObj) => {
+    if (!parsedObj.currencies || typeof parsedObj.currencies !== "object") {
+      throw new Error(`Invalid config: 'currencies' section is required`);
     }
-    throw err;
+    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 fs4 from "fs";
+import * as path3 from "path";
+
+// src/utils/fileUtils.ts
+import * as fs3 from "fs";
+import * as path2 from "path";
+function findCsvFiles(baseDir, options = {}) {
+  if (!fs3.existsSync(baseDir)) {
+    return [];
   }
-  if (typeof parsed !== "object" || parsed === null) {
-    throw new Error(`Invalid config: ${CONFIG_FILE} must contain a YAML object`);
+  let searchDir = baseDir;
+  if (options.subdir) {
+    searchDir = path2.join(searchDir, options.subdir);
+    if (options.subsubdir) {
+      searchDir = path2.join(searchDir, options.subsubdir);
+    }
   }
-  const parsedObj = parsed;
-  if (!parsedObj.currencies || typeof parsedObj.currencies !== "object") {
-    throw new Error(`Invalid config: 'currencies' section is required`);
+  if (!fs3.existsSync(searchDir)) {
+    return [];
   }
-  const currenciesObj = parsedObj.currencies;
-  if (Object.keys(currenciesObj).length === 0) {
-    throw new Error(`Invalid config: 'currencies' section must contain at least one currency`);
+  const csvFiles = [];
+  if (options.recursive) {
+    let scanDirectory = function(dir) {
+      const entries = fs3.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 = fs3.readdirSync(searchDir);
+    for (const name of entries) {
+      if (!name.toLowerCase().endsWith(".csv"))
+        continue;
+      const fullPath = path2.join(searchDir, name);
+      if (fs3.statSync(fullPath).isFile()) {
+        csvFiles.push(options.fullPaths ? fullPath : name);
+      }
+    }
   }
-  const currencies = {};
-  for (const [name, config2] of Object.entries(currenciesObj)) {
-    currencies[name] = validateCurrencyConfig(name, config2);
+  return csvFiles.sort();
+}
+function ensureDirectory(dirPath) {
+  if (!fs3.existsSync(dirPath)) {
+    fs3.mkdirSync(dirPath, { recursive: true });
   }
-  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 (fs2.existsSync(journalPath)) {
-    existingLines = fs2.readFileSync(journalPath, "utf-8").split(`
+  if (fs4.existsSync(journalPath)) {
+    existingLines = fs4.readFileSync(journalPath, "utf-8").split(`
 `).filter((line) => line.trim() !== "");
   }
   const priceMap = new Map;
@@ -17527,54 +16985,23 @@ 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);
-  fs2.writeFileSync(journalPath, sortedLines.join(`
+  fs4.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 = 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
+  const ledgerDir = path3.join(directory, "ledger");
+  const yearJournalPath = path3.join(ledgerDir, `${year}.journal`);
+  const mainJournalPath = path3.join(directory, ".hledger.journal");
+  ensureDirectory(ledgerDir);
+  if (!fs4.existsSync(yearJournalPath)) {
+    fs4.writeFileSync(yearJournalPath, `; ${year} transactions
 `);
   }
-  if (!fs2.existsSync(mainJournalPath)) {
+  if (!fs4.existsSync(mainJournalPath)) {
     throw new Error(`.hledger.journal not found at ${mainJournalPath}. Create it first with appropriate includes.`);
   }
-  const mainJournalContent = fs2.readFileSync(mainJournalPath, "utf-8");
+  const mainJournalContent = fs4.readFileSync(mainJournalPath, "utf-8");
   const includeDirective = `include ledger/${year}.journal`;
   const lines = mainJournalContent.split(`
 `);
@@ -17586,7 +17013,7 @@ function ensureYearJournalExists(directory, year) {
     const newContent = mainJournalContent.trimEnd() + `
 ` + includeDirective + `
 `;
-    fs2.writeFileSync(mainJournalPath, newContent);
+    fs4.writeFileSync(mainJournalPath, newContent);
   }
   return yearJournalPath;
 }
@@ -17606,6 +17033,30 @@ function getNextDay(dateStr) {
   return formatDateISO(date5);
 }
 
+// src/utils/resultHelpers.ts
+function buildToolErrorResult(error45, hint, extra) {
+  const result = {
+    success: false,
+    error: error45
+  };
+  if (hint) {
+    result.hint = hint;
+  }
+  if (extra) {
+    Object.assign(result, extra);
+  }
+  return JSON.stringify(result);
+}
+function buildToolSuccessResult(data) {
+  const result = {
+    success: true
+  };
+  if (data) {
+    Object.assign(result, data);
+  }
+  return JSON.stringify(result);
+}
+
 // src/tools/fetch-currency-prices.ts
 async function defaultPriceFetcher(cmdArgs) {
   const result = await $`pricehist ${cmdArgs}`.quiet();
@@ -17629,10 +17080,10 @@ function buildPricehistArgs(startDate, endDate, currencyConfig) {
   return cmdArgs;
 }
 function buildErrorResult(error45) {
-  return JSON.stringify({ error: error45 });
+  return buildToolErrorResult(error45);
 }
 function buildSuccessResult(results, endDate, backfill) {
-  return JSON.stringify({
+  return buildToolSuccessResult({
     success: results.every((r) => !("error" in r)),
     endDate,
     backfill,
@@ -17648,7 +17099,7 @@ function parsePriceLine(line) {
     formattedLine: line
   };
 }
-function filterPriceLinesByDateRange(priceLines, startDate, endDate) {
+function filterAndSortPriceLinesByDateRange(priceLines, startDate, endDate) {
   return priceLines.map(parsePriceLine).filter((parsed) => {
     if (!parsed)
       return false;
@@ -17684,7 +17135,7 @@ async function fetchCurrencyPrices(directory, agent, backfill, priceFetcher = de
         });
         continue;
       }
-      const priceLines = filterPriceLinesByDateRange(rawPriceLines, startDate, endDate);
+      const priceLines = filterAndSortPriceLinesByDateRange(rawPriceLines, startDate, endDate);
       if (priceLines.length === 0) {
         results.push({
           ticker,
@@ -17692,7 +17143,7 @@ async function fetchCurrencyPrices(directory, agent, backfill, priceFetcher = de
         });
         continue;
       }
-      const journalPath = path3.join(directory, "ledger", "currencies", currencyConfig.file);
+      const journalPath = path4.join(directory, "ledger", "currencies", currencyConfig.file);
       updatePriceJournal(journalPath, priceLines);
       const latestPriceLine = priceLines[priceLines.length - 1];
       results.push({
@@ -17721,13 +17172,10 @@ var fetch_currency_prices_default = tool({
   }
 });
 // src/tools/classify-statements.ts
-import * as fs5 from "fs";
+import * as fs6 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",
@@ -17850,43 +17298,27 @@ function validateProviderConfig(name, config2) {
   return { detect, currencies };
 }
 function loadImportConfig(directory) {
-  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 loadYamlConfig(directory, CONFIG_FILE2, (parsedObj) => {
+    if (!parsedObj.paths) {
+      throw new Error("Invalid config: 'paths' section is required");
     }
-    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 };
+    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 };
+  }, `Configuration file not found: ${CONFIG_FILE2}. Please create this file to configure statement imports.`);
 }
 
 // src/utils/providerDetector.ts
@@ -17994,28 +17426,85 @@ function detectProvider(filename, content, config2) {
   return null;
 }
 
-// src/utils/fileUtils.ts
-import * as fs4 from "fs";
+// src/utils/importContext.ts
+import * as fs5 from "fs";
 import * as path5 from "path";
-function findCSVFiles(importsDir) {
-  if (!fs4.existsSync(importsDir)) {
-    return [];
+import { randomUUID } from "crypto";
+function getContextPath(directory, contextId) {
+  return path5.join(directory, ".memory", `${contextId}.json`);
+}
+function ensureMemoryDir(directory) {
+  ensureDirectory(path5.join(directory, ".memory"));
+}
+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);
+  fs5.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}'`);
+    }
   }
-  return fs4.readdirSync(importsDir).filter((file2) => file2.toLowerCase().endsWith(".csv")).filter((file2) => {
-    const fullPath = path5.join(importsDir, file2);
-    return fs4.statSync(fullPath).isFile();
-  });
 }
-function ensureDirectory(dirPath) {
-  if (!fs4.existsSync(dirPath)) {
-    fs4.mkdirSync(dirPath, { recursive: true });
+function loadContext(directory, contextId) {
+  const contextPath = getContextPath(directory, contextId);
+  if (!fs5.existsSync(contextPath)) {
+    throw new Error(`Context not found: ${contextId}`);
   }
+  const content = fs5.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)}`);
+  }
+  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);
+  fs5.writeFileSync(contextPath, JSON.stringify(updatedContext, null, 2), "utf-8");
+  return updatedContext;
 }
 
 // src/tools/classify-statements.ts
 function buildSuccessResult2(classified, unrecognized, message) {
-  return JSON.stringify({
-    success: true,
+  return buildToolSuccessResult({
     classified,
     unrecognized,
     message,
@@ -18027,19 +17516,14 @@ function buildSuccessResult2(classified, unrecognized, message) {
   });
 }
 function buildErrorResult2(error45, hint) {
-  return JSON.stringify({
-    success: false,
-    error: error45,
-    hint,
+  return buildToolErrorResult(error45, hint, {
     classified: [],
     unrecognized: []
   });
 }
 function buildCollisionError(collisions) {
   const error45 = `Cannot classify: ${collisions.length} file(s) would overwrite existing pending files.`;
-  return JSON.stringify({
-    success: false,
-    error: error45,
+  return buildToolErrorResult(error45, undefined, {
     collisions,
     classified: [],
     unrecognized: []
@@ -18050,7 +17534,7 @@ function planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2) {
   const collisions = [];
   for (const filename of csvFiles) {
     const sourcePath = path6.join(importsDir, filename);
-    const content = fs5.readFileSync(sourcePath, "utf-8");
+    const content = fs6.readFileSync(sourcePath, "utf-8");
     const detection = detectProvider(filename, content, config2);
     let targetPath;
     let targetFilename;
@@ -18062,7 +17546,7 @@ function planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2) {
       targetFilename = filename;
       targetPath = path6.join(unrecognizedDir, filename);
     }
-    if (fs5.existsSync(targetPath)) {
+    if (fs6.existsSync(targetPath)) {
       collisions.push({
         filename,
         existingPath: targetPath
@@ -18078,24 +17562,52 @@ function planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2) {
   }
   return { plannedMoves, collisions };
 }
-function executeMoves(plannedMoves, config2, unrecognizedDir) {
+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) {
   const classified = [];
   const unrecognized = [];
   for (const move of plannedMoves) {
     if (move.detection) {
       const targetDir = path6.dirname(move.targetPath);
       ensureDirectory(targetDir);
-      fs5.renameSync(move.sourcePath, move.targetPath);
+      fs6.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: path6.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename)
+        targetPath,
+        contextId: context.id
       });
     } else {
       ensureDirectory(unrecognizedDir);
-      fs5.renameSync(move.sourcePath, move.targetPath);
+      fs6.renameSync(move.sourcePath, move.targetPath);
       unrecognized.push({
         filename: move.filename,
         targetPath: path6.join(config2.paths.unrecognized, move.filename)
@@ -18122,7 +17634,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}`);
   }
@@ -18130,11 +17642,19 @@ async function classifyStatements(directory, agent, configLoader = loadImportCon
   if (collisions.length > 0) {
     return buildCollisionError(collisions);
   }
-  const { classified, unrecognized } = executeMoves(plannedMoves, config2, unrecognizedDir);
+  const { classified, unrecognized } = executeMoves(plannedMoves, config2, unrecognizedDir, directory);
   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.",
+  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/`,
   args: {},
   async execute(_params, context) {
     const { directory, agent } = context;
@@ -18142,7 +17662,7 @@ var classify_statements_default = tool({
   }
 });
 // src/tools/import-statements.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as path9 from "path";
 
 // node_modules/minimatch/dist/esm/index.js
@@ -20474,7 +19994,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 readdirSync3, readlinkSync, realpathSync as rps } from "fs";
+import { lstatSync, readdir as readdirCB, readdirSync as readdirSync2, readlinkSync, realpathSync as rps } from "fs";
 import * as actualFS from "fs";
 import { lstat, readdir, readlink, realpath } from "fs/promises";
 
@@ -21146,7 +20666,7 @@ var realpathSync = rps.native;
 var defaultFS = {
   lstatSync,
   readdir: readdirCB,
-  readdirSync: readdirSync3,
+  readdirSync: readdirSync2,
   readlinkSync,
   realpathSync,
   promises: {
@@ -21927,8 +21447,8 @@ class PathScurryBase {
   #children;
   nocase;
   #fs;
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs6);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs7 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs7);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = fileURLToPath(cwd);
     }
@@ -22404,8 +21924,8 @@ class PathScurryWin32 extends PathScurryBase {
   parseRootPath(dir) {
     return win32.parse(dir).root.toUpperCase();
   }
-  newRoot(fs6) {
-    return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+  newRoot(fs7) {
+    return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
   }
   isAbsolute(p) {
     return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
@@ -22422,8 +21942,8 @@ class PathScurryPosix extends PathScurryBase {
   parseRootPath(_dir) {
     return "/";
   }
-  newRoot(fs6) {
-    return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+  newRoot(fs7) {
+    return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
   }
   isAbsolute(p) {
     return p.startsWith("/");
@@ -23425,7 +22945,7 @@ var glob = Object.assign(glob_, {
 glob.glob = glob;
 
 // src/utils/rulesMatcher.ts
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path8 from "path";
 function parseSourceDirective(content) {
   const match2 = content.match(/^source\s+([^\n#]+)/m);
@@ -23443,20 +22963,25 @@ function resolveSourcePath(sourcePath, rulesFilePath) {
 }
 function loadRulesMapping(rulesDir) {
   const mapping = {};
-  if (!fs6.existsSync(rulesDir)) {
+  if (!fs7.existsSync(rulesDir)) {
     return mapping;
   }
-  const files = fs6.readdirSync(rulesDir);
+  const files = fs7.readdirSync(rulesDir);
   for (const file2 of files) {
     if (!file2.endsWith(".rules")) {
       continue;
     }
     const rulesFilePath = path8.join(rulesDir, file2);
-    const stat = fs6.statSync(rulesFilePath);
+    const stat = fs7.statSync(rulesFilePath);
     if (!stat.isFile()) {
       continue;
     }
-    const content = fs6.readFileSync(rulesFilePath, "utf-8");
+    let content;
+    try {
+      content = fs7.readFileSync(rulesFilePath, "utf-8");
+    } catch {
+      continue;
+    }
     const sourcePath = parseSourceDirective(content);
     if (!sourcePath) {
       continue;
@@ -23499,18 +23024,30 @@ 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: result.stdout.toString(),
-      stderr: result.stderr.toString(),
+      stdout,
+      stderr,
       exitCode: result.exitCode
     };
   } catch (error45) {
+    const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+    process.stderr.write(`[hledger] exception: ${errorMessage}
+`);
     return {
       stdout: "",
-      stderr: error45 instanceof Error ? error45.message : String(error45),
+      stderr: errorMessage,
       exitCode: 1
     };
   }
@@ -23616,7 +23153,7 @@ async function getAccountBalance(mainJournalPath, account, asOfDate, executor =
 }
 
 // src/utils/rulesParser.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 function parseSkipRows(rulesContent) {
   const match2 = rulesContent.match(/^skip\s+(\d+)/m);
   return match2 ? parseInt(match2[1], 10) : 0;
@@ -23682,7 +23219,7 @@ function parseAccount1(rulesContent) {
 }
 function getAccountFromRulesFile(rulesFilePath) {
   try {
-    const content = fs7.readFileSync(rulesFilePath, "utf-8");
+    const content = fs8.readFileSync(rulesFilePath, "utf-8");
     return parseAccount1(content);
   } catch {
     return null;
@@ -23701,8 +23238,8 @@ function parseRulesFile(rulesContent) {
 }
 
 // src/utils/csvParser.ts
-var import_convert_csv_to_json = __toESM(require_convert_csv_to_json(), 1);
-import * as fs8 from "fs";
+var import_papaparse2 = __toESM(require_papaparse(), 1);
+import * as fs9 from "fs";
 
 // src/utils/balanceUtils.ts
 function parseAmountValue(amountStr) {
@@ -23750,30 +23287,35 @@ 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 csvContent = fs9.readFileSync(csvPath, "utf-8");
   const lines = csvContent.split(`
 `);
   const headerIndex = config2.skipRows;
   if (headerIndex >= lines.length) {
     return [];
   }
-  const headerLine = lines[headerIndex];
-  const dataLines = lines.slice(headerIndex + 1).filter((line) => line.trim() !== "");
-  const csvWithHeader = [headerLine, ...dataLines].join(`
+  const csvWithHeader = lines.slice(headerIndex).join(`
 `);
-  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);
+  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;
+    });
   }
-  return mappedRows;
+  return result.data;
 }
 function getRowAmount(row, amountFields) {
   if (amountFields.single) {
@@ -23851,7 +23393,7 @@ function findMatchingCsvRow(posting, csvRows, config2) {
     const rowAmount = getRowAmount(row, config2.amountFields);
     if (rowDate !== posting.date)
       return false;
-    if (Math.abs(rowAmount - postingAmount) > 0.001)
+    if (Math.abs(rowAmount - postingAmount) > AMOUNT_MATCH_TOLERANCE)
       return false;
     return true;
   });
@@ -23885,31 +23427,26 @@ function findMatchingCsvRow(posting, csvRows, config2) {
 
 // src/tools/import-statements.ts
 function buildErrorResult3(error45, hint) {
-  return JSON.stringify({
-    success: false,
-    error: error45,
-    hint
+  return buildToolErrorResult(error45, hint, {
+    files: [],
+    summary: {
+      filesProcessed: 0,
+      filesWithErrors: 0,
+      filesWithoutRules: 0,
+      totalTransactions: 0,
+      matched: 0,
+      unknown: 0
+    }
   });
 }
 function buildErrorResultWithDetails(error45, files, summary, hint) {
-  return JSON.stringify({
-    success: false,
-    error: error45,
-    hint,
-    files,
-    summary
-  });
+  return buildToolErrorResult(error45, hint, { files, summary });
 }
 function buildSuccessResult3(files, summary, message) {
-  return JSON.stringify({
-    success: true,
-    files,
-    summary,
-    message
-  });
+  return buildToolSuccessResult({ files, summary, message });
 }
 function findCsvFromRulesFile(rulesFile) {
-  const content = fs9.readFileSync(rulesFile, "utf-8");
+  const content = fs10.readFileSync(rulesFile, "utf-8");
   const match2 = content.match(/^source\s+([^\n#]+)/m);
   if (!match2) {
     return null;
@@ -23922,8 +23459,8 @@ function findCsvFromRulesFile(rulesFile) {
     return null;
   }
   matches.sort((a, b) => {
-    const aStat = fs9.statSync(a);
-    const bStat = fs9.statSync(b);
+    const aStat = fs10.statSync(a);
+    const bStat = fs10.statSync(b);
     return bStat.mtime.getTime() - aStat.mtime.getTime();
   });
   return matches[0];
@@ -23976,10 +23513,8 @@ async function executeImports(fileResults, directory, pendingDir, doneDir, hledg
     const relativePath = path9.relative(pendingDir, csvFile);
     const destPath = path9.join(doneDir, relativePath);
     const destDir = path9.dirname(destPath);
-    if (!fs9.existsSync(destDir)) {
-      fs9.mkdirSync(destDir, { recursive: true });
-    }
-    fs9.renameSync(csvFile, destPath);
+    ensureDirectory(destDir);
+    fs10.renameSync(csvFile, destPath);
   }
   return {
     success: true,
@@ -24027,7 +23562,7 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   const transactionYear = years.size === 1 ? Array.from(years)[0] : undefined;
   if (unknownPostings.length > 0) {
     try {
-      const rulesContent = fs9.readFileSync(rulesFile, "utf-8");
+      const rulesContent = fs10.readFileSync(rulesFile, "utf-8");
       const rulesConfig = parseRulesFile(rulesContent);
       const csvRows = parseCsvFile(csvFile, rulesConfig);
       for (const posting of unknownPostings) {
@@ -24068,17 +23603,12 @@ 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 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 importContext = loadContext(directory, options.contextId);
+  const csvPath = path9.join(directory, importContext.filePath);
+  if (!fs10.existsSync(csvPath)) {
+    return buildErrorResult3(`CSV file not found: ${importContext.filePath}`, "The file may have been moved or deleted");
   }
+  const csvFiles = [csvPath];
   const fileResults = [];
   let totalTransactions = 0;
   let totalMatched = 0;
@@ -24110,8 +23640,8 @@ async function importStatements(directory, agent, options, configLoader = loadIm
   }
   for (const [_rulesFile, matchingCSVs] of rulesFileToCSVs.entries()) {
     matchingCSVs.sort((a, b) => {
-      const aStat = fs9.statSync(a);
-      const bStat = fs9.statSync(b);
+      const aStat = fs10.statSync(a);
+      const bStat = fs10.statSync(b);
       return bStat.mtime.getTime() - aStat.mtime.getTime();
     });
     const newestCSV = matchingCSVs[0];
@@ -24169,6 +23699,16 @@ 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
@@ -24204,26 +23744,29 @@ 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: {
-    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.'),
+    contextId: tool.schema.string().describe("Context ID from classify step. Used to locate the specific CSV file to process."),
     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, {
-      provider: params.provider,
-      currency: params.currency,
+      contextId: params.contextId,
       checkOnly: params.checkOnly
     });
   }
 });
 // src/tools/reconcile-statement.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as path10 from "path";
 function buildErrorResult4(params) {
-  return JSON.stringify({
-    success: false,
-    ...params
+  return buildToolErrorResult(params.error, params.hint, {
+    account: params.account ?? "",
+    expectedBalance: params.expectedBalance ?? "",
+    actualBalance: params.actualBalance ?? "",
+    lastTransactionDate: params.lastTransactionDate ?? "",
+    csvFile: params.csvFile ?? "",
+    difference: params.difference,
+    metadata: params.metadata
   });
 }
 function loadConfiguration(directory, configLoader) {
@@ -24239,69 +23782,87 @@ function loadConfiguration(directory, configLoader) {
     };
   }
 }
-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}` : "";
+function verifyCsvExists(directory, importContext) {
+  const csvFile = path10.join(directory, importContext.filePath);
+  if (!fs11.existsSync(csvFile)) {
     return {
       error: buildErrorResult4({
-        error: `No CSV files found in ${doneDir}`,
-        hint: `Run: import-statements${providerFilter}${currencyFilter}`
+        error: `CSV file not found: ${importContext.filePath}`,
+        hint: `The file may have been moved or deleted. Context ID: ${importContext.id}`
       })
     };
   }
-  const csvFile = csvFiles[csvFiles.length - 1];
-  const relativePath = path10.relative(path10.dirname(path10.dirname(doneDir)), csvFile);
-  return { csvFile, relativePath };
+  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 determineClosingBalance(csvFile, config2, options, relativeCsvPath, rulesDir) {
-  let metadata;
+function getBalanceFromCsvAnalysis(csvFile, rulesDir) {
+  const csvAnalysis = tryExtractClosingBalanceFromCSV(csvFile, rulesDir);
+  if (csvAnalysis && csvAnalysis.confidence === "high") {
+    return csvAnalysis.balance;
+  }
+  return;
+}
+function extractCsvMetadata(csvFile, config2) {
   try {
-    const content = fs10.readFileSync(csvFile, "utf-8");
+    const content = fs11.readFileSync(csvFile, "utf-8");
     const filename = path10.basename(csvFile);
     const detectionResult = detectProvider(filename, content, config2);
-    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}`;
-    }
-  }
-  if (!closingBalance) {
-    const csvAnalysis = tryExtractClosingBalanceFromCSV(csvFile, rulesDir);
-    if (csvAnalysis && csvAnalysis.confidence === "high") {
-      closingBalance = csvAnalysis.balance;
-      return { closingBalance, metadata, fromCSVAnalysis: true };
+    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"]
+      };
     }
-  }
-  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 };
+  } catch {}
+  return;
 }
-function buildRetryCommand(options, closingBalance, account) {
-  const parts = ["import-pipeline"];
-  if (options.provider) {
-    parts.push(`--provider ${options.provider}`);
+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 };
   }
-  if (options.currency) {
-    parts.push(`--currency ${options.currency}`);
+  const analysisBalance = getBalanceFromCsvAnalysis(csvFile, rulesDir);
+  if (analysisBalance) {
+    return { closingBalance: analysisBalance, 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
+    })
+  };
+}
+function buildRetryCommand(contextId, closingBalance, account) {
+  const parts = ["reconcile-statement", `--contextId ${contextId}`];
   if (closingBalance) {
     parts.push(`--closingBalance "${closingBalance}"`);
   }
@@ -24310,19 +23871,17 @@ function buildRetryCommand(options, closingBalance, account) {
   }
   return parts.join(" ");
 }
-function determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata) {
-  let account = options.account;
+function determineAccount(csvFile, rulesDir, importContext, manualAccount, relativeCsvPath, metadata) {
+  let account = manualAccount;
+  const rulesMapping = loadRulesMapping(rulesDir);
+  const rulesFile = findRulesForCsv(csvFile, rulesMapping);
   if (!account) {
-    const rulesMapping = loadRulesMapping(rulesDir);
-    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
     if (rulesFile) {
       account = getAccountFromRulesFile(rulesFile) ?? undefined;
     }
   }
   if (!account) {
-    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:...")}`;
+    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:...")}`;
     return {
       error: buildErrorResult4({
         csvFile: relativeCsvPath,
@@ -24341,7 +23900,7 @@ function tryExtractClosingBalanceFromCSV(csvFile, rulesDir) {
     if (!rulesFile) {
       return null;
     }
-    const rulesContent = fs10.readFileSync(rulesFile, "utf-8");
+    const rulesContent = fs11.readFileSync(rulesFile, "utf-8");
     const rulesConfig = parseRulesFile(rulesContent);
     const csvRows = parseCsvFile(csvFile, rulesConfig);
     if (csvRows.length === 0) {
@@ -24403,25 +23962,33 @@ 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 = findCsvToReconcile(doneDir, options);
+  const csvResult = verifyCsvExists(directory, importContext);
   if ("error" in csvResult) {
     return csvResult.error;
   }
   const { csvFile, relativePath: relativeCsvPath } = csvResult;
-  const balanceResult = determineClosingBalance(csvFile, config2, options, relativeCsvPath, rulesDir);
+  const balanceResult = determineClosingBalance(csvFile, config2, importContext, options.closingBalance, relativeCsvPath, rulesDir);
   if ("error" in balanceResult) {
     return balanceResult.error;
   }
   const { closingBalance, metadata, fromCSVAnalysis } = balanceResult;
-  const accountResult = determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata);
+  const accountResult = determineAccount(csvFile, rulesDir, importContext, options.account, relativeCsvPath, metadata);
   if ("error" in accountResult) {
     return accountResult.error;
   }
@@ -24508,30 +24075,30 @@ var reconcile_statement_default = tool({
 This tool validates that the imported transactions result in the correct closing balance.
 
 **Workflow:**
-1. Finds the most recently imported CSV in the done directory
-2. Extracts closing balance from CSV metadata (or uses manual override)
+1. Loads import context to find the CSV file
+2. Extracts closing balance from context/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: Extracted from CSV header metadata (e.g., UBS files have "Closing balance:" row)
+- Automatic: From import context or 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`,
+- Manual: Provided via account parameter
+
+Note: This tool requires a contextId from a prior classify/import step.`,
   args: {
-    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")'),
+    contextId: tool.schema.string().describe("Context ID from classify/import step (required)"),
     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, {
-      provider: params.provider,
-      currency: params.currency,
+      contextId: params.contextId,
       closingBalance: params.closingBalance,
       account: params.account
     });
@@ -24541,13 +24108,13 @@ This tool validates that the imported transactions result in the correct closing
 import * as path12 from "path";
 
 // src/utils/accountDeclarations.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 function extractAccountsFromRulesFile(rulesPath) {
   const accounts = new Set;
-  if (!fs11.existsSync(rulesPath)) {
+  if (!fs12.existsSync(rulesPath)) {
     return accounts;
   }
-  const content = fs11.readFileSync(rulesPath, "utf-8");
+  const content = fs12.readFileSync(rulesPath, "utf-8");
   const lines = content.split(`
 `);
   for (const line of lines) {
@@ -24582,10 +24149,10 @@ function sortAccountDeclarations(accounts) {
   return Array.from(accounts).sort((a, b) => a.localeCompare(b));
 }
 function ensureAccountDeclarations(yearJournalPath, accounts) {
-  if (!fs11.existsSync(yearJournalPath)) {
+  if (!fs12.existsSync(yearJournalPath)) {
     throw new Error(`Year journal not found: ${yearJournalPath}`);
   }
-  const content = fs11.readFileSync(yearJournalPath, "utf-8");
+  const content = fs12.readFileSync(yearJournalPath, "utf-8");
   const lines = content.split(`
 `);
   const existingAccounts = new Set;
@@ -24647,7 +24214,7 @@ function ensureAccountDeclarations(yearJournalPath, accounts) {
     newContent.push("");
   }
   newContent.push(...otherLines);
-  fs11.writeFileSync(yearJournalPath, newContent.join(`
+  fs12.writeFileSync(yearJournalPath, newContent.join(`
 `));
   return {
     added: Array.from(missingAccounts).sort(),
@@ -24656,8 +24223,9 @@ function ensureAccountDeclarations(yearJournalPath, accounts) {
 }
 
 // src/utils/logger.ts
-import fs12 from "fs/promises";
+import fs13 from "fs/promises";
 import path11 from "path";
+var LOG_LINE_LIMIT = 50;
 
 class MarkdownLogger {
   buffer = [];
@@ -24665,6 +24233,7 @@ class MarkdownLogger {
   context = {};
   autoFlush;
   sectionDepth = 0;
+  pendingFlush = null;
   constructor(config2) {
     this.autoFlush = config2.autoFlush ?? true;
     this.context = config2.context || {};
@@ -24739,9 +24308,9 @@ class MarkdownLogger {
       this.buffer.push("");
       const lines = output.trim().split(`
 `);
-      if (lines.length > 50) {
-        this.buffer.push(...lines.slice(0, 50));
-        this.buffer.push(`... (${lines.length - 50} more lines omitted)`);
+      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)`);
       } else {
         this.buffer.push(output.trim());
       }
@@ -24763,11 +24332,14 @@ class MarkdownLogger {
     this.context[key] = value;
   }
   async flush() {
+    if (this.pendingFlush) {
+      await this.pendingFlush;
+    }
     if (this.buffer.length === 0)
       return;
     try {
-      await fs12.mkdir(path11.dirname(this.logPath), { recursive: true });
-      await fs12.writeFile(this.logPath, this.buffer.join(`
+      await fs13.mkdir(path11.dirname(this.logPath), { recursive: true });
+      await fs13.writeFile(this.logPath, this.buffer.join(`
 `), "utf-8");
     } catch {}
   }
@@ -24775,7 +24347,7 @@ class MarkdownLogger {
     return this.logPath;
   }
   flushAsync() {
-    this.flush().catch(() => {});
+    this.pendingFlush = this.flush().catch(() => {});
   }
   getTimestamp() {
     return new Date().toISOString().replace(/:/g, "-").split(".")[0];
@@ -24821,12 +24393,12 @@ function buildStepResult(success2, message, details) {
   }
   return result;
 }
-function buildSuccessResult4(result, summary) {
+function buildPipelineSuccessResult(result, summary) {
   result.success = true;
   result.summary = summary;
   return JSON.stringify(result);
 }
-function buildErrorResult5(result, error45, hint) {
+function buildPipelineErrorResult(result, error45, hint) {
   result.success = false;
   result.error = error45;
   if (hint) {
@@ -24841,16 +24413,28 @@ 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,
@@ -24858,23 +24442,18 @@ 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, logger) {
+async function executeAccountDeclarationsStep(context, contextId, 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 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 importCtx = loadContext(context.directory, contextId);
+  const csvPath = path12.join(context.directory, importCtx.filePath);
+  const csvFiles = [csvPath];
   const rulesMapping = loadRulesMapping(rulesDir);
   const matchedRulesFiles = new Set;
   for (const csvFile of csvFiles) {
@@ -24949,12 +24528,11 @@ async function executeAccountDeclarationsStep(context, logger) {
   });
   logger?.endSection();
 }
-async function executeDryRunStep(context, logger) {
+async function executeDryRunStep(context, contextId, logger) {
   logger?.startSection("Step 3: Dry Run Import");
   logger?.logStep("Dry Run", "start");
   const dryRunResult = await importStatements(context.directory, context.agent, {
-    provider: context.options.provider,
-    currency: context.options.currency,
+    contextId,
     checkOnly: true
   }, context.configLoader, context.hledgerExecutor);
   const dryRunParsed = JSON.parse(dryRunResult);
@@ -24979,35 +24557,30 @@ async function executeDryRunStep(context, 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 csvFiles = findCsvFiles(pendingDir, context.options.provider, context.options.currency);
+        const importCtx = loadContext(context.directory, contextId);
+        const csvPath = path12.join(context.directory, importCtx.filePath);
         const rulesMapping = loadRulesMapping(rulesDir);
         let yearJournalPath;
         let firstRulesFile;
-        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;
-                }
+        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);
               }
-            } catch {
-              continue;
             }
-          }
+          } catch {}
         }
         const suggestionContext = {
-          existingAccounts: yearJournalPath ? await loadExistingAccounts2(yearJournalPath) : [],
+          existingAccounts: yearJournalPath ? loadExistingAccounts2(yearJournalPath) : [],
           rulesFilePath: firstRulesFile,
-          existingRules: firstRulesFile ? await extractRulePatternsFromFile2(firstRulesFile) : undefined,
+          existingRules: firstRulesFile ? extractRulePatternsFromFile2(firstRulesFile) : undefined,
           yearJournalPath,
           logger
         };
@@ -25075,12 +24648,12 @@ function formatUnknownPostingsLog(postings) {
 `;
   return log;
 }
-async function executeImportStep(context, logger) {
-  logger?.startSection("Step 4: Import Transactions");
+async function executeImportStep(context, contextId, logger) {
+  const importContext = loadContext(context.directory, contextId);
+  logger?.startSection(`Step 4: Import Transactions (${importContext.accountNumber || contextId})`);
   logger?.logStep("Import", "start");
   const importResult = await importStatements(context.directory, context.agent, {
-    provider: context.options.provider,
-    currency: context.options.currency,
+    contextId,
     checkOnly: false
   }, context.configLoader, context.hledgerExecutor);
   const importParsed = JSON.parse(importResult);
@@ -25091,6 +24664,13 @@ async function executeImportStep(context, 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();
@@ -25099,12 +24679,12 @@ async function executeImportStep(context, logger) {
   }
   logger?.endSection();
 }
-async function executeReconcileStep(context, logger) {
-  logger?.startSection("Step 5: Reconcile Balance");
+async function executeReconcileStep(context, contextId, logger) {
+  const importContext = loadContext(context.directory, contextId);
+  logger?.startSection(`Step 5: Reconcile Balance (${importContext.accountNumber || contextId})`);
   logger?.logStep("Reconcile", "start");
   const reconcileResult = await reconcileStatement(context.directory, context.agent, {
-    provider: context.options.provider,
-    currency: context.options.currency,
+    contextId,
     closingBalance: context.options.closingBalance,
     account: context.options.account
   }, context.configLoader, context.hledgerExecutor);
@@ -25122,6 +24702,14 @@ async function executeReconcileStep(context, 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();
@@ -25134,7 +24722,7 @@ async function executeReconcileStep(context, logger) {
 function handleNoTransactions(result) {
   result.steps.import = buildStepResult(true, "No transactions to import");
   result.steps.reconcile = buildStepResult(true, "Reconciliation skipped (no transactions)");
-  return buildSuccessResult4(result, "No transactions found to import");
+  return buildPipelineSuccessResult(result, "No transactions found to import");
 }
 async function importPipeline(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
   const restrictionError = checkAccountantAgent(agent, "import pipeline");
@@ -25160,21 +24748,31 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     result
   };
   try {
-    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;
+    const contextIds = await executeClassifyStep(context, logger);
+    if (contextIds.length === 0) {
+      logger.info("No files classified, nothing to import");
+      return buildPipelineSuccessResult(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;
+    }
     logger.startSection("Summary");
     logger.info(`Import completed successfully`);
-    logger.info(`Total transactions imported: ${transactionCount}`);
+    logger.info(`Contexts processed: ${contextIds.length}`);
+    logger.info(`Total transactions imported: ${totalTransactions}`);
     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 ${transactionCount} transaction(s)`);
+    return buildPipelineSuccessResult(result, `Successfully imported ${totalTransactions} transaction(s) from ${contextIds.length} file(s)`);
   } catch (error45) {
     logger.error("Pipeline step failed", error45);
     logger.info(`Log file: ${logger.getLogPath()}`);
@@ -25184,7 +24782,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     if (!result.error) {
       result.error = error45 instanceof Error ? error45.message : String(error45);
     }
-    return buildErrorResult5(result, result.error, result.hint);
+    return buildPipelineErrorResult(result, result.error, result.hint);
   } finally {
     logger.endSection();
     await logger.flush();
@@ -25235,7 +24833,7 @@ This tool orchestrates the full import workflow:
   }
 });
 // src/tools/init-directories.ts
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 import * as path13 from "path";
 async function initDirectories(directory) {
   try {
@@ -25243,8 +24841,8 @@ async function initDirectories(directory) {
     const directoriesCreated = [];
     const gitkeepFiles = [];
     const importBase = path13.join(directory, "import");
-    if (!fs14.existsSync(importBase)) {
-      fs14.mkdirSync(importBase, { recursive: true });
+    if (!fs15.existsSync(importBase)) {
+      fs15.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -25255,19 +24853,19 @@ async function initDirectories(directory) {
     ];
     for (const { path: dirPath } of pathsToCreate) {
       const fullPath = path13.join(directory, dirPath);
-      if (!fs14.existsSync(fullPath)) {
-        fs14.mkdirSync(fullPath, { recursive: true });
+      if (!fs15.existsSync(fullPath)) {
+        fs15.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
       const gitkeepPath = path13.join(fullPath, ".gitkeep");
-      if (!fs14.existsSync(gitkeepPath)) {
-        fs14.writeFileSync(gitkeepPath, "");
+      if (!fs15.existsSync(gitkeepPath)) {
+        fs15.writeFileSync(gitkeepPath, "");
         gitkeepFiles.push(path13.join(dirPath, ".gitkeep"));
       }
     }
     const gitignorePath = path13.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs14.existsSync(gitignorePath)) {
+    if (!fs15.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -25285,7 +24883,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs14.writeFileSync(gitignorePath, gitignoreContent);
+      fs15.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];
@@ -25361,7 +24959,7 @@ You can now drop CSV files into import/incoming/ and run import-pipeline.`);
   }
 });
 // src/index.ts
-var __dirname2 = dirname5(fileURLToPath3(import.meta.url));
+var __dirname2 = dirname4(fileURLToPath3(import.meta.url));
 var AGENT_FILE = join12(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);