@fuzzle/opencode-accountant 0.1.0-next.1 → 0.1.1

package/dist/index.js

@@ -1342,18 +1342,18 @@ var require_papaparse = __commonJS((exports, module) => {
 
 // node_modules/convert-csv-to-json/src/util/fileUtils.js
 var require_fileUtils = __commonJS((exports, module) => {
-  var fs6 = __require("fs");
+  var fs8 = __require("fs");
 
   class FileUtils {
     readFile(fileInputName, encoding) {
-      return fs6.readFileSync(fileInputName, encoding).toString();
+      return fs8.readFileSync(fileInputName, encoding).toString();
     }
     readFileAsync(fileInputName, encoding = "utf8") {
-      if (fs6.promises && typeof fs6.promises.readFile === "function") {
-        return fs6.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
+      if (fs8.promises && typeof fs8.promises.readFile === "function") {
+        return fs8.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
       }
       return new Promise((resolve2, reject) => {
-        fs6.readFile(fileInputName, encoding, (err, data) => {
+        fs8.readFile(fileInputName, encoding, (err, data) => {
           if (err) {
             reject(err);
             return;
@@ -1363,7 +1363,7 @@ var require_fileUtils = __commonJS((exports, module) => {
       });
     }
     writeFile(json3, fileOutputName) {
-      fs6.writeFile(fileOutputName, json3, function(err) {
+      fs8.writeFile(fileOutputName, json3, function(err) {
         if (err) {
           throw err;
         } else {
@@ -1372,11 +1372,11 @@ var require_fileUtils = __commonJS((exports, module) => {
       });
     }
     writeFileAsync(json3, fileOutputName) {
-      if (fs6.promises && typeof fs6.promises.writeFile === "function") {
-        return fs6.promises.writeFile(fileOutputName, json3);
+      if (fs8.promises && typeof fs8.promises.writeFile === "function") {
+        return fs8.promises.writeFile(fileOutputName, json3);
       }
       return new Promise((resolve2, reject) => {
-        fs6.writeFile(fileOutputName, json3, (err) => {
+        fs8.writeFile(fileOutputName, json3, (err) => {
           if (err)
             return reject(err);
           resolve2();
@@ -1941,7 +1941,7 @@ var require_convert_csv_to_json = __commonJS((exports) => {
 });
 
 // src/index.ts
-import { dirname as dirname4, join as join7 } from "path";
+import { dirname as dirname5, join as join10 } from "path";
 import { fileURLToPath } from "url";
 
 // src/utils/agentLoader.ts
@@ -16976,10 +16976,9 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
-// src/tools/update-prices.ts
+// src/tools/fetch-currency-prices.ts
 var {$ } = globalThis.Bun;
-import * as path2 from "path";
-import * as fs2 from "fs";
+import * as path3 from "path";
 
 // src/utils/agentRestriction.ts
 function checkAccountantAgent(agent, toolPrompt, additionalFields) {
@@ -17056,15 +17055,141 @@ function loadPricesConfig(directory) {
   return { currencies };
 }
 
-// src/tools/update-prices.ts
-async function defaultPriceFetcher(cmdArgs) {
-  const result = await $`pricehist ${cmdArgs}`.quiet();
-  return result.stdout.toString().trim();
+// 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(`
+`).filter((line) => line.trim() !== "");
+  }
+  const priceMap = new Map;
+  for (const line of existingLines) {
+    const date5 = extractDateFromPriceLine(line);
+    if (date5)
+      priceMap.set(date5, line);
+  }
+  for (const line of newPriceLines) {
+    const date5 = extractDateFromPriceLine(line);
+    if (date5)
+      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(`
+`) + `
+`);
+}
+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
+`);
+  }
+  if (!fs2.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 includeDirective = `include ledger/${year}.journal`;
+  const lines = mainJournalContent.split(`
+`);
+  const includeExists = lines.some((line) => {
+    const trimmed = line.trim();
+    return trimmed === includeDirective || trimmed.startsWith(includeDirective + " ");
+  });
+  if (!includeExists) {
+    const newContent = mainJournalContent.trimEnd() + `
+` + includeDirective + `
+`;
+    fs2.writeFileSync(mainJournalPath, newContent);
+  }
+  return yearJournalPath;
+}
+
+// src/utils/dateUtils.ts
+function formatDateISO(date5) {
+  return date5.toISOString().split("T")[0];
 }
 function getYesterday() {
   const d = new Date;
   d.setDate(d.getDate() - 1);
-  return d.toISOString().split("T")[0];
+  return formatDateISO(d);
+}
+function getNextDay(dateStr) {
+  const date5 = new Date(dateStr);
+  date5.setDate(date5.getDate() + 1);
+  return formatDateISO(date5);
+}
+
+// src/tools/fetch-currency-prices.ts
+async function defaultPriceFetcher(cmdArgs) {
+  const result = await $`pricehist ${cmdArgs}`.quiet();
+  return result.stdout.toString().trim();
+}
+function buildPricehistArgs(startDate, endDate, currencyConfig) {
+  const cmdArgs = [
+    "fetch",
+    "-o",
+    "ledger",
+    "-s",
+    startDate,
+    "-e",
+    endDate,
+    currencyConfig.source,
+    currencyConfig.pair
+  ];
+  if (currencyConfig.fmt_base) {
+    cmdArgs.push("--fmt-base", currencyConfig.fmt_base);
+  }
+  return cmdArgs;
+}
+function buildErrorResult(error45) {
+  return JSON.stringify({ error: error45 });
+}
+function buildSuccessResult(results, endDate, backfill) {
+  return JSON.stringify({
+    success: results.every((r) => !("error" in r)),
+    endDate,
+    backfill,
+    results
+  });
 }
 function parsePriceLine(line) {
   const match = line.match(/^P (\d{4}-\d{2}-\d{2})(?: \d{2}:\d{2}:\d{2})? .+$/);
@@ -17082,30 +17207,8 @@ function filterPriceLinesByDateRange(priceLines, startDate, endDate) {
     return parsed.date >= startDate && parsed.date <= endDate;
   }).sort((a, b) => a.date.localeCompare(b.date)).map((parsed) => parsed.formattedLine);
 }
-function updateJournalWithPrices(journalPath, newPriceLines) {
-  let existingLines = [];
-  if (fs2.existsSync(journalPath)) {
-    existingLines = fs2.readFileSync(journalPath, "utf-8").split(`
-`).filter((line) => line.trim() !== "");
-  }
-  const priceMap = new Map;
-  for (const line of existingLines) {
-    const date5 = line.split(" ")[1];
-    if (date5)
-      priceMap.set(date5, line);
-  }
-  for (const line of newPriceLines) {
-    const date5 = line.split(" ")[1];
-    if (date5)
-      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(`
-`) + `
-`);
-}
-async function updatePricesCore(directory, agent, backfill, priceFetcher = defaultPriceFetcher, configLoader = loadPricesConfig) {
-  const restrictionError = checkAccountantAgent(agent, "update prices");
+async function fetchCurrencyPrices(directory, agent, backfill, priceFetcher = defaultPriceFetcher, configLoader = loadPricesConfig) {
+  const restrictionError = checkAccountantAgent(agent, "fetch currency prices");
   if (restrictionError) {
     return restrictionError;
   }
@@ -17113,9 +17216,8 @@ async function updatePricesCore(directory, agent, backfill, priceFetcher = defau
   try {
     config2 = configLoader(directory);
   } catch (err) {
-    return JSON.stringify({
-      error: err instanceof Error ? err.message : String(err)
-    });
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    return buildErrorResult(errorMessage);
   }
   const endDate = getYesterday();
   const defaultBackfillDate = getDefaultBackfillDate();
@@ -17123,20 +17225,7 @@ async function updatePricesCore(directory, agent, backfill, priceFetcher = defau
   for (const [ticker, currencyConfig] of Object.entries(config2.currencies)) {
     try {
       const startDate = backfill ? currencyConfig.backfill_date || defaultBackfillDate : endDate;
-      const cmdArgs = [
-        "fetch",
-        "-o",
-        "ledger",
-        "-s",
-        startDate,
-        "-e",
-        endDate,
-        currencyConfig.source,
-        currencyConfig.pair
-      ];
-      if (currencyConfig.fmt_base) {
-        cmdArgs.push("--fmt-base", currencyConfig.fmt_base);
-      }
+      const cmdArgs = buildPricehistArgs(startDate, endDate, currencyConfig);
       const output = await priceFetcher(cmdArgs);
       const rawPriceLines = output.split(`
 `).filter((line) => line.startsWith("P "));
@@ -17155,8 +17244,8 @@ async function updatePricesCore(directory, agent, backfill, priceFetcher = defau
         });
         continue;
       }
-      const journalPath = path2.join(directory, "ledger", "currencies", currencyConfig.file);
-      updateJournalWithPrices(journalPath, priceLines);
+      const journalPath = path3.join(directory, "ledger", "currencies", currencyConfig.file);
+      updatePriceJournal(journalPath, priceLines);
       const latestPriceLine = priceLines[priceLines.length - 1];
       results.push({
         ticker,
@@ -17170,14 +17259,9 @@ async function updatePricesCore(directory, agent, backfill, priceFetcher = defau
       });
     }
   }
-  return JSON.stringify({
-    success: results.every((r) => !("error" in r)),
-    endDate,
-    backfill: !!backfill,
-    results
-  });
+  return buildSuccessResult(results, endDate, backfill);
 }
-var update_prices_default = tool({
+var fetch_currency_prices_default = tool({
   description: "ACCOUNTANT AGENT ONLY: Fetches end-of-day prices for all configured currencies (from config/prices.yaml) and appends them to the corresponding price journals in ledger/currencies/.",
   args: {
     backfill: tool.schema.boolean().optional().describe("If true, fetch history from each currency's configured backfill_date (or Jan 1 of current year if not specified)")
@@ -17185,16 +17269,16 @@ var update_prices_default = tool({
   async execute(params, context) {
     const { directory, agent } = context;
     const { backfill } = params;
-    return updatePricesCore(directory, agent, backfill || false);
+    return fetchCurrencyPrices(directory, agent, backfill || false);
   }
 });
 // src/tools/classify-statements.ts
-import * as path4 from "path";
-import * as fs4 from "fs";
+import * as fs5 from "fs";
+import * as path6 from "path";
 
 // src/utils/importConfig.ts
 import * as fs3 from "fs";
-import * as path3 from "path";
+import * as path4 from "path";
 var CONFIG_FILE2 = "config/import/providers.yaml";
 var REQUIRED_PATH_FIELDS = [
   "import",
@@ -17316,7 +17400,7 @@ function validateProviderConfig(name, config2) {
   return { detect, currencies };
 }
 function loadImportConfig(directory) {
-  const configPath = path3.join(directory, CONFIG_FILE2);
+  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.`);
   }
@@ -17475,13 +17559,15 @@ function isInWorktree(directory) {
   }
 }
 
-// src/tools/classify-statements.ts
+// src/utils/fileUtils.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
 function findCSVFiles(importsDir) {
   if (!fs4.existsSync(importsDir)) {
     return [];
   }
   return fs4.readdirSync(importsDir).filter((file2) => file2.toLowerCase().endsWith(".csv")).filter((file2) => {
-    const fullPath = path4.join(importsDir, file2);
+    const fullPath = path5.join(importsDir, file2);
     return fs4.statSync(fullPath).isFile();
   });
 }
@@ -17490,63 +17576,58 @@ function ensureDirectory(dirPath) {
     fs4.mkdirSync(dirPath, { recursive: true });
   }
 }
-async function classifyStatementsCore(directory, agent, configLoader = loadImportConfig, worktreeChecker = isInWorktree) {
-  const restrictionError = checkAccountantAgent(agent, "classify statements", {
+
+// src/tools/classify-statements.ts
+function buildSuccessResult2(classified, unrecognized, message) {
+  return JSON.stringify({
+    success: true,
+    classified,
+    unrecognized,
+    message,
+    summary: {
+      total: classified.length + unrecognized.length,
+      classified: classified.length,
+      unrecognized: unrecognized.length
+    }
+  });
+}
+function buildErrorResult2(error45, hint) {
+  return JSON.stringify({
+    success: false,
+    error: error45,
+    hint,
     classified: [],
     unrecognized: []
   });
-  if (restrictionError) {
-    return restrictionError;
-  }
-  if (!worktreeChecker(directory)) {
-    return JSON.stringify({
-      success: false,
-      error: "classify-statements must be run inside an import worktree",
-      hint: "Use import-pipeline tool to orchestrate the full workflow",
-      classified: [],
-      unrecognized: []
-    });
-  }
-  let config2;
-  try {
-    config2 = configLoader(directory);
-  } catch (err) {
-    return JSON.stringify({
-      success: false,
-      error: err instanceof Error ? err.message : String(err),
-      classified: [],
-      unrecognized: []
-    });
-  }
-  const importsDir = path4.join(directory, config2.paths.import);
-  const pendingDir = path4.join(directory, config2.paths.pending);
-  const unrecognizedDir = path4.join(directory, config2.paths.unrecognized);
-  const csvFiles = findCSVFiles(importsDir);
-  if (csvFiles.length === 0) {
-    return JSON.stringify({
-      success: true,
-      classified: [],
-      unrecognized: [],
-      message: `No CSV files found in ${config2.paths.import}`
-    });
-  }
+}
+function buildCollisionError(collisions) {
+  const error45 = `Cannot classify: ${collisions.length} file(s) would overwrite existing pending files.`;
+  return JSON.stringify({
+    success: false,
+    error: error45,
+    collisions,
+    classified: [],
+    unrecognized: []
+  });
+}
+function planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2) {
   const plannedMoves = [];
   const collisions = [];
   for (const filename of csvFiles) {
-    const sourcePath = path4.join(importsDir, filename);
-    const content = fs4.readFileSync(sourcePath, "utf-8");
+    const sourcePath = path6.join(importsDir, filename);
+    const content = fs5.readFileSync(sourcePath, "utf-8");
     const detection = detectProvider(filename, content, config2);
     let targetPath;
     let targetFilename;
     if (detection) {
       targetFilename = detection.outputFilename || filename;
-      const targetDir = path4.join(pendingDir, detection.provider, detection.currency);
-      targetPath = path4.join(targetDir, targetFilename);
+      const targetDir = path6.join(pendingDir, detection.provider, detection.currency);
+      targetPath = path6.join(targetDir, targetFilename);
     } else {
       targetFilename = filename;
-      targetPath = path4.join(unrecognizedDir, filename);
+      targetPath = path6.join(unrecognizedDir, filename);
     }
-    if (fs4.existsSync(targetPath)) {
+    if (fs5.existsSync(targetPath)) {
       collisions.push({
         filename,
         existingPath: targetPath
@@ -17560,64 +17641,81 @@ async function classifyStatementsCore(directory, agent, configLoader = loadImpor
       detection
     });
   }
-  if (collisions.length > 0) {
-    return JSON.stringify({
-      success: false,
-      error: `Cannot classify: ${collisions.length} file(s) would overwrite existing pending files.`,
-      collisions,
-      classified: [],
-      unrecognized: []
-    });
-  }
+  return { plannedMoves, collisions };
+}
+function executeMoves(plannedMoves, config2, unrecognizedDir) {
   const classified = [];
   const unrecognized = [];
   for (const move of plannedMoves) {
     if (move.detection) {
-      const targetDir = path4.dirname(move.targetPath);
+      const targetDir = path6.dirname(move.targetPath);
       ensureDirectory(targetDir);
-      fs4.renameSync(move.sourcePath, move.targetPath);
+      fs5.renameSync(move.sourcePath, move.targetPath);
       classified.push({
         filename: move.targetFilename,
         originalFilename: move.detection.outputFilename ? move.filename : undefined,
         provider: move.detection.provider,
         currency: move.detection.currency,
-        targetPath: path4.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename)
+        targetPath: path6.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename)
       });
     } else {
       ensureDirectory(unrecognizedDir);
-      fs4.renameSync(move.sourcePath, move.targetPath);
+      fs5.renameSync(move.sourcePath, move.targetPath);
       unrecognized.push({
         filename: move.filename,
-        targetPath: path4.join(config2.paths.unrecognized, move.filename)
+        targetPath: path6.join(config2.paths.unrecognized, move.filename)
       });
     }
   }
-  return JSON.stringify({
-    success: true,
-    classified,
-    unrecognized,
-    summary: {
-      total: csvFiles.length,
-      classified: classified.length,
-      unrecognized: unrecognized.length
-    }
+  return { classified, unrecognized };
+}
+async function classifyStatements(directory, agent, configLoader = loadImportConfig, worktreeChecker = isInWorktree) {
+  const restrictionError = checkAccountantAgent(agent, "classify statements", {
+    classified: [],
+    unrecognized: []
   });
+  if (restrictionError) {
+    return restrictionError;
+  }
+  if (!worktreeChecker(directory)) {
+    return buildErrorResult2("classify-statements must be run inside an import worktree", "Use import-pipeline tool to orchestrate the full workflow");
+  }
+  let config2;
+  try {
+    config2 = configLoader(directory);
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    return buildErrorResult2(errorMessage);
+  }
+  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);
+  if (csvFiles.length === 0) {
+    return buildSuccessResult2([], [], `No CSV files found in ${config2.paths.import}`);
+  }
+  const { plannedMoves, collisions } = planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2);
+  if (collisions.length > 0) {
+    return buildCollisionError(collisions);
+  }
+  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.",
   args: {},
   async execute(_params, context) {
     const { directory, agent } = context;
-    return classifyStatementsCore(directory, agent);
+    return classifyStatements(directory, agent);
   }
 });
 // src/tools/import-statements.ts
-import * as fs7 from "fs";
-import * as path6 from "path";
+import * as fs9 from "fs";
+import * as path8 from "path";
 
 // src/utils/rulesMatcher.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 function parseSourceDirective(content) {
   const match = content.match(/^source\s+([^\n#]+)/m);
   if (!match) {
@@ -17626,28 +17724,28 @@ function parseSourceDirective(content) {
   return match[1].trim();
 }
 function resolveSourcePath(sourcePath, rulesFilePath) {
-  if (path5.isAbsolute(sourcePath)) {
+  if (path7.isAbsolute(sourcePath)) {
     return sourcePath;
   }
-  const rulesDir = path5.dirname(rulesFilePath);
-  return path5.resolve(rulesDir, sourcePath);
+  const rulesDir = path7.dirname(rulesFilePath);
+  return path7.resolve(rulesDir, sourcePath);
 }
 function loadRulesMapping(rulesDir) {
   const mapping = {};
-  if (!fs5.existsSync(rulesDir)) {
+  if (!fs6.existsSync(rulesDir)) {
     return mapping;
   }
-  const files = fs5.readdirSync(rulesDir);
+  const files = fs6.readdirSync(rulesDir);
   for (const file2 of files) {
     if (!file2.endsWith(".rules")) {
       continue;
     }
-    const rulesFilePath = path5.join(rulesDir, file2);
-    const stat = fs5.statSync(rulesFilePath);
+    const rulesFilePath = path7.join(rulesDir, file2);
+    const stat = fs6.statSync(rulesFilePath);
     if (!stat.isFile()) {
       continue;
     }
-    const content = fs5.readFileSync(rulesFilePath, "utf-8");
+    const content = fs6.readFileSync(rulesFilePath, "utf-8");
     const sourcePath = parseSourceDirective(content);
     if (!sourcePath) {
       continue;
@@ -17661,9 +17759,9 @@ function findRulesForCsv(csvPath, mapping) {
   if (mapping[csvPath]) {
     return mapping[csvPath];
   }
-  const normalizedCsvPath = path5.normalize(csvPath);
+  const normalizedCsvPath = path7.normalize(csvPath);
   for (const [mappedCsv, rulesFile] of Object.entries(mapping)) {
-    if (path5.normalize(mappedCsv) === normalizedCsvPath) {
+    if (path7.normalize(mappedCsv) === normalizedCsvPath) {
       return rulesFile;
     }
   }
@@ -17751,8 +17849,45 @@ async function validateLedger(mainJournalPath, executor = defaultHledgerExecutor
   }
   return { valid: errors3.length === 0, errors: errors3 };
 }
+async function getLastTransactionDate(mainJournalPath, account, executor = defaultHledgerExecutor) {
+  const result = await executor(["register", account, "-f", mainJournalPath, "-O", "csv"]);
+  if (result.exitCode !== 0 || !result.stdout.trim()) {
+    return null;
+  }
+  const lines = result.stdout.trim().split(`
+`);
+  if (lines.length < 2) {
+    return null;
+  }
+  const lastLine = lines[lines.length - 1];
+  const match = lastLine.match(/^"?\d+"?,"?(\d{4}-\d{2}-\d{2})"?/);
+  return match ? match[1] : null;
+}
+async function getAccountBalance(mainJournalPath, account, asOfDate, executor = defaultHledgerExecutor) {
+  const nextDay = getNextDay(asOfDate);
+  const result = await executor([
+    "bal",
+    account,
+    "-f",
+    mainJournalPath,
+    "-e",
+    nextDay,
+    "-N",
+    "--flat"
+  ]);
+  if (result.exitCode !== 0) {
+    return null;
+  }
+  const output = result.stdout.trim();
+  if (!output) {
+    return "0";
+  }
+  const match = output.match(/^\s*(.+?)\s{2,}/);
+  return match ? match[1].trim() : output.trim();
+}
 
 // src/utils/rulesParser.ts
+import * as fs7 from "fs";
 function parseSkipRows(rulesContent) {
   const match = rulesContent.match(/^skip\s+(\d+)/m);
   return match ? parseInt(match[1], 10) : 0;
@@ -17812,6 +17947,18 @@ function parseAmountFields(rulesContent, fieldNames) {
   }
   return result;
 }
+function parseAccount1(rulesContent) {
+  const match = rulesContent.match(/^account1\s+(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+function getAccountFromRulesFile(rulesFilePath) {
+  try {
+    const content = fs7.readFileSync(rulesFilePath, "utf-8");
+    return parseAccount1(content);
+  } catch {
+    return null;
+  }
+}
 function parseRulesFile(rulesContent) {
   const fieldNames = parseFieldNames(rulesContent);
   return {
@@ -17826,9 +17973,56 @@ function parseRulesFile(rulesContent) {
 
 // src/utils/csvParser.ts
 var import_convert_csv_to_json = __toESM(require_convert_csv_to_json(), 1);
-import * as fs6 from "fs";
+import * as fs8 from "fs";
+
+// src/utils/balanceUtils.ts
+function parseAmountValue(amountStr) {
+  const cleaned = amountStr.replace(/[A-Z]{3}\s*/g, "").replace(/,/g, "").trim();
+  return parseFloat(cleaned) || 0;
+}
+function parseBalance(balance) {
+  const match = balance.match(/([A-Z]{3})\s*([-\d.,]+)|([+-]?[\d.,]+)\s*([A-Z]{3})/);
+  if (!match) {
+    const numMatch = balance.match(/^([+-]?[\d.,]+)$/);
+    if (numMatch) {
+      return { currency: "", amount: parseFloat(numMatch[1].replace(/,/g, "")) };
+    }
+    return null;
+  }
+  const currency = match[1] || match[4];
+  const amountStr = match[2] || match[3];
+  const amount = parseFloat(amountStr.replace(/,/g, ""));
+  return { currency, amount };
+}
+function calculateDifference(expected, actual) {
+  const expectedParsed = parseBalance(expected);
+  const actualParsed = parseBalance(actual);
+  if (!expectedParsed || !actualParsed) {
+    throw new Error(`Cannot parse balances: expected="${expected}", actual="${actual}"`);
+  }
+  if (expectedParsed.currency && actualParsed.currency && expectedParsed.currency !== actualParsed.currency) {
+    throw new Error(`Currency mismatch: expected ${expectedParsed.currency}, got ${actualParsed.currency}`);
+  }
+  const diff = actualParsed.amount - expectedParsed.amount;
+  const sign = diff >= 0 ? "+" : "";
+  const currency = expectedParsed.currency || actualParsed.currency;
+  return currency ? `${currency} ${sign}${diff.toFixed(2)}` : `${sign}${diff.toFixed(2)}`;
+}
+function balancesMatch(balance1, balance2) {
+  const parsed1 = parseBalance(balance1);
+  const parsed2 = parseBalance(balance2);
+  if (!parsed1 || !parsed2) {
+    return false;
+  }
+  if (parsed1.currency && parsed2.currency && parsed1.currency !== parsed2.currency) {
+    throw new Error(`Currency mismatch: ${parsed1.currency} vs ${parsed2.currency}`);
+  }
+  return parsed1.amount === parsed2.amount;
+}
+
+// src/utils/csvParser.ts
 function parseCsvFile(csvPath, config2) {
-  const csvContent = fs6.readFileSync(csvPath, "utf-8");
+  const csvContent = fs8.readFileSync(csvPath, "utf-8");
   const lines = csvContent.split(`
 `);
   const headerIndex = config2.skipRows;
@@ -17852,10 +18046,6 @@ function parseCsvFile(csvPath, config2) {
   }
   return mappedRows;
 }
-function parseAmountValue(amountStr) {
-  const cleaned = amountStr.replace(/[A-Z]{3}\s*/g, "").trim();
-  return parseFloat(cleaned) || 0;
-}
 function getRowAmount(row, amountFields) {
   if (amountFields.single) {
     return parseAmountValue(row[amountFields.single] || "0");
@@ -17965,106 +18155,188 @@ function findMatchingCsvRow(posting, csvRows, config2) {
 }
 
 // src/tools/import-statements.ts
-function ensureYearJournalExists(directory, year) {
-  const ledgerDir = path6.join(directory, "ledger");
-  const yearJournalPath = path6.join(ledgerDir, `${year}.journal`);
-  const mainJournalPath = path6.join(directory, ".hledger.journal");
-  if (!fs7.existsSync(ledgerDir)) {
-    fs7.mkdirSync(ledgerDir, { recursive: true });
-  }
-  if (!fs7.existsSync(yearJournalPath)) {
-    fs7.writeFileSync(yearJournalPath, `; ${year} transactions
-`);
+function buildErrorResult3(error45, hint) {
+  return JSON.stringify({
+    success: false,
+    error: error45,
+    hint
+  });
+}
+function buildErrorResultWithDetails(error45, files, summary, hint) {
+  return JSON.stringify({
+    success: false,
+    error: error45,
+    hint,
+    files,
+    summary
+  });
+}
+function buildSuccessResult3(files, summary, message) {
+  return JSON.stringify({
+    success: true,
+    files,
+    summary,
+    message
+  });
+}
+async function executeImports(fileResults, directory, pendingDir, doneDir, hledgerExecutor) {
+  const importedFiles = [];
+  for (const fileResult of fileResults) {
+    const csvFile = path8.join(directory, fileResult.csv);
+    const rulesFile = fileResult.rulesFile ? path8.join(directory, fileResult.rulesFile) : null;
+    if (!rulesFile)
+      continue;
+    const year = fileResult.transactionYear;
+    if (!year) {
+      return {
+        success: false,
+        error: `No transactions found in ${fileResult.csv}`
+      };
+    }
+    let yearJournalPath;
+    try {
+      yearJournalPath = ensureYearJournalExists(directory, year);
+    } catch (error45) {
+      const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+    const result = await hledgerExecutor([
+      "import",
+      "-f",
+      yearJournalPath,
+      csvFile,
+      "--rules-file",
+      rulesFile
+    ]);
+    if (result.exitCode !== 0) {
+      return {
+        success: false,
+        error: `Import failed for ${fileResult.csv}: ${result.stderr.trim()}`
+      };
+    }
+    importedFiles.push(csvFile);
   }
-  if (!fs7.existsSync(mainJournalPath)) {
-    throw new Error(`.hledger.journal not found at ${mainJournalPath}. Create it first with appropriate includes.`);
+  const mainJournalPath = path8.join(directory, ".hledger.journal");
+  const validationResult = await validateLedger(mainJournalPath, hledgerExecutor);
+  if (!validationResult.valid) {
+    return {
+      success: false,
+      error: `Ledger validation failed after import: ${validationResult.errors.join("; ")}`,
+      hint: "The import created invalid transactions. Check your rules file configuration. CSV files have NOT been moved to done."
+    };
   }
-  const mainJournalContent = fs7.readFileSync(mainJournalPath, "utf-8");
-  const includeDirective = `include ledger/${year}.journal`;
-  const lines = mainJournalContent.split(`
-`);
-  const includeExists = lines.some((line) => {
-    const trimmed = line.trim();
-    return trimmed === includeDirective || trimmed.startsWith(includeDirective + " ");
-  });
-  if (!includeExists) {
-    const newContent = mainJournalContent.trimEnd() + `
-` + includeDirective + `
-`;
-    fs7.writeFileSync(mainJournalPath, newContent);
+  for (const csvFile of importedFiles) {
+    const relativePath = path8.relative(pendingDir, csvFile);
+    const destPath = path8.join(doneDir, relativePath);
+    const destDir = path8.dirname(destPath);
+    if (!fs9.existsSync(destDir)) {
+      fs9.mkdirSync(destDir, { recursive: true });
+    }
+    fs9.renameSync(csvFile, destPath);
   }
-  return yearJournalPath;
+  return {
+    success: true,
+    importedCount: importedFiles.length
+  };
 }
-function findPendingCsvFiles(pendingDir, provider, currency) {
-  const csvFiles = [];
-  if (!fs7.existsSync(pendingDir)) {
-    return csvFiles;
+async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor) {
+  const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+  if (!rulesFile) {
+    return {
+      csv: path8.relative(directory, csvFile),
+      rulesFile: null,
+      totalTransactions: 0,
+      matchedTransactions: 0,
+      unknownPostings: [],
+      error: "No matching rules file found"
+    };
   }
-  let searchPath = pendingDir;
-  if (provider) {
-    searchPath = path6.join(searchPath, provider);
-    if (currency) {
-      searchPath = path6.join(searchPath, currency);
-    }
+  const result = await hledgerExecutor(["print", "-f", csvFile, "--rules-file", rulesFile]);
+  if (result.exitCode !== 0) {
+    return {
+      csv: path8.relative(directory, csvFile),
+      rulesFile: path8.relative(directory, rulesFile),
+      totalTransactions: 0,
+      matchedTransactions: 0,
+      unknownPostings: [],
+      error: `hledger error: ${result.stderr.trim() || "Unknown error"}`
+    };
   }
-  if (!fs7.existsSync(searchPath)) {
-    return csvFiles;
+  const unknownPostings = parseUnknownPostings(result.stdout);
+  const transactionCount = countTransactions(result.stdout);
+  const matchedCount = transactionCount - unknownPostings.length;
+  const years = extractTransactionYears(result.stdout);
+  if (years.size > 1) {
+    const yearList = Array.from(years).sort().join(", ");
+    return {
+      csv: path8.relative(directory, csvFile),
+      rulesFile: path8.relative(directory, rulesFile),
+      totalTransactions: transactionCount,
+      matchedTransactions: matchedCount,
+      unknownPostings: [],
+      error: `CSV contains transactions from multiple years (${yearList}). Split the CSV by year before importing.`
+    };
   }
-  function scanDirectory(directory) {
-    const entries = fs7.readdirSync(directory, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path6.join(directory, entry.name);
-      if (entry.isDirectory()) {
-        scanDirectory(fullPath);
-      } else if (entry.isFile() && entry.name.endsWith(".csv")) {
-        csvFiles.push(fullPath);
+  const transactionYear = years.size === 1 ? Array.from(years)[0] : undefined;
+  if (unknownPostings.length > 0) {
+    try {
+      const rulesContent = fs9.readFileSync(rulesFile, "utf-8");
+      const rulesConfig = parseRulesFile(rulesContent);
+      const csvRows = parseCsvFile(csvFile, rulesConfig);
+      for (const posting of unknownPostings) {
+        posting.csvRow = findMatchingCsvRow({
+          date: posting.date,
+          description: posting.description,
+          amount: posting.amount
+        }, csvRows, rulesConfig);
+      }
+    } catch {
+      for (const posting of unknownPostings) {
+        posting.csvRow = undefined;
       }
     }
   }
-  scanDirectory(searchPath);
-  return csvFiles.sort();
+  return {
+    csv: path8.relative(directory, csvFile),
+    rulesFile: path8.relative(directory, rulesFile),
+    totalTransactions: transactionCount,
+    matchedTransactions: matchedCount,
+    unknownPostings,
+    transactionYear
+  };
 }
-async function importStatementsCore(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
+async function importStatements(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
   const restrictionError = checkAccountantAgent(agent, "import statements");
   if (restrictionError) {
     return restrictionError;
   }
   if (!worktreeChecker(directory)) {
-    return JSON.stringify({
-      success: false,
-      error: "import-statements must be run inside an import worktree",
-      hint: "Use import-pipeline tool to orchestrate the full workflow"
-    });
+    return buildErrorResult3("import-statements must be run inside an import worktree", "Use import-pipeline tool to orchestrate the full workflow");
   }
   let config2;
   try {
     config2 = configLoader(directory);
   } catch (error45) {
-    return JSON.stringify({
-      success: false,
-      error: `Failed to load configuration: ${error45 instanceof Error ? error45.message : String(error45)}`,
-      hint: 'Ensure config/import/providers.yaml exists with required paths including "rules"'
-    });
+    const errorMessage = `Failed to load configuration: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    return buildErrorResult3(errorMessage, 'Ensure config/import/providers.yaml exists with required paths including "rules"');
   }
-  const pendingDir = path6.join(directory, config2.paths.pending);
-  const rulesDir = path6.join(directory, config2.paths.rules);
-  const doneDir = path6.join(directory, config2.paths.done);
+  const pendingDir = path8.join(directory, config2.paths.pending);
+  const rulesDir = path8.join(directory, config2.paths.rules);
+  const doneDir = path8.join(directory, config2.paths.done);
   const rulesMapping = loadRulesMapping(rulesDir);
-  const csvFiles = findPendingCsvFiles(pendingDir, options.provider, options.currency);
+  const csvFiles = findCsvFiles(pendingDir, options.provider, options.currency);
   if (csvFiles.length === 0) {
-    return JSON.stringify({
-      success: true,
-      files: [],
-      summary: {
-        filesProcessed: 0,
-        filesWithErrors: 0,
-        filesWithoutRules: 0,
-        totalTransactions: 0,
-        matched: 0,
-        unknown: 0
-      },
-      message: "No CSV files found to process"
-    });
+    return buildSuccessResult3([], {
+      filesProcessed: 0,
+      filesWithErrors: 0,
+      filesWithoutRules: 0,
+      totalTransactions: 0,
+      matched: 0,
+      unknown: 0
+    }, "No CSV files found to process");
   }
   const fileResults = [];
   let totalTransactions = 0;
@@ -18073,79 +18345,18 @@ async function importStatementsCore(directory, agent, options, configLoader = lo
   let filesWithErrors = 0;
   let filesWithoutRules = 0;
   for (const csvFile of csvFiles) {
-    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
-    if (!rulesFile) {
-      filesWithoutRules++;
-      fileResults.push({
-        csv: path6.relative(directory, csvFile),
-        rulesFile: null,
-        totalTransactions: 0,
-        matchedTransactions: 0,
-        unknownPostings: [],
-        error: "No matching rules file found"
-      });
-      continue;
-    }
-    const result = await hledgerExecutor(["print", "-f", csvFile, "--rules-file", rulesFile]);
-    if (result.exitCode !== 0) {
-      filesWithErrors++;
-      fileResults.push({
-        csv: path6.relative(directory, csvFile),
-        rulesFile: path6.relative(directory, rulesFile),
-        totalTransactions: 0,
-        matchedTransactions: 0,
-        unknownPostings: [],
-        error: `hledger error: ${result.stderr.trim() || "Unknown error"}`
-      });
-      continue;
-    }
-    const unknownPostings = parseUnknownPostings(result.stdout);
-    const transactionCount = countTransactions(result.stdout);
-    const matchedCount = transactionCount - unknownPostings.length;
-    const years = extractTransactionYears(result.stdout);
-    if (years.size > 1) {
-      const yearList = Array.from(years).sort().join(", ");
-      filesWithErrors++;
-      fileResults.push({
-        csv: path6.relative(directory, csvFile),
-        rulesFile: path6.relative(directory, rulesFile),
-        totalTransactions: transactionCount,
-        matchedTransactions: matchedCount,
-        unknownPostings: [],
-        error: `CSV contains transactions from multiple years (${yearList}). Split the CSV by year before importing.`
-      });
-      continue;
+    const fileResult = await processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor);
+    fileResults.push(fileResult);
+    if (fileResult.error) {
+      if (fileResult.rulesFile === null) {
+        filesWithoutRules++;
+      } else {
+        filesWithErrors++;
+      }
     }
-    const transactionYear = years.size === 1 ? Array.from(years)[0] : undefined;
-    if (unknownPostings.length > 0) {
-      try {
-        const rulesContent = fs7.readFileSync(rulesFile, "utf-8");
-        const rulesConfig = parseRulesFile(rulesContent);
-        const csvRows = parseCsvFile(csvFile, rulesConfig);
-        for (const posting of unknownPostings) {
-          posting.csvRow = findMatchingCsvRow({
-            date: posting.date,
-            description: posting.description,
-            amount: posting.amount
-          }, csvRows, rulesConfig);
-        }
-      } catch {
-        for (const posting of unknownPostings) {
-          posting.csvRow = undefined;
-        }
-      }
-    }
-    totalTransactions += transactionCount;
-    totalMatched += matchedCount;
-    totalUnknown += unknownPostings.length;
-    fileResults.push({
-      csv: path6.relative(directory, csvFile),
-      rulesFile: path6.relative(directory, rulesFile),
-      totalTransactions: transactionCount,
-      matchedTransactions: matchedCount,
-      unknownPostings,
-      transactionYear
-    });
+    totalTransactions += fileResult.totalTransactions;
+    totalMatched += fileResult.matchedTransactions;
+    totalUnknown += fileResult.unknownPostings.length;
   }
   const hasUnknowns = totalUnknown > 0;
   const hasErrors = filesWithErrors > 0 || filesWithoutRules > 0;
@@ -18172,129 +18383,37 @@ async function importStatementsCore(directory, agent, options, configLoader = lo
     return JSON.stringify(result);
   }
   if (hasUnknowns || hasErrors) {
-    return JSON.stringify({
-      success: false,
-      files: fileResults,
-      summary: {
-        filesProcessed: csvFiles.length,
-        filesWithErrors,
-        filesWithoutRules,
-        totalTransactions,
-        matched: totalMatched,
-        unknown: totalUnknown
-      },
-      error: "Cannot import: some transactions have unknown accounts or files have errors",
-      hint: "Run with checkOnly: true to see details, then add missing rules"
-    });
-  }
-  const importedFiles = [];
-  for (const fileResult of fileResults) {
-    const csvFile = path6.join(directory, fileResult.csv);
-    const rulesFile = fileResult.rulesFile ? path6.join(directory, fileResult.rulesFile) : null;
-    if (!rulesFile)
-      continue;
-    const year = fileResult.transactionYear;
-    if (!year) {
-      return JSON.stringify({
-        success: false,
-        files: fileResults,
-        summary: {
-          filesProcessed: csvFiles.length,
-          filesWithErrors: 1,
-          filesWithoutRules,
-          totalTransactions,
-          matched: totalMatched,
-          unknown: totalUnknown
-        },
-        error: `No transactions found in ${fileResult.csv}`
-      });
-    }
-    let yearJournalPath;
-    try {
-      yearJournalPath = ensureYearJournalExists(directory, year);
-    } catch (error45) {
-      return JSON.stringify({
-        success: false,
-        files: fileResults,
-        summary: {
-          filesProcessed: csvFiles.length,
-          filesWithErrors: 1,
-          filesWithoutRules,
-          totalTransactions,
-          matched: totalMatched,
-          unknown: totalUnknown
-        },
-        error: error45 instanceof Error ? error45.message : String(error45)
-      });
-    }
-    const result = await hledgerExecutor([
-      "import",
-      "-f",
-      yearJournalPath,
-      csvFile,
-      "--rules-file",
-      rulesFile
-    ]);
-    if (result.exitCode !== 0) {
-      return JSON.stringify({
-        success: false,
-        files: fileResults,
-        summary: {
-          filesProcessed: csvFiles.length,
-          filesWithErrors: 1,
-          filesWithoutRules,
-          totalTransactions,
-          matched: totalMatched,
-          unknown: totalUnknown
-        },
-        error: `Import failed for ${fileResult.csv}: ${result.stderr.trim()}`
-      });
-    }
-    importedFiles.push(csvFile);
-  }
-  const mainJournalPath = path6.join(directory, ".hledger.journal");
-  const validationResult = await validateLedger(mainJournalPath, hledgerExecutor);
-  if (!validationResult.valid) {
-    return JSON.stringify({
-      success: false,
-      files: fileResults,
-      summary: {
-        filesProcessed: csvFiles.length,
-        filesWithErrors: 1,
-        filesWithoutRules,
-        totalTransactions,
-        matched: totalMatched,
-        unknown: totalUnknown
-      },
-      error: `Ledger validation failed after import: ${validationResult.errors.join("; ")}`,
-      hint: "The import created invalid transactions. Check your rules file configuration. CSV files have NOT been moved to done."
-    });
-  }
-  for (const csvFile of importedFiles) {
-    const relativePath = path6.relative(pendingDir, csvFile);
-    const destPath = path6.join(doneDir, relativePath);
-    const destDir = path6.dirname(destPath);
-    if (!fs7.existsSync(destDir)) {
-      fs7.mkdirSync(destDir, { recursive: true });
-    }
-    fs7.renameSync(csvFile, destPath);
+    return buildErrorResultWithDetails("Cannot import: some transactions have unknown accounts or files have errors", fileResults, {
+      filesProcessed: csvFiles.length,
+      filesWithErrors,
+      filesWithoutRules,
+      totalTransactions,
+      matched: totalMatched,
+      unknown: totalUnknown
+    }, "Run with checkOnly: true to see details, then add missing rules");
   }
-  return JSON.stringify({
-    success: true,
-    files: fileResults.map((f) => ({
-      ...f,
-      imported: true
-    })),
-    summary: {
+  const importResult = await executeImports(fileResults, directory, pendingDir, doneDir, hledgerExecutor);
+  if (!importResult.success) {
+    return buildErrorResultWithDetails(importResult.error, fileResults, {
       filesProcessed: csvFiles.length,
-      filesWithErrors: 0,
-      filesWithoutRules: 0,
+      filesWithErrors: 1,
+      filesWithoutRules,
       totalTransactions,
       matched: totalMatched,
-      unknown: 0
-    },
-    message: `Successfully imported ${totalTransactions} transaction(s) from ${importedFiles.length} file(s)`
-  });
+      unknown: totalUnknown
+    }, importResult.hint);
+  }
+  return buildSuccessResult3(fileResults.map((f) => ({
+    ...f,
+    imported: true
+  })), {
+    filesProcessed: csvFiles.length,
+    filesWithErrors: 0,
+    filesWithoutRules: 0,
+    totalTransactions,
+    matched: totalMatched,
+    unknown: 0
+  }, `Successfully imported ${totalTransactions} transaction(s) from ${importResult.importedCount} file(s)`);
 }
 var import_statements_default = tool({
   description: `ACCOUNTANT AGENT ONLY: Import classified bank statement CSVs into hledger using rules files.
@@ -18323,23 +18442,269 @@ This tool processes CSV files in the pending import directory and uses hledger's
   },
   async execute(params, context) {
     const { directory, agent } = context;
-    return importStatementsCore(directory, agent, {
+    return importStatements(directory, agent, {
       provider: params.provider,
       currency: params.currency,
       checkOnly: params.checkOnly
     });
   }
 });
+// src/tools/reconcile-statement.ts
+import * as fs10 from "fs";
+import * as path9 from "path";
+function buildErrorResult4(params) {
+  return JSON.stringify({
+    success: false,
+    ...params
+  });
+}
+function buildSuccessResult4(params) {
+  return JSON.stringify({
+    success: true,
+    ...params
+  });
+}
+function validateWorktree(directory, worktreeChecker) {
+  if (!worktreeChecker(directory)) {
+    return buildErrorResult4({
+      error: "reconcile-statement must be run inside an import worktree",
+      hint: "Use import-pipeline tool to orchestrate the full workflow"
+    });
+  }
+  return null;
+}
+function loadConfiguration(directory, configLoader) {
+  try {
+    const config2 = configLoader(directory);
+    return { config: config2 };
+  } catch (error45) {
+    return {
+      error: buildErrorResult4({
+        error: `Failed to load configuration: ${error45 instanceof Error ? error45.message : String(error45)}`,
+        hint: "Ensure config/import/providers.yaml exists"
+      })
+    };
+  }
+}
+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: `No CSV files found in ${doneDir}`,
+        hint: `Run: import-statements${providerFilter}${currencyFilter}`
+      })
+    };
+  }
+  const csvFile = csvFiles[csvFiles.length - 1];
+  const relativePath = path9.relative(path9.dirname(path9.dirname(doneDir)), csvFile);
+  return { csvFile, relativePath };
+}
+function determineClosingBalance(csvFile, config2, options, relativeCsvPath) {
+  let metadata;
+  try {
+    const content = fs10.readFileSync(csvFile, "utf-8");
+    const filename = path9.basename(csvFile);
+    const detectionResult = detectProvider(filename, content, config2);
+    metadata = detectionResult?.metadata;
+  } catch {
+    metadata = undefined;
+  }
+  let closingBalance = options.closingBalance;
+  if (!closingBalance && metadata?.closing_balance) {
+    closingBalance = metadata.closing_balance;
+    if (metadata.currency && !closingBalance.includes(metadata.currency)) {
+      closingBalance = `${metadata.currency} ${closingBalance}`;
+    }
+  }
+  if (!closingBalance) {
+    return {
+      error: buildErrorResult4({
+        csvFile: relativeCsvPath,
+        error: "No closing balance found in CSV metadata",
+        hint: "Provide closingBalance parameter manually",
+        metadata
+      })
+    };
+  }
+  return { closingBalance, metadata };
+}
+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 rulesMapping = loadRulesMapping(rulesDir);
+    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+    const rulesHint = rulesFile ? `Add 'account1 assets:bank:...' to ${rulesFile} or use --account parameter` : `Create a rules file in ${rulesDir} with 'account1' directive or use --account parameter`;
+    return {
+      error: buildErrorResult4({
+        csvFile: relativeCsvPath,
+        error: "Could not determine account from rules file",
+        hint: rulesHint,
+        metadata
+      })
+    };
+  }
+  return { account };
+}
+async function reconcileStatementCore(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
+  const restrictionError = checkAccountantAgent(agent, "reconcile statement");
+  if (restrictionError) {
+    return restrictionError;
+  }
+  const worktreeError = validateWorktree(directory, worktreeChecker);
+  if (worktreeError) {
+    return worktreeError;
+  }
+  const configResult = loadConfiguration(directory, configLoader);
+  if ("error" in configResult) {
+    return configResult.error;
+  }
+  const { config: config2 } = configResult;
+  const doneDir = path9.join(directory, config2.paths.done);
+  const rulesDir = path9.join(directory, config2.paths.rules);
+  const mainJournalPath = path9.join(directory, ".hledger.journal");
+  const csvResult = findCsvToReconcile(doneDir, options);
+  if ("error" in csvResult) {
+    return csvResult.error;
+  }
+  const { csvFile, relativePath: relativeCsvPath } = csvResult;
+  const balanceResult = determineClosingBalance(csvFile, config2, options, relativeCsvPath);
+  if ("error" in balanceResult) {
+    return balanceResult.error;
+  }
+  const { closingBalance, metadata } = balanceResult;
+  const accountResult = determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata);
+  if ("error" in accountResult) {
+    return accountResult.error;
+  }
+  const { account } = accountResult;
+  const lastTransactionDate = await getLastTransactionDate(mainJournalPath, account, hledgerExecutor);
+  if (!lastTransactionDate) {
+    return buildErrorResult4({
+      csvFile: relativeCsvPath,
+      account,
+      error: "No transactions found for account",
+      hint: "Ensure import completed successfully",
+      metadata
+    });
+  }
+  const actualBalance = await getAccountBalance(mainJournalPath, account, lastTransactionDate, hledgerExecutor);
+  if (actualBalance === null) {
+    return buildErrorResult4({
+      csvFile: relativeCsvPath,
+      account,
+      lastTransactionDate,
+      error: "Failed to query account balance from hledger",
+      hint: `Check journal syntax: hledger check -f ${mainJournalPath}`,
+      metadata
+    });
+  }
+  let doBalancesMatch;
+  try {
+    doBalancesMatch = balancesMatch(closingBalance, actualBalance);
+  } catch (error45) {
+    return buildErrorResult4({
+      csvFile: relativeCsvPath,
+      account,
+      lastTransactionDate,
+      expectedBalance: closingBalance,
+      actualBalance,
+      error: `Cannot parse balances for comparison: ${error45 instanceof Error ? error45.message : String(error45)}`,
+      metadata
+    });
+  }
+  if (doBalancesMatch) {
+    return buildSuccessResult4({
+      csvFile: relativeCsvPath,
+      account,
+      lastTransactionDate,
+      expectedBalance: closingBalance,
+      actualBalance,
+      metadata
+    });
+  }
+  let difference;
+  try {
+    difference = calculateDifference(closingBalance, actualBalance);
+  } catch (error45) {
+    return buildErrorResult4({
+      csvFile: relativeCsvPath,
+      account,
+      lastTransactionDate,
+      expectedBalance: closingBalance,
+      actualBalance,
+      error: `Failed to calculate difference: ${error45 instanceof Error ? error45.message : String(error45)}`,
+      metadata
+    });
+  }
+  return buildErrorResult4({
+    csvFile: relativeCsvPath,
+    account,
+    lastTransactionDate,
+    expectedBalance: closingBalance,
+    actualBalance,
+    difference,
+    error: `Balance mismatch: expected ${closingBalance}, got ${actualBalance} (difference: ${difference})`,
+    hint: "Check for missing transactions, duplicate imports, or incorrect rules",
+    metadata
+  });
+}
+var reconcile_statement_default = tool({
+  description: `ACCOUNTANT AGENT ONLY: Reconcile imported bank statement against closing balance.
+
+This tool validates that the imported transactions result in the correct closing balance.
+It must be run inside an import worktree (use import-pipeline for the full workflow).
+
+**Workflow:**
+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: 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`,
+  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")'),
+    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 reconcileStatementCore(directory, agent, {
+      provider: params.provider,
+      currency: params.currency,
+      closingBalance: params.closingBalance,
+      account: params.account
+    });
+  }
+});
 // src/index.ts
-var __dirname2 = dirname4(fileURLToPath(import.meta.url));
-var AGENT_FILE = join7(__dirname2, "..", "agent", "accountant.md");
+var __dirname2 = dirname5(fileURLToPath(import.meta.url));
+var AGENT_FILE = join10(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {
     tool: {
-      "update-prices": update_prices_default,
+      "fetch-currency-prices": fetch_currency_prices_default,
       "classify-statements": classify_statements_default,
-      "import-statements": import_statements_default
+      "import-statements": import_statements_default,
+      "reconcile-statements": reconcile_statement_default
     },
     config: async (config2) => {
       if (agent) {