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

package/agent/accountant.md

@@ -97,71 +97,11 @@ 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 preserved by default at `/tmp/import-worktree-<uuid>` for debugging
-   - Main branch remains untouched
+   - Worktree is discarded, 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`

package/dist/index.js

@@ -17509,8 +17509,7 @@ function validatePaths(paths) {
     pending: pathsObj.pending,
     done: pathsObj.done,
     unrecognized: pathsObj.unrecognized,
-    rules: pathsObj.rules,
-    logs: pathsObj.logs
+    rules: pathsObj.rules
   };
 }
 function validateDetectionRule(providerName, index, rule) {
@@ -17640,9 +17639,6 @@ 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 };
 }
 
@@ -17911,35 +17907,15 @@ function isInWorktree(directory) {
     return false;
   }
 }
-async function withWorktree(directory, operation, options) {
+async function withWorktree(directory, operation) {
   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) {
-      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`);
-      }
+      removeWorktree(createdWorktree, true);
     }
   }
 }
@@ -24052,7 +24028,7 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
     transactionYear
   };
 }
-async function importStatements(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree, _logger) {
+async function importStatements(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
   const restrictionError = checkAccountantAgent(agent, "import statements");
   if (restrictionError) {
     return restrictionError;
@@ -24553,8 +24529,8 @@ It must be run inside an import worktree (use import-pipeline for the full workf
   }
 });
 // src/tools/import-pipeline.ts
-import * as fs14 from "fs";
-import * as path13 from "path";
+import * as fs13 from "fs";
+import * as path12 from "path";
 
 // src/utils/accountDeclarations.ts
 import * as fs12 from "fs";
@@ -24671,158 +24647,6 @@ 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() {
@@ -24862,8 +24686,8 @@ function buildCommitMessage(provider, currency, fromDate, untilDate, transaction
   return `${parts.join(" ")}${dateRange}${txStr}`;
 }
 function cleanupIncomingFiles(worktree, context) {
-  const incomingDir = path13.join(worktree.mainRepoPath, "import/incoming");
-  if (!fs14.existsSync(incomingDir)) {
+  const incomingDir = path12.join(worktree.mainRepoPath, "import/incoming");
+  if (!fs13.existsSync(incomingDir)) {
     return;
   }
   const importStep = context.result.steps.import;
@@ -24878,11 +24702,11 @@ function cleanupIncomingFiles(worktree, context) {
   for (const fileResult of importResult.files) {
     if (!fileResult.csv)
       continue;
-    const filename = path13.basename(fileResult.csv);
-    const filePath = path13.join(incomingDir, filename);
-    if (fs14.existsSync(filePath)) {
+    const filename = path12.basename(fileResult.csv);
+    const filePath = path12.join(incomingDir, filename);
+    if (fs13.existsSync(filePath)) {
       try {
-        fs14.unlinkSync(filePath);
+        fs13.unlinkSync(filePath);
         deletedCount++;
       } catch (error45) {
         console.error(`[ERROR] Failed to delete ${filename}: ${error45 instanceof Error ? error45.message : String(error45)}`);
@@ -24893,13 +24717,9 @@ function cleanupIncomingFiles(worktree, context) {
     console.log(`[INFO] Cleaned up ${deletedCount} file(s) from import/incoming/`);
   }
 }
-async function executeClassifyStep(context, worktree, logger) {
-  logger?.startSection("Step 2: Classify Transactions");
-  logger?.logStep("Classify", "start");
+async function executeClassifyStep(context, worktree) {
   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;
@@ -24909,23 +24729,18 @@ async function executeClassifyStep(context, worktree, logger) {
   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, logger) {
-  logger?.startSection("Step 3: Check Account Declarations");
-  logger?.logStep("Check Accounts", "start");
+async function executeAccountDeclarationsStep(context, worktree) {
   const config2 = context.configLoader(worktree.path);
-  const pendingDir = path13.join(worktree.path, config2.paths.pending);
-  const rulesDir = path13.join(worktree.path, config2.paths.rules);
+  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", {
@@ -24956,7 +24771,7 @@ async function executeAccountDeclarationsStep(context, worktree, logger) {
     context.result.steps.accountDeclarations = buildStepResult(true, "No accounts found in rules files", {
       accountsAdded: [],
       journalUpdated: "",
-      rulesScanned: Array.from(matchedRulesFiles).map((f) => path13.relative(worktree.path, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(worktree.path, f))
     });
     return;
   }
@@ -24979,7 +24794,7 @@ async function executeAccountDeclarationsStep(context, worktree, logger) {
     context.result.steps.accountDeclarations = buildStepResult(false, "Could not determine transaction year from CSV files", {
       accountsAdded: [],
       journalUpdated: "",
-      rulesScanned: Array.from(matchedRulesFiles).map((f) => path13.relative(worktree.path, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(worktree.path, f))
     });
     return;
   }
@@ -24990,28 +24805,19 @@ async function executeAccountDeclarationsStep(context, worktree, logger) {
     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) => path13.relative(worktree.path, f))
+      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 ${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}`);
-    }
-  }
+  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: path13.relative(worktree.path, yearJournalPath),
-    rulesScanned: Array.from(matchedRulesFiles).map((f) => path13.relative(worktree.path, f))
+    journalUpdated: path12.relative(worktree.path, yearJournalPath),
+    rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(worktree.path, f))
   });
-  logger?.endSection();
 }
-async function executeDryRunStep(context, worktree, logger) {
-  logger?.startSection("Step 4: Dry Run Import");
-  logger?.logStep("Dry Run", "start");
+async function executeDryRunStep(context, worktree) {
   const inWorktree = () => true;
   const dryRunResult = await importStatements(worktree.path, context.agent, {
     provider: context.options.provider,
@@ -25020,30 +24826,20 @@ async function executeDryRunStep(context, worktree, logger) {
   }, 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, logger) {
-  logger?.startSection("Step 5: Import Transactions");
-  logger?.logStep("Import", "start");
+async function executeImportStep(context, worktree) {
   const inWorktree = () => true;
   const importResult = await importStatements(worktree.path, context.agent, {
     provider: context.options.provider,
@@ -25052,23 +24848,17 @@ async function executeImportStep(context, worktree, logger) {
   }, 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, logger) {
-  logger?.startSection("Step 6: Reconcile Balance");
-  logger?.logStep("Reconcile", "start");
+async function executeReconcileStep(context, worktree) {
   const inWorktree = () => true;
   const reconcileResult = await reconcileStatement(worktree.path, context.agent, {
     provider: context.options.provider,
@@ -25078,11 +24868,6 @@ async function executeReconcileStep(context, worktree, logger) {
   }, 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,
@@ -25091,17 +24876,12 @@ async function executeReconcileStep(context, worktree, logger) {
     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, logger) {
-  logger?.startSection("Step 7: Merge to Main");
-  logger?.logStep("Merge", "start");
+async function executeMergeStep(context, worktree) {
   const importDetails = context.result.steps.import?.details;
   const reconcileDetails = context.result.steps.reconcile?.details;
   if (!importDetails || !reconcileDetails) {
@@ -25114,17 +24894,11 @@ async function executeMergeStep(context, worktree, logger) {
   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";
@@ -25142,13 +24916,6 @@ 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: {}
@@ -25163,47 +24930,33 @@ 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, logger);
-        await executeAccountDeclarationsStep(context, worktree, logger);
-        await executeDryRunStep(context, worktree, logger);
-        await executeImportStep(context, worktree, logger);
-        await executeReconcileStep(context, worktree, logger);
+        await executeClassifyStep(context, worktree);
+        await executeAccountDeclarationsStep(context, worktree);
+        await executeDryRunStep(context, worktree);
+        await executeImportStep(context, worktree);
+        await executeReconcileStep(context, worktree);
         try {
           const config2 = configLoader(directory);
           const cleanupResult = cleanupProcessedCSVFiles(directory, config2.paths.import);
@@ -25228,7 +24981,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
             }
           });
         }
-        await executeMergeStep(context, worktree, logger);
+        await executeMergeStep(context, worktree);
         const existingCleanup = result.steps.cleanup;
         if (existingCleanup) {
           existingCleanup.message += ", worktree cleaned up";
@@ -25238,30 +24991,10 @@ 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) {
-        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,
+        result.steps.cleanup = buildStepResult(true, "Worktree cleaned up after failure (CSV files preserved for retry)", {
+          cleanedAfterFailure: true,
           csvCleanup: { deleted: [] }
         });
         if (error45 instanceof NoTransactionsError) {
@@ -25272,18 +25005,11 @@ 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({
@@ -25298,40 +25024,25 @@ 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 (or preserves on error)
+7. **Cleanup**: Removes worktree
 
 **Safety Features:**
 - All changes happen in isolated worktree
-- If any step fails, worktree is preserved by default for debugging
+- If any step fails, worktree is discarded (main branch untouched)
 - 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
-- Always cleanup: import-pipeline --keepWorktreeOnError false`,
+- Skip classify: import-pipeline --skipClassify true`,
   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)"),
-    keepWorktreeOnError: tool.schema.boolean().optional().describe("Keep worktree on error for debugging (default: true)")
+    skipClassify: tool.schema.boolean().optional().describe("Skip the classify step (default: false)")
   },
   async execute(params, context) {
     const { directory, agent } = context;
@@ -25340,22 +25051,21 @@ This tool orchestrates the full import workflow in an isolated git worktree:
       currency: params.currency,
       closingBalance: params.closingBalance,
       account: params.account,
-      skipClassify: params.skipClassify,
-      keepWorktreeOnError: params.keepWorktreeOnError
+      skipClassify: params.skipClassify
     });
   }
 });
 // src/tools/init-directories.ts
-import * as fs15 from "fs";
-import * as path14 from "path";
+import * as fs14 from "fs";
+import * as path13 from "path";
 async function initDirectories(directory) {
   try {
     const config2 = loadImportConfig(directory);
     const directoriesCreated = [];
     const gitkeepFiles = [];
-    const importBase = path14.join(directory, "import");
-    if (!fs15.existsSync(importBase)) {
-      fs15.mkdirSync(importBase, { recursive: true });
+    const importBase = path13.join(directory, "import");
+    if (!fs14.existsSync(importBase)) {
+      fs14.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -25365,20 +25075,20 @@ async function initDirectories(directory) {
       { key: "unrecognized", path: config2.paths.unrecognized }
     ];
     for (const { path: dirPath } of pathsToCreate) {
-      const fullPath = path14.join(directory, dirPath);
-      if (!fs15.existsSync(fullPath)) {
-        fs15.mkdirSync(fullPath, { recursive: true });
+      const fullPath = path13.join(directory, dirPath);
+      if (!fs14.existsSync(fullPath)) {
+        fs14.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
-      const gitkeepPath = path14.join(fullPath, ".gitkeep");
-      if (!fs15.existsSync(gitkeepPath)) {
-        fs15.writeFileSync(gitkeepPath, "");
-        gitkeepFiles.push(path14.join(dirPath, ".gitkeep"));
+      const gitkeepPath = path13.join(fullPath, ".gitkeep");
+      if (!fs14.existsSync(gitkeepPath)) {
+        fs14.writeFileSync(gitkeepPath, "");
+        gitkeepFiles.push(path13.join(dirPath, ".gitkeep"));
       }
     }
-    const gitignorePath = path14.join(importBase, ".gitignore");
+    const gitignorePath = path13.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs15.existsSync(gitignorePath)) {
+    if (!fs14.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -25396,7 +25106,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs15.writeFileSync(gitignorePath, gitignoreContent);
+      fs14.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];

package/package.json

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