@fuzzle/opencode-accountant 0.4.0 → 0.4.1-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
@@ -226,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
@@ -234,7 +250,13 @@ 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.
 
@@ -265,13 +287,13 @@ 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
 ```

package/agent/accountant.md

@@ -97,15 +97,77 @@ The `import-pipeline` tool provides an **atomic, safe workflow** using git workt
    - Deletes processed CSV files from main repo's import/incoming
    - Cleans up the worktree
 4. **Handle Failures**: If any step fails (e.g., unknown postings found):
-   - Worktree is discarded, main branch remains untouched
+   - Worktree is preserved by default at `/tmp/import-worktree-<uuid>` for debugging
+   - Main branch remains untouched
    - Review error output for unknown postings with full CSV row data
    - Update rules file with `if` directives to match the transaction
    - Re-run `import-pipeline`
 
+### Error Recovery and Worktree Preservation
+
+**Default Behavior:**
+
+- On success: Worktrees are automatically cleaned up
+- On error: Worktrees are preserved in `/tmp/import-worktree-<uuid>` for debugging
+- Worktrees in `/tmp` are automatically cleaned up on system reboot
+
+**Manual Recovery from Failed Import:**
+
+If an import fails and the worktree is preserved, you can:
+
+1. **Inspect the worktree:**
+
+   ```bash
+   cd /tmp/import-worktree-<uuid>
+   hledger check                    # Validate journal
+   hledger balance                   # Check balances
+   cat ledger/2026.journal           # View imported transactions
+   ```
+
+2. **Continue the import manually:**
+
+   ```bash
+   cd /tmp/import-worktree-<uuid>
+   # Fix any issues (edit rules, fix transactions, etc.)
+   git add .
+   git commit -m "Fix import issues"
+   git checkout main
+   git merge --no-ff import-<uuid>
+   ```
+
+3. **Clean up when done:**
+
+   ```bash
+   git worktree remove /tmp/import-worktree-<uuid>
+   ```
+
+4. **Or use the cleanup tool:**
+   ```bash
+   cleanup-worktrees                 # Removes worktrees >24h old
+   cleanup-worktrees --all true      # Removes all import worktrees
+   cleanup-worktrees --dryRun true   # Preview without removing
+   ```
+
+**Logs:**
+
+- Every import run generates a detailed log: `.memory/import-<timestamp>.md`
+- Log includes all commands, output, timing, and errors
+- Log path is included in import-pipeline output
+- Review the log to understand what failed and why
+
+**Force Cleanup on Error:**
+If you prefer the old behavior (always cleanup, even on error):
+
+```bash
+import-pipeline --keepWorktreeOnError false
+```
+
 ### 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)
 

package/dist/index.js

@@ -17509,7 +17509,8 @@ function validatePaths(paths) {
     pending: pathsObj.pending,
     done: pathsObj.done,
     unrecognized: pathsObj.unrecognized,
-    rules: pathsObj.rules
+    rules: pathsObj.rules,
+    logs: pathsObj.logs
   };
 }
 function validateDetectionRule(providerName, index, rule) {
@@ -17639,6 +17640,9 @@ function loadImportConfig(directory) {
   for (const [name, config2] of Object.entries(providersObj)) {
     providers[name] = validateProviderConfig(name, config2);
   }
+  if (!paths.logs) {
+    paths.logs = ".memory";
+  }
   return { paths, providers };
 }
 
@@ -17907,15 +17911,35 @@ function isInWorktree(directory) {
     return false;
   }
 }
-async function withWorktree(directory, operation) {
+async function withWorktree(directory, operation, options) {
   let createdWorktree = null;
+  let operationSucceeded = false;
+  const logger = options?.logger;
+  const keepOnError = options?.keepOnError ?? true;
   try {
+    logger?.logStep("Create Worktree", "start");
     createdWorktree = createImportWorktree(directory);
+    logger?.logStep("Create Worktree", "success", `Path: ${createdWorktree.path}`);
+    logger?.info(`Branch: ${createdWorktree.branch}`);
+    logger?.info(`UUID: ${createdWorktree.uuid}`);
     const result = await operation(createdWorktree);
+    operationSucceeded = true;
     return result;
   } finally {
     if (createdWorktree) {
-      removeWorktree(createdWorktree, true);
+      if (operationSucceeded) {
+        logger?.logStep("Cleanup Worktree", "start");
+        removeWorktree(createdWorktree, true);
+        logger?.logStep("Cleanup Worktree", "success", "Worktree removed");
+      } else if (!keepOnError) {
+        logger?.warn("Operation failed, but keepOnError=false, removing worktree");
+        removeWorktree(createdWorktree, true);
+      } else {
+        logger?.warn("Operation failed, worktree preserved for debugging");
+        logger?.info(`Worktree path: ${createdWorktree.path}`);
+        logger?.info(`To clean up manually: git worktree remove ${createdWorktree.path}`);
+        logger?.info(`To list all worktrees: git worktree list`);
+      }
     }
   }
 }
@@ -23458,6 +23482,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;
 }
 
@@ -24016,7 +24052,7 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
     transactionYear
   };
 }
-async function importStatements(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
+async function importStatements(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree, _logger) {
   const restrictionError = checkAccountantAgent(agent, "import statements");
   if (restrictionError) {
     return restrictionError;
@@ -24240,10 +24276,11 @@ function determineClosingBalance(csvFile, config2, options, relativeCsvPath, rul
     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}`;
     }
   }
@@ -24324,7 +24361,7 @@ function tryExtractClosingBalanceFromCSV(csvFile, rulesDir) {
       "balance",
       "Balance",
       "BALANCE",
-      "closing_balance",
+      "closing-balance",
       "Closing Balance",
       "account_balance",
       "Account Balance",
@@ -24516,8 +24553,8 @@ It must be run inside an import worktree (use import-pipeline for the full workf
   }
 });
 // src/tools/import-pipeline.ts
-import * as fs13 from "fs";
-import * as path12 from "path";
+import * as fs14 from "fs";
+import * as path13 from "path";
 
 // src/utils/accountDeclarations.ts
 import * as fs12 from "fs";
@@ -24634,6 +24671,158 @@ function ensureAccountDeclarations(yearJournalPath, accounts) {
   };
 }
 
+// src/utils/logger.ts
+import fs13 from "fs/promises";
+import path12 from "path";
+
+class MarkdownLogger {
+  buffer = [];
+  logPath;
+  context = {};
+  autoFlush;
+  sectionDepth = 0;
+  constructor(config2) {
+    this.autoFlush = config2.autoFlush ?? true;
+    this.context = config2.context || {};
+    const filename = config2.filename || `import-${this.getTimestamp()}.md`;
+    this.logPath = path12.join(config2.logDir, filename);
+    this.buffer.push(`# Import Pipeline Log`);
+    this.buffer.push(`**Started**: ${new Date().toLocaleString()}`);
+    this.buffer.push("");
+  }
+  startSection(title, level = 2) {
+    this.buffer.push("");
+    this.buffer.push(`${"#".repeat(level + 1)} ${title}`);
+    this.buffer.push(`**Started**: ${this.getTime()}`);
+    this.buffer.push("");
+    this.sectionDepth++;
+  }
+  endSection() {
+    if (this.sectionDepth > 0) {
+      this.buffer.push("");
+      this.buffer.push("---");
+      this.buffer.push("");
+      this.sectionDepth--;
+    }
+  }
+  info(message) {
+    this.buffer.push(message);
+    if (this.autoFlush)
+      this.flushAsync();
+  }
+  warn(message) {
+    this.buffer.push(`\u26A0\uFE0F **WARNING**: ${message}`);
+    if (this.autoFlush)
+      this.flushAsync();
+  }
+  error(message, error45) {
+    this.buffer.push(`\u274C **ERROR**: ${message}`);
+    if (error45) {
+      const errorStr = error45 instanceof Error ? error45.message : String(error45);
+      this.buffer.push("");
+      this.buffer.push("```");
+      this.buffer.push(errorStr);
+      if (error45 instanceof Error && error45.stack) {
+        this.buffer.push("");
+        this.buffer.push(error45.stack);
+      }
+      this.buffer.push("```");
+      this.buffer.push("");
+    }
+    if (this.autoFlush)
+      this.flushAsync();
+  }
+  debug(message) {
+    this.buffer.push(`\uD83D\uDD0D ${message}`);
+    if (this.autoFlush)
+      this.flushAsync();
+  }
+  logStep(stepName, status, details) {
+    const icon = status === "success" ? "\u2705" : status === "error" ? "\u274C" : "\u25B6\uFE0F";
+    const statusText = status.charAt(0).toUpperCase() + status.slice(1);
+    this.buffer.push(`**${stepName}**: ${icon} ${statusText}`);
+    if (details) {
+      this.buffer.push(`  ${details}`);
+    }
+    this.buffer.push("");
+    if (this.autoFlush)
+      this.flushAsync();
+  }
+  logCommand(command, output) {
+    this.buffer.push("```bash");
+    this.buffer.push(`$ ${command}`);
+    if (output) {
+      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)`);
+      } else {
+        this.buffer.push(output.trim());
+      }
+    }
+    this.buffer.push("```");
+    this.buffer.push("");
+    if (this.autoFlush)
+      this.flushAsync();
+  }
+  logResult(data) {
+    this.buffer.push("```json");
+    this.buffer.push(JSON.stringify(data, null, 2));
+    this.buffer.push("```");
+    this.buffer.push("");
+    if (this.autoFlush)
+      this.flushAsync();
+  }
+  setContext(key, value) {
+    this.context[key] = value;
+  }
+  async flush() {
+    if (this.buffer.length === 0)
+      return;
+    try {
+      await fs13.mkdir(path12.dirname(this.logPath), { recursive: true });
+      await fs13.writeFile(this.logPath, this.buffer.join(`
+`), "utf-8");
+    } catch {}
+  }
+  getLogPath() {
+    return this.logPath;
+  }
+  flushAsync() {
+    this.flush().catch(() => {});
+  }
+  getTimestamp() {
+    return new Date().toISOString().replace(/:/g, "-").split(".")[0];
+  }
+  getTime() {
+    return new Date().toLocaleTimeString();
+  }
+}
+function createLogger(config2) {
+  return new MarkdownLogger(config2);
+}
+function createImportLogger(directory, worktreeId, provider) {
+  const context = {};
+  if (worktreeId)
+    context.worktreeId = worktreeId;
+  if (provider)
+    context.provider = provider;
+  const logger = createLogger({
+    logDir: path12.join(directory, ".memory"),
+    autoFlush: true,
+    context
+  });
+  if (worktreeId)
+    logger.info(`**Worktree ID**: ${worktreeId}`);
+  if (provider)
+    logger.info(`**Provider**: ${provider}`);
+  logger.info(`**Repository**: ${directory}`);
+  logger.info("");
+  return logger;
+}
+
 // src/tools/import-pipeline.ts
 class NoTransactionsError extends Error {
   constructor() {
@@ -24673,8 +24862,8 @@ function buildCommitMessage(provider, currency, fromDate, untilDate, transaction
   return `${parts.join(" ")}${dateRange}${txStr}`;
 }
 function cleanupIncomingFiles(worktree, context) {
-  const incomingDir = path12.join(worktree.mainRepoPath, "import/incoming");
-  if (!fs13.existsSync(incomingDir)) {
+  const incomingDir = path13.join(worktree.mainRepoPath, "import/incoming");
+  if (!fs14.existsSync(incomingDir)) {
     return;
   }
   const importStep = context.result.steps.import;
@@ -24689,11 +24878,11 @@ function cleanupIncomingFiles(worktree, context) {
   for (const fileResult of importResult.files) {
     if (!fileResult.csv)
       continue;
-    const filename = path12.basename(fileResult.csv);
-    const filePath = path12.join(incomingDir, filename);
-    if (fs13.existsSync(filePath)) {
+    const filename = path13.basename(fileResult.csv);
+    const filePath = path13.join(incomingDir, filename);
+    if (fs14.existsSync(filePath)) {
       try {
-        fs13.unlinkSync(filePath);
+        fs14.unlinkSync(filePath);
         deletedCount++;
       } catch (error45) {
         console.error(`[ERROR] Failed to delete ${filename}: ${error45 instanceof Error ? error45.message : String(error45)}`);
@@ -24704,9 +24893,13 @@ function cleanupIncomingFiles(worktree, context) {
     console.log(`[INFO] Cleaned up ${deletedCount} file(s) from import/incoming/`);
   }
 }
-async function executeClassifyStep(context, worktree) {
+async function executeClassifyStep(context, worktree, logger) {
+  logger?.startSection("Step 2: Classify Transactions");
+  logger?.logStep("Classify", "start");
   if (context.options.skipClassify) {
+    logger?.info("Classification skipped (skipClassify: true)");
     context.result.steps.classify = buildStepResult(true, "Classification skipped (skipClassify: true)");
+    logger?.endSection();
     return;
   }
   const inWorktree = () => true;
@@ -24716,18 +24909,23 @@ async function executeClassifyStep(context, worktree) {
   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)`);
   }
+  logger?.logStep("Classify", success2 ? "success" : "error", message);
   const details = {
     success: success2,
     unrecognized: classifyParsed.unrecognized,
     classified: classifyParsed
   };
   context.result.steps.classify = buildStepResult(success2, message, details);
+  logger?.endSection();
 }
-async function executeAccountDeclarationsStep(context, worktree) {
+async function executeAccountDeclarationsStep(context, worktree, logger) {
+  logger?.startSection("Step 3: Check Account Declarations");
+  logger?.logStep("Check Accounts", "start");
   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 pendingDir = path13.join(worktree.path, config2.paths.pending);
+  const rulesDir = path13.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", {
@@ -24758,7 +24956,7 @@ async function executeAccountDeclarationsStep(context, worktree) {
     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))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path13.relative(worktree.path, f))
     });
     return;
   }
@@ -24781,7 +24979,7 @@ async function executeAccountDeclarationsStep(context, worktree) {
     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))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path13.relative(worktree.path, f))
     });
     return;
   }
@@ -24792,19 +24990,28 @@ async function executeAccountDeclarationsStep(context, worktree) {
     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))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path13.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";
+  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path13.relative(worktree.path, yearJournalPath)}` : "All required accounts already declared";
+  logger?.logStep("Check Accounts", "success", message);
+  if (result.added.length > 0) {
+    for (const account of result.added) {
+      logger?.info(`  - ${account}`);
+    }
+  }
   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))
+    journalUpdated: path13.relative(worktree.path, yearJournalPath),
+    rulesScanned: Array.from(matchedRulesFiles).map((f) => path13.relative(worktree.path, f))
   });
+  logger?.endSection();
 }
-async function executeDryRunStep(context, worktree) {
+async function executeDryRunStep(context, worktree, logger) {
+  logger?.startSection("Step 4: Dry Run Import");
+  logger?.logStep("Dry Run", "start");
   const inWorktree = () => true;
   const dryRunResult = await importStatements(worktree.path, context.agent, {
     provider: context.options.provider,
@@ -24813,20 +25020,30 @@ async function executeDryRunStep(context, worktree) {
   }, context.configLoader, context.hledgerExecutor, inWorktree);
   const dryRunParsed = JSON.parse(dryRunResult);
   const message = dryRunParsed.success ? `Dry run passed: ${dryRunParsed.summary?.totalTransactions || 0} transactions ready` : `Dry run failed: ${dryRunParsed.summary?.unknown || 0} unknown account(s)`;
+  logger?.logStep("Dry Run", dryRunParsed.success ? "success" : "error", message);
+  if (dryRunParsed.summary?.totalTransactions) {
+    logger?.info(`Found ${dryRunParsed.summary.totalTransactions} transactions`);
+  }
   context.result.steps.dryRun = buildStepResult(dryRunParsed.success, message, {
     success: dryRunParsed.success,
     summary: dryRunParsed.summary
   });
   if (!dryRunParsed.success) {
+    logger?.error("Dry run found unknown accounts or errors");
+    logger?.endSection();
     context.result.error = "Dry run found unknown accounts or errors";
     context.result.hint = "Add rules to categorize unknown transactions, then retry";
     throw new Error("Dry run failed");
   }
   if (dryRunParsed.summary?.totalTransactions === 0) {
+    logger?.endSection();
     throw new NoTransactionsError;
   }
+  logger?.endSection();
 }
-async function executeImportStep(context, worktree) {
+async function executeImportStep(context, worktree, logger) {
+  logger?.startSection("Step 5: Import Transactions");
+  logger?.logStep("Import", "start");
   const inWorktree = () => true;
   const importResult = await importStatements(worktree.path, context.agent, {
     provider: context.options.provider,
@@ -24835,17 +25052,23 @@ async function executeImportStep(context, worktree) {
   }, context.configLoader, context.hledgerExecutor, inWorktree);
   const importParsed = JSON.parse(importResult);
   const message = importParsed.success ? `Imported ${importParsed.summary?.totalTransactions || 0} transactions` : `Import failed: ${importParsed.error || "Unknown error"}`;
+  logger?.logStep("Import", importParsed.success ? "success" : "error", message);
   context.result.steps.import = buildStepResult(importParsed.success, message, {
     success: importParsed.success,
     summary: importParsed.summary,
     error: importParsed.error
   });
   if (!importParsed.success) {
+    logger?.error("Import failed", new Error(importParsed.error || "Unknown error"));
+    logger?.endSection();
     context.result.error = `Import failed: ${importParsed.error || "Unknown error"}`;
     throw new Error("Import failed");
   }
+  logger?.endSection();
 }
-async function executeReconcileStep(context, worktree) {
+async function executeReconcileStep(context, worktree, logger) {
+  logger?.startSection("Step 6: Reconcile Balance");
+  logger?.logStep("Reconcile", "start");
   const inWorktree = () => true;
   const reconcileResult = await reconcileStatement(worktree.path, context.agent, {
     provider: context.options.provider,
@@ -24855,6 +25078,11 @@ async function executeReconcileStep(context, worktree) {
   }, context.configLoader, context.hledgerExecutor, inWorktree);
   const reconcileParsed = JSON.parse(reconcileResult);
   const message = reconcileParsed.success ? `Balance reconciled: ${reconcileParsed.actualBalance}` : `Balance mismatch: expected ${reconcileParsed.expectedBalance}, got ${reconcileParsed.actualBalance}`;
+  logger?.logStep("Reconcile", reconcileParsed.success ? "success" : "error", message);
+  if (reconcileParsed.success) {
+    logger?.info(`Actual: ${reconcileParsed.actualBalance}`);
+    logger?.info(`Expected: ${reconcileParsed.expectedBalance}`);
+  }
   context.result.steps.reconcile = buildStepResult(reconcileParsed.success, message, {
     success: reconcileParsed.success,
     actualBalance: reconcileParsed.actualBalance,
@@ -24863,29 +25091,40 @@ async function executeReconcileStep(context, worktree) {
     error: reconcileParsed.error
   });
   if (!reconcileParsed.success) {
+    logger?.error("Reconciliation failed", new Error(reconcileParsed.error || "Balance mismatch"));
+    logger?.endSection();
     context.result.error = `Reconciliation failed: ${reconcileParsed.error || "Balance mismatch"}`;
     context.result.hint = "Check for missing transactions or incorrect rules";
     throw new Error("Reconciliation failed");
   }
+  logger?.endSection();
 }
-async function executeMergeStep(context, worktree) {
+async function executeMergeStep(context, worktree, logger) {
+  logger?.startSection("Step 7: Merge to Main");
+  logger?.logStep("Merge", "start");
   const importDetails = context.result.steps.import?.details;
   const reconcileDetails = context.result.steps.reconcile?.details;
   if (!importDetails || !reconcileDetails) {
     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);
   try {
+    logger?.info(`Commit message: "${commitMessage}"`);
     mergeWorktree(worktree, commitMessage);
+    logger?.logStep("Merge", "success", "Merged to main branch");
     const mergeDetails = { commitMessage };
     context.result.steps.merge = buildStepResult(true, `Merged to main: "${commitMessage}"`, mergeDetails);
     cleanupIncomingFiles(worktree, context);
+    logger?.endSection();
   } catch (error45) {
+    logger?.logStep("Merge", "error");
+    logger?.error("Merge to main branch failed", error45);
+    logger?.endSection();
     const message = `Merge failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
     context.result.steps.merge = buildStepResult(false, message);
     context.result.error = "Merge to main branch failed";
@@ -24903,6 +25142,13 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
   if (restrictionError) {
     return restrictionError;
   }
+  const logger = createImportLogger(directory, undefined, options.provider);
+  logger.startSection("Import Pipeline", 1);
+  logger.info(`Provider filter: ${options.provider || "all"}`);
+  logger.info(`Currency filter: ${options.currency || "all"}`);
+  logger.info(`Skip classify: ${options.skipClassify || false}`);
+  logger.info(`Keep worktree on error: ${options.keepWorktreeOnError ?? true}`);
+  logger.info("");
   const result = {
     success: false,
     steps: {}
@@ -24917,33 +25163,47 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
   };
   try {
     return await withWorktree(directory, async (worktree) => {
+      logger.setContext("worktreeId", worktree.uuid);
+      logger.setContext("worktreePath", worktree.path);
       result.worktreeId = worktree.uuid;
       result.steps.worktree = buildStepResult(true, `Created worktree at ${worktree.path}`, {
         path: worktree.path,
         branch: worktree.branch
       });
+      logger.startSection("Step 1: Sync Files");
+      logger.logStep("Sync Files", "start");
       try {
         const config2 = configLoader(directory);
         const syncResult = syncCSVFilesToWorktree(directory, worktree.path, config2.paths.import);
         if (syncResult.synced.length === 0 && syncResult.errors.length === 0) {
+          logger.logStep("Sync Files", "success", "No CSV files to sync");
           result.steps.sync = buildStepResult(true, "No CSV files to sync", {
             synced: []
           });
         } else if (syncResult.errors.length > 0) {
+          logger.warn(`Synced ${syncResult.synced.length} file(s) with ${syncResult.errors.length} error(s)`);
           result.steps.sync = buildStepResult(true, `Synced ${syncResult.synced.length} file(s) with ${syncResult.errors.length} error(s)`, { synced: syncResult.synced, errors: syncResult.errors });
         } else {
+          logger.logStep("Sync Files", "success", `Synced ${syncResult.synced.length} CSV file(s)`);
+          for (const file2 of syncResult.synced) {
+            logger.info(`  - ${file2}`);
+          }
           result.steps.sync = buildStepResult(true, `Synced ${syncResult.synced.length} CSV file(s) to worktree`, { synced: syncResult.synced });
         }
+        logger.endSection();
       } catch (error45) {
+        logger.logStep("Sync Files", "error");
+        logger.error("Failed to sync CSV files", error45);
+        logger.endSection();
         const errorMsg = error45 instanceof Error ? error45.message : String(error45);
         result.steps.sync = buildStepResult(false, `Failed to sync CSV files: ${errorMsg}`, { synced: [], errors: [{ file: "unknown", error: errorMsg }] });
       }
       try {
-        await executeClassifyStep(context, worktree);
-        await executeAccountDeclarationsStep(context, worktree);
-        await executeDryRunStep(context, worktree);
-        await executeImportStep(context, worktree);
-        await executeReconcileStep(context, worktree);
+        await executeClassifyStep(context, worktree, logger);
+        await executeAccountDeclarationsStep(context, worktree, logger);
+        await executeDryRunStep(context, worktree, logger);
+        await executeImportStep(context, worktree, logger);
+        await executeReconcileStep(context, worktree, logger);
         try {
           const config2 = configLoader(directory);
           const cleanupResult = cleanupProcessedCSVFiles(directory, config2.paths.import);
@@ -24968,7 +25228,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
             }
           });
         }
-        await executeMergeStep(context, worktree);
+        await executeMergeStep(context, worktree, logger);
         const existingCleanup = result.steps.cleanup;
         if (existingCleanup) {
           existingCleanup.message += ", worktree cleaned up";
@@ -24978,10 +25238,30 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
           };
         }
         const transactionCount = context.result.steps.import?.details?.summary?.totalTransactions || 0;
+        logger.startSection("Summary");
+        logger.info(`\u2705 Import completed successfully`);
+        logger.info(`Total transactions imported: ${transactionCount}`);
+        if (context.result.steps.reconcile?.details?.actualBalance) {
+          logger.info(`Balance reconciliation: \u2705 Matched (${context.result.steps.reconcile.details.actualBalance})`);
+        }
+        logger.info(`Log file: ${logger.getLogPath()}`);
+        logger.endSection();
         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,
+        const worktreePath = context.result.steps.worktree?.details?.path;
+        const keepWorktree = options.keepWorktreeOnError ?? true;
+        logger.error("Pipeline step failed", error45);
+        if (keepWorktree && worktreePath) {
+          logger.warn(`Worktree preserved at: ${worktreePath}`);
+          logger.info(`To continue manually: cd ${worktreePath}`);
+          logger.info(`To clean up: git worktree remove ${worktreePath}`);
+        }
+        logger.info(`Log file: ${logger.getLogPath()}`);
+        result.steps.cleanup = buildStepResult(true, keepWorktree ? `Worktree preserved for debugging (CSV files preserved for retry)` : "Worktree cleaned up after failure (CSV files preserved for retry)", {
+          cleanedAfterFailure: !keepWorktree,
+          worktreePreserved: keepWorktree,
+          worktreePath,
+          preserveReason: keepWorktree ? "error occurred" : undefined,
           csvCleanup: { deleted: [] }
         });
         if (error45 instanceof NoTransactionsError) {
@@ -24992,11 +25272,18 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
         }
         return buildErrorResult5(result, result.error, result.hint);
       }
+    }, {
+      keepOnError: options.keepWorktreeOnError ?? true,
+      logger
     });
   } catch (error45) {
+    logger.error("Pipeline failed", error45);
     result.steps.worktree = buildStepResult(false, `Failed to create worktree: ${error45 instanceof Error ? error45.message : String(error45)}`);
     result.error = "Failed to create worktree";
     return buildErrorResult5(result, result.error);
+  } finally {
+    logger.endSection();
+    await logger.flush();
   }
 }
 var import_pipeline_default = tool({
@@ -25011,25 +25298,40 @@ This tool orchestrates the full import workflow in an isolated git worktree:
 4. **Import**: Imports transactions to the journal
 5. **Reconcile**: Validates closing balance matches CSV metadata
 6. **Merge**: Merges worktree to main with --no-ff
-7. **Cleanup**: Removes worktree
+7. **Cleanup**: Removes worktree (or preserves on error)
 
 **Safety Features:**
 - All changes happen in isolated worktree
-- If any step fails, worktree is discarded (main branch untouched)
+- If any step fails, worktree is preserved by default for debugging
 - Balance reconciliation ensures data integrity
 - Atomic commit with merge --no-ff preserves history
 
+**Worktree Cleanup:**
+- On success: Worktree is always cleaned up
+- On error (default): Worktree is kept at /tmp/import-worktree-<uuid> for debugging
+- On error (--keepWorktreeOnError false): Worktree is removed (old behavior)
+- Manual cleanup: git worktree remove /tmp/import-worktree-<uuid>
+- Auto cleanup: System reboot (worktrees are in /tmp)
+
+**Logging:**
+- All operations are logged to .memory/import-<timestamp>.md
+- Log includes full command output, timing, and error details
+- Log path is included in tool output for easy access
+- NO console output (avoids polluting OpenCode TUI)
+
 **Usage:**
 - Basic: import-pipeline (processes all pending CSVs)
 - Filtered: import-pipeline --provider ubs --currency chf
 - With manual balance: import-pipeline --closingBalance "CHF 1234.56"
-- Skip classify: import-pipeline --skipClassify true`,
+- Skip classify: import-pipeline --skipClassify true
+- Always cleanup: import-pipeline --keepWorktreeOnError false`,
   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 override (if not in CSV metadata)"),
     account: tool.schema.string().optional().describe("Manual account override (auto-detected from rules file if not provided)"),
-    skipClassify: tool.schema.boolean().optional().describe("Skip the classify step (default: false)")
+    skipClassify: tool.schema.boolean().optional().describe("Skip the classify step (default: false)"),
+    keepWorktreeOnError: tool.schema.boolean().optional().describe("Keep worktree on error for debugging (default: true)")
   },
   async execute(params, context) {
     const { directory, agent } = context;
@@ -25038,21 +25340,22 @@ This tool orchestrates the full import workflow in an isolated git worktree:
       currency: params.currency,
       closingBalance: params.closingBalance,
       account: params.account,
-      skipClassify: params.skipClassify
+      skipClassify: params.skipClassify,
+      keepWorktreeOnError: params.keepWorktreeOnError
     });
   }
 });
 // src/tools/init-directories.ts
-import * as fs14 from "fs";
-import * as path13 from "path";
+import * as fs15 from "fs";
+import * as path14 from "path";
 async function initDirectories(directory) {
   try {
     const config2 = loadImportConfig(directory);
     const directoriesCreated = [];
     const gitkeepFiles = [];
-    const importBase = path13.join(directory, "import");
-    if (!fs14.existsSync(importBase)) {
-      fs14.mkdirSync(importBase, { recursive: true });
+    const importBase = path14.join(directory, "import");
+    if (!fs15.existsSync(importBase)) {
+      fs15.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -25062,20 +25365,20 @@ async function initDirectories(directory) {
       { key: "unrecognized", path: config2.paths.unrecognized }
     ];
     for (const { path: dirPath } of pathsToCreate) {
-      const fullPath = path13.join(directory, dirPath);
-      if (!fs14.existsSync(fullPath)) {
-        fs14.mkdirSync(fullPath, { recursive: true });
+      const fullPath = path14.join(directory, dirPath);
+      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, "");
-        gitkeepFiles.push(path13.join(dirPath, ".gitkeep"));
+      const gitkeepPath = path14.join(fullPath, ".gitkeep");
+      if (!fs15.existsSync(gitkeepPath)) {
+        fs15.writeFileSync(gitkeepPath, "");
+        gitkeepFiles.push(path14.join(dirPath, ".gitkeep"));
       }
     }
-    const gitignorePath = path13.join(importBase, ".gitignore");
+    const gitignorePath = path14.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
@@ -25093,7 +25396,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs14.writeFileSync(gitignorePath, gitignoreContent);
+      fs15.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];

package/package.json

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