@fuzzle/opencode-accountant 0.3.0 → 0.4.0-next.1

package/README.md

@@ -122,12 +122,21 @@ providers:
         currencyField: Currency
         skipRows: 9
         delimiter: ';'
-        renamePattern: 'transactions-ubs-{account-number}.csv'
+        renamePattern: 'ubs-{account-number}-transactions-{from-date}-to-{until-date}.csv'
         metadata:
           - field: account-number
             row: 0
             column: 1
             normalize: spaces-to-dashes
+          - field: from-date
+            row: 2
+            column: 1
+          - field: until-date
+            row: 3
+            column: 1
+          - field: closing-balance
+            row: 5
+            column: 1
     currencies:
       CHF: chf
       EUR: eur
@@ -201,9 +210,10 @@ The `import-pipeline` tool provides an atomic, safe import workflow using git wo
    - Creates an isolated git worktree
    - Syncs CSV files from main repo to worktree
    - Classifies CSV files by provider/currency
+   - Extracts accounts from rules and creates declarations in year journal
    - Validates all transactions have matching rules
    - Imports transactions to the appropriate year journal
-   - Reconciles closing balance (if available in CSV metadata)
+   - Reconciles closing balance (auto-detected from CSV metadata or data analysis)
    - Merges changes back to main branch with `--no-ff`
    - Deletes processed CSV files from main repo's import/incoming
    - Cleans up the worktree
@@ -225,7 +235,14 @@ The `import-pipeline` tool is the single entry point for importing bank statemen
 
 #### Rules File Matching
 
-The tool matches CSV files to their rules files by parsing the `source` directive in each `.rules` file. For example, if `ubs-account.rules` contains:
+The tool matches CSV files to their rules files using multiple methods:
+
+1. **Source directive matching** (primary): Parses the `source` directive in each `.rules` file and supports glob patterns
+2. **Filename matching** (fallback): If path matching fails, matches based on the rules filename prefix
+
+**Example using source directive:**
+
+If `ubs-account.rules` contains:
 
 ```
 source ../../import/pending/ubs/chf/transactions.csv
@@ -233,32 +250,58 @@ source ../../import/pending/ubs/chf/transactions.csv
 
 The tool will use that rules file when processing `transactions.csv`.
 
-**Note:** The `source` path should match your configured `{paths.pending}` directory structure.
+**Example using filename matching:**
+
+If you have a rules file named `ubs-1234-567890.rules` and a CSV file named `ubs-1234-567890-transactions-2026-01-05-to-2026-01-31.csv`, the tool will automatically match them based on the common prefix `ubs-1234-567890`.
+
+This is particularly useful when CSV files move between directories (e.g., from `pending/` to `done/`) or when maintaining exact source paths is impractical.
+
+**Note:** Name your rules files to match the prefix of your CSV files for automatic matching.
 
 See the hledger documentation for details on rules file format and syntax.
 
+#### Account Declarations
+
+The pipeline automatically manages account declarations:
+
+- Scans rules files matched to the CSVs being imported
+- Extracts all accounts (account1 and account2 directives)
+- Creates or updates year journal files with sorted account declarations
+- Ensures `hledger check --strict` validation passes
+
+**No manual account setup required.** Account declarations are created proactively before import attempts.
+
 #### Unknown Postings
 
 When a transaction doesn't match any `if` pattern in the rules file, hledger assigns it to `income:unknown` or `expenses:unknown` depending on the transaction direction. The pipeline will fail at the validation step, reporting the unknown postings so you can add appropriate rules before retrying.
 
 #### Closing Balance Reconciliation
 
-For providers that include closing balance in CSV metadata (e.g., UBS), the tool automatically validates that the imported transactions result in the correct balance. Configure metadata extraction in `providers.yaml`:
+The import pipeline automatically detects closing balance using the following fallback chain:
+
+1. **CSV Metadata Extraction**: For providers with closing balance in metadata (e.g., UBS)
+2. **CSV Data Analysis**: Extracts balance from the last transaction row if metadata unavailable
+3. **Manual Override**: Use the `closingBalance` parameter when automatic detection fails
+
+Configure metadata extraction in `providers.yaml`:
 
 ```yaml
 metadata:
-  - field: closing_balance
+  - field: closing-balance
     row: 5
     column: 1
-  - field: from_date
+  - field: from-date
     row: 2
     column: 1
-  - field: until_date
+  - field: until-date
     row: 3
     column: 1
 ```
 
-For providers without closing balance in metadata (e.g., Revolut), provide it manually via the `closingBalance` argument.
+**Note:** For most CSV formats, the closing balance will be detected automatically. Manual override is only needed when:
+
+- CSV has no balance information in metadata or data
+- The auto-detected balance has low confidence
 
 ## Development
 

package/agent/accountant.md

@@ -89,9 +89,10 @@ The `import-pipeline` tool provides an **atomic, safe workflow** using git workt
 3. **Automatic Processing**: The tool creates an isolated git worktree and:
    - Syncs CSV files from main repo to worktree
    - Classifies CSV files by provider/currency
+   - Extracts required accounts from rules files and updates year journal
    - Validates all transactions have matching rules
    - Imports transactions to the appropriate year journal
-   - Reconciles closing balance (if available in CSV metadata)
+   - Reconciles closing balance (auto-detected from CSV metadata or data, or manual override)
    - Merges changes back to main branch with `--no-ff`
    - Deletes processed CSV files from main repo's import/incoming
    - Cleans up the worktree
@@ -104,10 +105,31 @@ The `import-pipeline` tool provides an **atomic, safe workflow** using git workt
 ### Rules Files
 
 - The location of the rules files is configured in `config/import/providers.yaml`
-- Match CSV to rules file via the `source` directive in each `.rules` file
+- Match CSV to rules file via the `source` directive in each `.rules` file, with automatic fallback to filename-based matching
+- **Filename matching example:** If the rules file is named `ubs-1234-567890.rules`, it will automatically match CSV files like `ubs-1234-567890-transactions-2026-01.csv` based on the common prefix. This works even when CSV files move between directories.
+- When account detection fails, recommend users either fix their `source` directive or rename their rules file to match the CSV filename prefix
 - Use field names from the `fields` directive for matching
 - Unknown account pattern: `income:unknown` (positive amounts) / `expenses:unknown` (negative amounts)
 
+### Automatic Account Declarations
+
+The import pipeline automatically:
+
+- Scans matched rules files for all account references (account1, account2 directives)
+- Creates/updates year journal files (e.g., ledger/2026.journal) with sorted account declarations
+- Prevents `hledger check --strict` failures due to missing account declarations
+- No manual account setup required
+
+### Automatic Balance Detection
+
+The reconciliation step attempts to extract closing balance from:
+
+1. CSV header metadata (e.g., UBS "Closing balance:" row)
+2. CSV data analysis (balance field in last transaction row)
+3. Manual override via `closingBalance` parameter (fallback)
+
+For most providers, manual balance input is no longer required.
+
 ## Tool Usage Reference
 
 The following are MCP tools available to you. Always call these tools directly - do not attempt to replicate their behavior with shell commands.
@@ -138,12 +160,13 @@ The following are MCP tools available to you. Always call these tools directly -
 1. Creates isolated git worktree
 2. Syncs CSV files from main repo to worktree
 3. Classifies CSV files (unless `skipClassify: true`)
-4. Validates all transactions have matching rules (dry run)
-5. Imports transactions to year journal
-6. Reconciles closing balance against CSV metadata or manual value
-7. Merges to main with `--no-ff` commit
-8. Deletes processed CSV files from main repo's import/incoming
-9. Cleans up worktree
+4. Extracts accounts from matched rules and updates year journal with declarations
+5. Validates all transactions have matching rules (dry run)
+6. Imports transactions to year journal
+7. Reconciles closing balance (auto-detected from CSV metadata/data or manual override)
+8. Merges to main with `--no-ff` commit
+9. Deletes processed CSV files from main repo's import/incoming
+10. Cleans up worktree
 
 **Output:** Returns step-by-step results with success/failure for each phase
 

package/dist/index.js

@@ -23458,6 +23458,18 @@ function findRulesForCsv(csvPath, mapping) {
       return rulesFile;
     }
   }
+  const csvBasename = path9.basename(csvPath);
+  const matches = [];
+  for (const rulesFile of Object.values(mapping)) {
+    const rulesBasename = path9.basename(rulesFile, ".rules");
+    if (csvBasename.startsWith(rulesBasename)) {
+      matches.push({ rulesFile, prefixLength: rulesBasename.length });
+    }
+  }
+  if (matches.length > 0) {
+    matches.sort((a, b) => b.prefixLength - a.prefixLength);
+    return matches[0].rulesFile;
+  }
   return null;
 }
 
@@ -24191,12 +24203,6 @@ function buildErrorResult4(params) {
     ...params
   });
 }
-function buildSuccessResult4(params) {
-  return JSON.stringify({
-    success: true,
-    ...params
-  });
-}
 function validateWorktree(directory, worktreeChecker) {
   if (!worktreeChecker(directory)) {
     return buildErrorResult4({
@@ -24235,7 +24241,7 @@ function findCsvToReconcile(doneDir, options) {
   const relativePath = path11.relative(path11.dirname(path11.dirname(doneDir)), csvFile);
   return { csvFile, relativePath };
 }
-function determineClosingBalance(csvFile, config2, options, relativeCsvPath) {
+function determineClosingBalance(csvFile, config2, options, relativeCsvPath, rulesDir) {
   let metadata;
   try {
     const content = fs11.readFileSync(csvFile, "utf-8");
@@ -24246,25 +24252,50 @@ function determineClosingBalance(csvFile, config2, options, relativeCsvPath) {
     metadata = undefined;
   }
   let closingBalance = options.closingBalance;
-  if (!closingBalance && metadata?.closing_balance) {
-    const { closing_balance, currency } = metadata;
-    closingBalance = closing_balance;
-    if (currency && !closingBalance.includes(currency)) {
+  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 (!closingBalance) {
+    const retryCmd = buildRetryCommand(options, "CHF 2324.79", options.account);
     return {
       error: buildErrorResult4({
         csvFile: relativeCsvPath,
-        error: "No closing balance found in CSV metadata",
-        hint: "Provide closingBalance parameter manually",
+        error: "No closing balance found in CSV metadata or data",
+        hint: `Provide closingBalance parameter manually. Example retry: ${retryCmd}`,
         metadata
       })
     };
   }
   return { closingBalance, metadata };
 }
+function buildRetryCommand(options, closingBalance, account) {
+  const parts = ["import-pipeline"];
+  if (options.provider) {
+    parts.push(`--provider ${options.provider}`);
+  }
+  if (options.currency) {
+    parts.push(`--currency ${options.currency}`);
+  }
+  if (closingBalance) {
+    parts.push(`--closingBalance "${closingBalance}"`);
+  }
+  if (account) {
+    parts.push(`--account "${account}"`);
+  }
+  return parts.join(" ");
+}
 function determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata) {
   let account = options.account;
   if (!account) {
@@ -24277,7 +24308,7 @@ function determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata)
   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`;
+    const rulesHint = rulesFile ? `Add 'account1 assets:bank:...' to ${rulesFile} or retry with: ${buildRetryCommand(options, undefined, "assets:bank:...")}` : `Create a rules file in ${rulesDir} with 'account1' directive or retry with: ${buildRetryCommand(options, undefined, "assets:bank:...")}`;
     return {
       error: buildErrorResult4({
         csvFile: relativeCsvPath,
@@ -24289,6 +24320,70 @@ function determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata)
   }
   return { account };
 }
+function tryExtractClosingBalanceFromCSV(csvFile, rulesDir) {
+  try {
+    const rulesMapping = loadRulesMapping(rulesDir);
+    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+    if (!rulesFile) {
+      return null;
+    }
+    const rulesContent = fs11.readFileSync(rulesFile, "utf-8");
+    const rulesConfig = parseRulesFile(rulesContent);
+    const csvRows = parseCsvFile(csvFile, rulesConfig);
+    if (csvRows.length === 0) {
+      return null;
+    }
+    const balanceFieldNames = [
+      "balance",
+      "Balance",
+      "BALANCE",
+      "closing-balance",
+      "Closing Balance",
+      "account_balance",
+      "Account Balance",
+      "saldo",
+      "Saldo",
+      "SALDO"
+    ];
+    const lastRow = csvRows[csvRows.length - 1];
+    let balanceField;
+    let balanceValue;
+    for (const fieldName of balanceFieldNames) {
+      if (lastRow[fieldName] !== undefined && lastRow[fieldName].trim() !== "") {
+        balanceField = fieldName;
+        balanceValue = lastRow[fieldName];
+        break;
+      }
+    }
+    if (balanceValue && balanceField) {
+      const numericValue = parseAmountValue(balanceValue);
+      let currency = "";
+      const balanceCurrencyMatch = balanceValue.match(/[A-Z]{3}/);
+      if (balanceCurrencyMatch) {
+        currency = balanceCurrencyMatch[0];
+      }
+      if (!currency) {
+        const amountField = rulesConfig.amountFields.single || rulesConfig.amountFields.credit || rulesConfig.amountFields.debit;
+        if (amountField) {
+          const amountStr = lastRow[amountField] || "";
+          const currencyMatch = amountStr.match(/[A-Z]{3}/);
+          if (currencyMatch) {
+            currency = currencyMatch[0];
+          }
+        }
+      }
+      const balanceStr = currency ? `${currency} ${numericValue.toFixed(2)}` : numericValue.toFixed(2);
+      return {
+        balance: balanceStr,
+        confidence: "high",
+        method: `Extracted from ${balanceField} field in last CSV row`
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 async function reconcileStatement(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
   const restrictionError = checkAccountantAgent(agent, "reconcile statement");
   if (restrictionError) {
@@ -24311,11 +24406,11 @@ async function reconcileStatement(directory, agent, options, configLoader = load
     return csvResult.error;
   }
   const { csvFile, relativePath: relativeCsvPath } = csvResult;
-  const balanceResult = determineClosingBalance(csvFile, config2, options, relativeCsvPath);
+  const balanceResult = determineClosingBalance(csvFile, config2, options, relativeCsvPath, rulesDir);
   if ("error" in balanceResult) {
     return balanceResult.error;
   }
-  const { closingBalance, metadata } = balanceResult;
+  const { closingBalance, metadata, fromCSVAnalysis } = balanceResult;
   const accountResult = determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata);
   if ("error" in accountResult) {
     return accountResult.error;
@@ -24357,14 +24452,19 @@ async function reconcileStatement(directory, agent, options, configLoader = load
     });
   }
   if (doBalancesMatch) {
-    return buildSuccessResult4({
+    const result = {
+      success: true,
       csvFile: relativeCsvPath,
       account,
       lastTransactionDate,
       expectedBalance: closingBalance,
       actualBalance,
       metadata
-    });
+    };
+    if (fromCSVAnalysis) {
+      result.note = `Closing balance auto-detected from CSV data (no metadata available). Account: ${account}`;
+    }
+    return JSON.stringify(result);
   }
   let difference;
   try {
@@ -24429,8 +24529,125 @@ It must be run inside an import worktree (use import-pipeline for the full workf
   }
 });
 // src/tools/import-pipeline.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as path12 from "path";
+
+// src/utils/accountDeclarations.ts
+import * as fs12 from "fs";
+function extractAccountsFromRulesFile(rulesPath) {
+  const accounts = new Set;
+  if (!fs12.existsSync(rulesPath)) {
+    return accounts;
+  }
+  const content = fs12.readFileSync(rulesPath, "utf-8");
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || trimmed.startsWith(";") || trimmed === "") {
+      continue;
+    }
+    const account1Match = trimmed.match(/^account1\s+(.+?)(?:\s+|$)/);
+    if (account1Match) {
+      accounts.add(account1Match[1].trim());
+      continue;
+    }
+    const account2Match = trimmed.match(/account2\s+(.+?)(?:\s+|$)/);
+    if (account2Match) {
+      accounts.add(account2Match[1].trim());
+      continue;
+    }
+  }
+  return accounts;
+}
+function getAllAccountsFromRules(rulesPaths) {
+  const allAccounts = new Set;
+  for (const rulesPath of rulesPaths) {
+    const accounts = extractAccountsFromRulesFile(rulesPath);
+    for (const account of accounts) {
+      allAccounts.add(account);
+    }
+  }
+  return allAccounts;
+}
+function sortAccountDeclarations(accounts) {
+  return Array.from(accounts).sort((a, b) => a.localeCompare(b));
+}
+function ensureAccountDeclarations(yearJournalPath, accounts) {
+  if (!fs12.existsSync(yearJournalPath)) {
+    throw new Error(`Year journal not found: ${yearJournalPath}`);
+  }
+  const content = fs12.readFileSync(yearJournalPath, "utf-8");
+  const lines = content.split(`
+`);
+  const existingAccounts = new Set;
+  const commentLines = [];
+  const accountLines = [];
+  const otherLines = [];
+  let inAccountSection = false;
+  let accountSectionEnded = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(";") || trimmed.startsWith("#")) {
+      if (!accountSectionEnded) {
+        commentLines.push(line);
+      } else {
+        otherLines.push(line);
+      }
+      continue;
+    }
+    if (trimmed.startsWith("account ")) {
+      inAccountSection = true;
+      const accountMatch = trimmed.match(/^account\s+(.+?)(?:\s+|$)/);
+      if (accountMatch) {
+        const accountName = accountMatch[1].trim();
+        existingAccounts.add(accountName);
+        accountLines.push(line);
+      }
+      continue;
+    }
+    if (trimmed === "") {
+      if (inAccountSection && !accountSectionEnded) {
+        accountLines.push(line);
+      } else {
+        otherLines.push(line);
+      }
+      continue;
+    }
+    if (inAccountSection) {
+      accountSectionEnded = true;
+    }
+    otherLines.push(line);
+  }
+  const missingAccounts = new Set;
+  for (const account of accounts) {
+    if (!existingAccounts.has(account)) {
+      missingAccounts.add(account);
+    }
+  }
+  if (missingAccounts.size === 0) {
+    return { added: [], updated: false };
+  }
+  const allAccounts = new Set([...existingAccounts, ...missingAccounts]);
+  const sortedAccounts = sortAccountDeclarations(allAccounts);
+  const newAccountLines = sortedAccounts.map((account) => `account ${account}`);
+  const newContent = [];
+  newContent.push(...commentLines);
+  if (newAccountLines.length > 0) {
+    newContent.push("");
+    newContent.push(...newAccountLines);
+    newContent.push("");
+  }
+  newContent.push(...otherLines);
+  fs12.writeFileSync(yearJournalPath, newContent.join(`
+`));
+  return {
+    added: Array.from(missingAccounts).sort(),
+    updated: true
+  };
+}
+
+// src/tools/import-pipeline.ts
 class NoTransactionsError extends Error {
   constructor() {
     super("No transactions to import");
@@ -24444,7 +24661,7 @@ function buildStepResult(success2, message, details) {
   }
   return result;
 }
-function buildSuccessResult5(result, summary) {
+function buildSuccessResult4(result, summary) {
   result.success = true;
   result.summary = summary;
   return JSON.stringify(result);
@@ -24470,7 +24687,7 @@ function buildCommitMessage(provider, currency, fromDate, untilDate, transaction
 }
 function cleanupIncomingFiles(worktree, context) {
   const incomingDir = path12.join(worktree.mainRepoPath, "import/incoming");
-  if (!fs12.existsSync(incomingDir)) {
+  if (!fs13.existsSync(incomingDir)) {
     return;
   }
   const importStep = context.result.steps.import;
@@ -24487,9 +24704,9 @@ function cleanupIncomingFiles(worktree, context) {
       continue;
     const filename = path12.basename(fileResult.csv);
     const filePath = path12.join(incomingDir, filename);
-    if (fs12.existsSync(filePath)) {
+    if (fs13.existsSync(filePath)) {
       try {
-        fs12.unlinkSync(filePath);
+        fs13.unlinkSync(filePath);
         deletedCount++;
       } catch (error45) {
         console.error(`[ERROR] Failed to delete ${filename}: ${error45 instanceof Error ? error45.message : String(error45)}`);
@@ -24520,6 +24737,86 @@ async function executeClassifyStep(context, worktree) {
   };
   context.result.steps.classify = buildStepResult(success2, message, details);
 }
+async function executeAccountDeclarationsStep(context, worktree) {
+  const config2 = context.configLoader(worktree.path);
+  const pendingDir = path12.join(worktree.path, config2.paths.pending);
+  const rulesDir = path12.join(worktree.path, 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 rulesMapping = loadRulesMapping(rulesDir);
+  const matchedRulesFiles = new Set;
+  for (const csvFile of csvFiles) {
+    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+    if (rulesFile) {
+      matchedRulesFiles.add(rulesFile);
+    }
+  }
+  if (matchedRulesFiles.size === 0) {
+    context.result.steps.accountDeclarations = buildStepResult(true, "No matching rules files found", {
+      accountsAdded: [],
+      journalUpdated: "",
+      rulesScanned: []
+    });
+    return;
+  }
+  const allAccounts = getAllAccountsFromRules(Array.from(matchedRulesFiles));
+  if (allAccounts.size === 0) {
+    context.result.steps.accountDeclarations = buildStepResult(true, "No accounts found in rules files", {
+      accountsAdded: [],
+      journalUpdated: "",
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(worktree.path, f))
+    });
+    return;
+  }
+  let transactionYear;
+  for (const rulesFile of matchedRulesFiles) {
+    try {
+      const result2 = await context.hledgerExecutor(["print", "-f", rulesFile]);
+      if (result2.exitCode === 0) {
+        const years = extractTransactionYears(result2.stdout);
+        if (years.size > 0) {
+          transactionYear = Array.from(years)[0];
+          break;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (!transactionYear) {
+    context.result.steps.accountDeclarations = buildStepResult(false, "Could not determine transaction year from CSV files", {
+      accountsAdded: [],
+      journalUpdated: "",
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(worktree.path, f))
+    });
+    return;
+  }
+  let yearJournalPath;
+  try {
+    yearJournalPath = ensureYearJournalExists(worktree.path, transactionYear);
+  } catch (error45) {
+    context.result.steps.accountDeclarations = buildStepResult(false, `Failed to create year journal: ${error45 instanceof Error ? error45.message : String(error45)}`, {
+      accountsAdded: [],
+      journalUpdated: "",
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(worktree.path, f))
+    });
+    return;
+  }
+  const result = ensureAccountDeclarations(yearJournalPath, allAccounts);
+  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path12.relative(worktree.path, yearJournalPath)}` : "All required accounts already declared";
+  context.result.steps.accountDeclarations = buildStepResult(true, message, {
+    accountsAdded: result.added,
+    journalUpdated: path12.relative(worktree.path, yearJournalPath),
+    rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(worktree.path, f))
+  });
+}
 async function executeDryRunStep(context, worktree) {
   const inWorktree = () => true;
   const dryRunResult = await importStatements(worktree.path, context.agent, {
@@ -24591,8 +24888,8 @@ async function executeMergeStep(context, worktree) {
     throw new Error("Import or reconcile step not completed before merge");
   }
   const commitInfo = {
-    fromDate: reconcileDetails.metadata?.from_date,
-    untilDate: reconcileDetails.metadata?.until_date
+    fromDate: reconcileDetails.metadata?.["from-date"],
+    untilDate: reconcileDetails.metadata?.["until-date"]
   };
   const transactionCount = importDetails.summary?.totalTransactions || 0;
   const commitMessage = buildCommitMessage(context.options.provider, context.options.currency, commitInfo.fromDate, commitInfo.untilDate, transactionCount);
@@ -24612,7 +24909,7 @@ function handleNoTransactions(result) {
   result.steps.import = buildStepResult(true, "No transactions to import");
   result.steps.reconcile = buildStepResult(true, "Reconciliation skipped (no transactions)");
   result.steps.merge = buildStepResult(true, "Merge skipped (no changes)");
-  return buildSuccessResult5(result, "No transactions found to import");
+  return buildSuccessResult4(result, "No transactions found to import");
 }
 async function importPipeline(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
   const restrictionError = checkAccountantAgent(agent, "import pipeline");
@@ -24656,6 +24953,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
       }
       try {
         await executeClassifyStep(context, worktree);
+        await executeAccountDeclarationsStep(context, worktree);
         await executeDryRunStep(context, worktree);
         await executeImportStep(context, worktree);
         await executeReconcileStep(context, worktree);
@@ -24693,7 +24991,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
           };
         }
         const transactionCount = context.result.steps.import?.details?.summary?.totalTransactions || 0;
-        return buildSuccessResult5(result, `Successfully imported ${transactionCount} transaction(s)`);
+        return buildSuccessResult4(result, `Successfully imported ${transactionCount} transaction(s)`);
       } catch (error45) {
         result.steps.cleanup = buildStepResult(true, "Worktree cleaned up after failure (CSV files preserved for retry)", {
           cleanedAfterFailure: true,
@@ -24758,7 +25056,7 @@ This tool orchestrates the full import workflow in an isolated git worktree:
   }
 });
 // src/tools/init-directories.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as path13 from "path";
 async function initDirectories(directory) {
   try {
@@ -24766,8 +25064,8 @@ async function initDirectories(directory) {
     const directoriesCreated = [];
     const gitkeepFiles = [];
     const importBase = path13.join(directory, "import");
-    if (!fs13.existsSync(importBase)) {
-      fs13.mkdirSync(importBase, { recursive: true });
+    if (!fs14.existsSync(importBase)) {
+      fs14.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -24778,19 +25076,19 @@ async function initDirectories(directory) {
     ];
     for (const { path: dirPath } of pathsToCreate) {
       const fullPath = path13.join(directory, dirPath);
-      if (!fs13.existsSync(fullPath)) {
-        fs13.mkdirSync(fullPath, { recursive: true });
+      if (!fs14.existsSync(fullPath)) {
+        fs14.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
       const gitkeepPath = path13.join(fullPath, ".gitkeep");
-      if (!fs13.existsSync(gitkeepPath)) {
-        fs13.writeFileSync(gitkeepPath, "");
+      if (!fs14.existsSync(gitkeepPath)) {
+        fs14.writeFileSync(gitkeepPath, "");
         gitkeepFiles.push(path13.join(dirPath, ".gitkeep"));
       }
     }
     const gitignorePath = path13.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs13.existsSync(gitignorePath)) {
+    if (!fs14.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -24808,7 +25106,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs13.writeFileSync(gitignorePath, gitignoreContent);
+      fs14.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzzle/opencode-accountant",
-  "version": "0.3.0",
+  "version": "0.4.0-next.1",
   "description": "An OpenCode accounting agent, specialized in double-entry-bookkepping with hledger",
   "author": {
     "name": "ali bengali",