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

package/dist/index.js

@@ -1548,18 +1548,18 @@ var require_brace_expansion = __commonJS((exports, module) => {
 
 // node_modules/convert-csv-to-json/src/util/fileUtils.js
 var require_fileUtils = __commonJS((exports, module) => {
-  var fs9 = __require("fs");
+  var fs8 = __require("fs");
 
   class FileUtils {
     readFile(fileInputName, encoding) {
-      return fs9.readFileSync(fileInputName, encoding).toString();
+      return fs8.readFileSync(fileInputName, encoding).toString();
     }
     readFileAsync(fileInputName, encoding = "utf8") {
-      if (fs9.promises && typeof fs9.promises.readFile === "function") {
-        return fs9.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
+      if (fs8.promises && typeof fs8.promises.readFile === "function") {
+        return fs8.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
       }
       return new Promise((resolve2, reject) => {
-        fs9.readFile(fileInputName, encoding, (err, data) => {
+        fs8.readFile(fileInputName, encoding, (err, data) => {
           if (err) {
             reject(err);
             return;
@@ -1569,7 +1569,7 @@ var require_fileUtils = __commonJS((exports, module) => {
       });
     }
     writeFile(json3, fileOutputName) {
-      fs9.writeFile(fileOutputName, json3, function(err) {
+      fs8.writeFile(fileOutputName, json3, function(err) {
         if (err) {
           throw err;
         } else {
@@ -1578,11 +1578,11 @@ var require_fileUtils = __commonJS((exports, module) => {
       });
     }
     writeFileAsync(json3, fileOutputName) {
-      if (fs9.promises && typeof fs9.promises.writeFile === "function") {
-        return fs9.promises.writeFile(fileOutputName, json3);
+      if (fs8.promises && typeof fs8.promises.writeFile === "function") {
+        return fs8.promises.writeFile(fileOutputName, json3);
       }
       return new Promise((resolve2, reject) => {
-        fs9.writeFile(fileOutputName, json3, (err) => {
+        fs8.writeFile(fileOutputName, json3, (err) => {
           if (err)
             return reject(err);
           resolve2();
@@ -2147,7 +2147,7 @@ var require_convert_csv_to_json = __commonJS((exports) => {
 });
 
 // src/index.ts
-import { dirname as dirname6, join as join13 } from "path";
+import { dirname as dirname5, join as join12 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/utils/agentLoader.ts
@@ -17479,8 +17479,8 @@ var fetch_currency_prices_default = tool({
   }
 });
 // src/tools/classify-statements.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs5 from "fs";
+import * as path6 from "path";
 
 // src/utils/importConfig.ts
 import * as fs3 from "fs";
@@ -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 };
 }
 
@@ -17747,242 +17751,22 @@ function detectProvider(filename, content, config2) {
   return null;
 }
 
-// src/utils/worktreeManager.ts
-import { spawnSync } from "child_process";
-
-// node_modules/uuid/dist-node/stringify.js
-var byteToHex = [];
-for (let i2 = 0;i2 < 256; ++i2) {
-  byteToHex.push((i2 + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-
-// node_modules/uuid/dist-node/rng.js
-import { randomFillSync } from "crypto";
-var rnds8Pool = new Uint8Array(256);
-var poolPtr = rnds8Pool.length;
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    randomFillSync(rnds8Pool);
-    poolPtr = 0;
-  }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-
-// node_modules/uuid/dist-node/native.js
-import { randomUUID } from "crypto";
-var native_default = { randomUUID };
-
-// node_modules/uuid/dist-node/v4.js
-function _v4(options, buf, offset) {
-  options = options || {};
-  const rnds = options.random ?? options.rng?.() ?? rng();
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
-  }
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-    for (let i2 = 0;i2 < 16; ++i2) {
-      buf[offset + i2] = rnds[i2];
-    }
-    return buf;
-  }
-  return unsafeStringify(rnds);
-}
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
-  }
-  return _v4(options, buf, offset);
-}
-var v4_default = v4;
-// src/utils/worktreeManager.ts
+// src/utils/fileUtils.ts
 import * as fs4 from "fs";
 import * as path5 from "path";
-function execGit(args, cwd) {
-  const result = spawnSync("git", args, { cwd, encoding: "utf-8" });
-  if (result.status !== 0) {
-    throw new Error(result.stderr || result.stdout || `git ${args[0]} failed`);
-  }
-  return (result.stdout || "").trim();
-}
-function execGitSafe(args, cwd) {
-  const result = spawnSync("git", args, { cwd, encoding: "utf-8" });
-  if (result.status !== 0) {
-    return { success: false, output: result.stderr || result.stdout || `git ${args[0]} failed` };
-  }
-  return { success: true, output: (result.stdout || "").trim() };
-}
-function copyIncomingFiles(mainRepoPath, worktreePath) {
-  const sourceDir = path5.join(mainRepoPath, "import/incoming");
-  const targetDir = path5.join(worktreePath, "import/incoming");
-  if (!fs4.existsSync(sourceDir)) {
-    return;
-  }
-  fs4.mkdirSync(targetDir, { recursive: true });
-  const entries = fs4.readdirSync(sourceDir, { withFileTypes: true });
-  let copiedCount = 0;
-  for (const entry of entries) {
-    if (entry.isFile() && !entry.name.startsWith(".")) {
-      const srcPath = path5.join(sourceDir, entry.name);
-      const destPath = path5.join(targetDir, entry.name);
-      fs4.copyFileSync(srcPath, destPath);
-      copiedCount++;
-    }
-  }
-  if (copiedCount > 0) {
-    console.log(`[INFO] Copied ${copiedCount} file(s) from import/incoming/ to worktree`);
-  }
-}
-function createImportWorktree(mainRepoPath, options = {}) {
-  const baseDir = options.baseDir ?? "/tmp";
-  const uuid3 = v4_default();
-  const branch = `import-${uuid3}`;
-  const worktreePath = path5.join(baseDir, `import-worktree-${uuid3}`);
-  try {
-    execGit(["rev-parse", "--git-dir"], mainRepoPath);
-  } catch {
-    throw new Error(`Not a git repository: ${mainRepoPath}`);
-  }
-  execGit(["branch", branch], mainRepoPath);
-  try {
-    execGit(["worktree", "add", worktreePath, branch], mainRepoPath);
-  } catch (error45) {
-    execGitSafe(["branch", "-D", branch], mainRepoPath);
-    throw error45;
-  }
-  copyIncomingFiles(mainRepoPath, worktreePath);
-  return {
-    path: worktreePath,
-    branch,
-    uuid: uuid3,
-    mainRepoPath
-  };
-}
-function mergeWorktree(context, commitMessage) {
-  const status = execGit(["status", "--porcelain"], context.path);
-  if (status.length > 0) {
-    execGit(["add", "-A"], context.path);
-    execGit(["commit", "-m", commitMessage], context.path);
-  }
-  const currentBranch = execGit(["rev-parse", "--abbrev-ref", "HEAD"], context.mainRepoPath);
-  execGit(["merge", "--no-ff", context.branch, "-m", commitMessage], context.mainRepoPath);
-  if (currentBranch !== "main" && currentBranch !== "master") {
-    execGit(["checkout", currentBranch], context.mainRepoPath);
-  }
-}
-function removeWorktree(context, force = false) {
-  const forceFlag = force ? "--force" : "";
-  const args = ["worktree", "remove", context.path];
-  if (forceFlag) {
-    args.push(forceFlag);
-  }
-  const removeResult = execGitSafe(args, context.mainRepoPath);
-  if (!removeResult.success) {
-    if (!fs4.existsSync(context.path)) {} else {
-      return { success: false, error: `Failed to remove worktree: ${removeResult.output}` };
-    }
-  }
-  execGitSafe(["worktree", "prune"], context.mainRepoPath);
-  const branchResult = execGitSafe(["branch", "-D", context.branch], context.mainRepoPath);
-  if (!branchResult.success) {
-    if (!branchResult.output.includes("not found")) {
-      return { success: false, error: `Failed to delete branch: ${branchResult.output}` };
-    }
-  }
-  return { success: true };
-}
-function isInWorktree(directory) {
-  try {
-    const gitDir = execGit(["rev-parse", "--git-dir"], directory);
-    return gitDir.includes(".git/worktrees/");
-  } catch {
-    return false;
-  }
-}
-async function withWorktree(directory, operation) {
-  let createdWorktree = null;
-  try {
-    createdWorktree = createImportWorktree(directory);
-    const result = await operation(createdWorktree);
-    return result;
-  } finally {
-    if (createdWorktree) {
-      removeWorktree(createdWorktree, true);
-    }
-  }
-}
-
-// src/utils/fileUtils.ts
-import * as fs5 from "fs";
-import * as path6 from "path";
 function findCSVFiles(importsDir) {
-  if (!fs5.existsSync(importsDir)) {
+  if (!fs4.existsSync(importsDir)) {
     return [];
   }
-  return fs5.readdirSync(importsDir).filter((file2) => file2.toLowerCase().endsWith(".csv")).filter((file2) => {
-    const fullPath = path6.join(importsDir, file2);
-    return fs5.statSync(fullPath).isFile();
+  return fs4.readdirSync(importsDir).filter((file2) => file2.toLowerCase().endsWith(".csv")).filter((file2) => {
+    const fullPath = path5.join(importsDir, file2);
+    return fs4.statSync(fullPath).isFile();
   });
 }
 function ensureDirectory(dirPath) {
-  if (!fs5.existsSync(dirPath)) {
-    fs5.mkdirSync(dirPath, { recursive: true });
-  }
-}
-function syncCSVFilesToWorktree(mainRepoPath, worktreePath, importDir) {
-  const result = {
-    synced: [],
-    errors: []
-  };
-  const mainImportDir = path6.join(mainRepoPath, importDir);
-  const worktreeImportDir = path6.join(worktreePath, importDir);
-  const csvFiles = findCSVFiles(mainImportDir);
-  if (csvFiles.length === 0) {
-    return result;
-  }
-  ensureDirectory(worktreeImportDir);
-  for (const file2 of csvFiles) {
-    try {
-      const sourcePath = path6.join(mainImportDir, file2);
-      const destPath = path6.join(worktreeImportDir, file2);
-      fs5.copyFileSync(sourcePath, destPath);
-      result.synced.push(file2);
-    } catch (error45) {
-      const errorMsg = error45 instanceof Error ? error45.message : String(error45);
-      result.errors.push({ file: file2, error: errorMsg });
-    }
-  }
-  return result;
-}
-function cleanupProcessedCSVFiles(mainRepoPath, importDir) {
-  const result = {
-    deleted: [],
-    errors: []
-  };
-  const mainImportDir = path6.join(mainRepoPath, importDir);
-  const csvFiles = findCSVFiles(mainImportDir);
-  if (csvFiles.length === 0) {
-    return result;
-  }
-  for (const file2 of csvFiles) {
-    try {
-      const filePath = path6.join(mainImportDir, file2);
-      fs5.unlinkSync(filePath);
-      result.deleted.push(file2);
-    } catch (error45) {
-      const errorMsg = error45 instanceof Error ? error45.message : String(error45);
-      result.errors.push({ file: file2, error: errorMsg });
-    }
+  if (!fs4.existsSync(dirPath)) {
+    fs4.mkdirSync(dirPath, { recursive: true });
   }
-  return result;
 }
 
 // src/tools/classify-statements.ts
@@ -18022,20 +17806,20 @@ function planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2) {
   const plannedMoves = [];
   const collisions = [];
   for (const filename of csvFiles) {
-    const sourcePath = path7.join(importsDir, filename);
-    const content = fs6.readFileSync(sourcePath, "utf-8");
+    const sourcePath = path6.join(importsDir, filename);
+    const content = fs5.readFileSync(sourcePath, "utf-8");
     const detection = detectProvider(filename, content, config2);
     let targetPath;
     let targetFilename;
     if (detection) {
       targetFilename = detection.outputFilename || filename;
-      const targetDir = path7.join(pendingDir, detection.provider, detection.currency);
-      targetPath = path7.join(targetDir, targetFilename);
+      const targetDir = path6.join(pendingDir, detection.provider, detection.currency);
+      targetPath = path6.join(targetDir, targetFilename);
     } else {
       targetFilename = filename;
-      targetPath = path7.join(unrecognizedDir, filename);
+      targetPath = path6.join(unrecognizedDir, filename);
     }
-    if (fs6.existsSync(targetPath)) {
+    if (fs5.existsSync(targetPath)) {
       collisions.push({
         filename,
         existingPath: targetPath
@@ -18056,28 +17840,28 @@ function executeMoves(plannedMoves, config2, unrecognizedDir) {
   const unrecognized = [];
   for (const move of plannedMoves) {
     if (move.detection) {
-      const targetDir = path7.dirname(move.targetPath);
+      const targetDir = path6.dirname(move.targetPath);
       ensureDirectory(targetDir);
-      fs6.renameSync(move.sourcePath, move.targetPath);
+      fs5.renameSync(move.sourcePath, move.targetPath);
       classified.push({
         filename: move.targetFilename,
         originalFilename: move.detection.outputFilename ? move.filename : undefined,
         provider: move.detection.provider,
         currency: move.detection.currency,
-        targetPath: path7.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename)
+        targetPath: path6.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename)
       });
     } else {
       ensureDirectory(unrecognizedDir);
-      fs6.renameSync(move.sourcePath, move.targetPath);
+      fs5.renameSync(move.sourcePath, move.targetPath);
       unrecognized.push({
         filename: move.filename,
-        targetPath: path7.join(config2.paths.unrecognized, move.filename)
+        targetPath: path6.join(config2.paths.unrecognized, move.filename)
       });
     }
   }
   return { classified, unrecognized };
 }
-async function classifyStatements(directory, agent, configLoader = loadImportConfig, worktreeChecker = isInWorktree) {
+async function classifyStatements(directory, agent, configLoader = loadImportConfig) {
   const restrictionError = checkAccountantAgent(agent, "classify statements", {
     classified: [],
     unrecognized: []
@@ -18085,9 +17869,6 @@ async function classifyStatements(directory, agent, configLoader = loadImportCon
   if (restrictionError) {
     return restrictionError;
   }
-  if (!worktreeChecker(directory)) {
-    return buildErrorResult2("classify-statements must be run inside an import worktree", "Use import-pipeline tool to orchestrate the full workflow");
-  }
   let config2;
   try {
     config2 = configLoader(directory);
@@ -18095,9 +17876,9 @@ async function classifyStatements(directory, agent, configLoader = loadImportCon
     const errorMessage = err instanceof Error ? err.message : String(err);
     return buildErrorResult2(errorMessage);
   }
-  const importsDir = path7.join(directory, config2.paths.import);
-  const pendingDir = path7.join(directory, config2.paths.pending);
-  const unrecognizedDir = path7.join(directory, config2.paths.unrecognized);
+  const importsDir = path6.join(directory, config2.paths.import);
+  const pendingDir = path6.join(directory, config2.paths.pending);
+  const unrecognizedDir = path6.join(directory, config2.paths.unrecognized);
   const csvFiles = findCSVFiles(importsDir);
   if (csvFiles.length === 0) {
     return buildSuccessResult2([], [], `No CSV files found in ${config2.paths.import}`);
@@ -18118,8 +17899,8 @@ var classify_statements_default = tool({
   }
 });
 // src/tools/import-statements.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
 
 // node_modules/minimatch/dist/esm/index.js
 var import_brace_expansion = __toESM(require_brace_expansion(), 1);
@@ -18712,11 +18493,11 @@ var qmarksTestNoExtDot = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path8 = {
+var path7 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep = defaultPlatform === "win32" ? path8.win32.sep : path8.posix.sep;
+var sep = defaultPlatform === "win32" ? path7.win32.sep : path7.posix.sep;
 minimatch.sep = sep;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -20450,7 +20231,7 @@ class LRUCache {
 // node_modules/path-scurry/dist/esm/index.js
 import { posix, win32 } from "path";
 import { fileURLToPath } from "url";
-import { lstatSync, readdir as readdirCB, readdirSync as readdirSync4, readlinkSync, realpathSync as rps } from "fs";
+import { lstatSync, readdir as readdirCB, readdirSync as readdirSync3, readlinkSync, realpathSync as rps } from "fs";
 import * as actualFS from "fs";
 import { lstat, readdir, readlink, realpath } from "fs/promises";
 
@@ -21122,7 +20903,7 @@ var realpathSync = rps.native;
 var defaultFS = {
   lstatSync,
   readdir: readdirCB,
-  readdirSync: readdirSync4,
+  readdirSync: readdirSync3,
   readlinkSync,
   realpathSync,
   promises: {
@@ -21321,12 +21102,12 @@ class PathBase {
   childrenCache() {
     return this.#children;
   }
-  resolve(path9) {
-    if (!path9) {
+  resolve(path8) {
+    if (!path8) {
       return this;
     }
-    const rootPath = this.getRootString(path9);
-    const dir = path9.substring(rootPath.length);
+    const rootPath = this.getRootString(path8);
+    const dir = path8.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -21855,8 +21636,8 @@ class PathWin32 extends PathBase {
   newChild(name, type2 = UNKNOWN, opts = {}) {
     return new PathWin32(name, type2, this.root, this.roots, this.nocase, this.childrenCache(), opts);
   }
-  getRootString(path9) {
-    return win32.parse(path9).root;
+  getRootString(path8) {
+    return win32.parse(path8).root;
   }
   getRoot(rootPath) {
     rootPath = uncToDrive(rootPath.toUpperCase());
@@ -21882,8 +21663,8 @@ class PathPosix extends PathBase {
   constructor(name, type2 = UNKNOWN, root, roots, nocase, children, opts) {
     super(name, type2, root, roots, nocase, children, opts);
   }
-  getRootString(path9) {
-    return path9.startsWith("/") ? "/" : "";
+  getRootString(path8) {
+    return path8.startsWith("/") ? "/" : "";
   }
   getRoot(_rootPath) {
     return this.root;
@@ -21903,8 +21684,8 @@ class PathScurryBase {
   #children;
   nocase;
   #fs;
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs7 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs7);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs6);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = fileURLToPath(cwd);
     }
@@ -21940,11 +21721,11 @@ class PathScurryBase {
     }
     this.cwd = prev;
   }
-  depth(path9 = this.cwd) {
-    if (typeof path9 === "string") {
-      path9 = this.cwd.resolve(path9);
+  depth(path8 = this.cwd) {
+    if (typeof path8 === "string") {
+      path8 = this.cwd.resolve(path8);
     }
-    return path9.depth();
+    return path8.depth();
   }
   childrenCache() {
     return this.#children;
@@ -22360,9 +22141,9 @@ class PathScurryBase {
     process2();
     return results;
   }
-  chdir(path9 = this.cwd) {
+  chdir(path8 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path9 === "string" ? this.cwd.resolve(path9) : path9;
+    this.cwd = typeof path8 === "string" ? this.cwd.resolve(path8) : path8;
     this.cwd[setAsCwd](oldCwd);
   }
 }
@@ -22380,8 +22161,8 @@ class PathScurryWin32 extends PathScurryBase {
   parseRootPath(dir) {
     return win32.parse(dir).root.toUpperCase();
   }
-  newRoot(fs7) {
-    return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
+  newRoot(fs6) {
+    return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
   }
   isAbsolute(p) {
     return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
@@ -22398,8 +22179,8 @@ class PathScurryPosix extends PathScurryBase {
   parseRootPath(_dir) {
     return "/";
   }
-  newRoot(fs7) {
-    return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
+  newRoot(fs6) {
+    return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
   }
   isAbsolute(p) {
     return p.startsWith("/");
@@ -22651,8 +22432,8 @@ class MatchRecord {
     this.store.set(target, current === undefined ? n : n & current);
   }
   entries() {
-    return [...this.store.entries()].map(([path9, n]) => [
-      path9,
+    return [...this.store.entries()].map(([path8, n]) => [
+      path8,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -22855,9 +22636,9 @@ class GlobUtil {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path9, opts) {
+  constructor(patterns, path8, opts) {
     this.patterns = patterns;
-    this.path = path9;
+    this.path = path8;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -22876,11 +22657,11 @@ class GlobUtil {
       });
     }
   }
-  #ignored(path9) {
-    return this.seen.has(path9) || !!this.#ignore?.ignored?.(path9);
+  #ignored(path8) {
+    return this.seen.has(path8) || !!this.#ignore?.ignored?.(path8);
   }
-  #childrenIgnored(path9) {
-    return !!this.#ignore?.childrenIgnored?.(path9);
+  #childrenIgnored(path8) {
+    return !!this.#ignore?.childrenIgnored?.(path8);
   }
   pause() {
     this.paused = true;
@@ -23093,8 +22874,8 @@ class GlobUtil {
 
 class GlobWalker extends GlobUtil {
   matches = new Set;
-  constructor(patterns, path9, opts) {
-    super(patterns, path9, opts);
+  constructor(patterns, path8, opts) {
+    super(patterns, path8, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -23132,8 +22913,8 @@ class GlobWalker extends GlobUtil {
 
 class GlobStream extends GlobUtil {
   results;
-  constructor(patterns, path9, opts) {
-    super(patterns, path9, opts);
+  constructor(patterns, path8, opts) {
+    super(patterns, path8, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -23401,8 +23182,8 @@ var glob = Object.assign(glob_, {
 glob.glob = glob;
 
 // src/utils/rulesMatcher.ts
-import * as fs7 from "fs";
-import * as path9 from "path";
+import * as fs6 from "fs";
+import * as path8 from "path";
 function parseSourceDirective(content) {
   const match2 = content.match(/^source\s+([^\n#]+)/m);
   if (!match2) {
@@ -23411,28 +23192,28 @@ function parseSourceDirective(content) {
   return match2[1].trim();
 }
 function resolveSourcePath(sourcePath, rulesFilePath) {
-  if (path9.isAbsolute(sourcePath)) {
+  if (path8.isAbsolute(sourcePath)) {
     return sourcePath;
   }
-  const rulesDir = path9.dirname(rulesFilePath);
-  return path9.resolve(rulesDir, sourcePath);
+  const rulesDir = path8.dirname(rulesFilePath);
+  return path8.resolve(rulesDir, sourcePath);
 }
 function loadRulesMapping(rulesDir) {
   const mapping = {};
-  if (!fs7.existsSync(rulesDir)) {
+  if (!fs6.existsSync(rulesDir)) {
     return mapping;
   }
-  const files = fs7.readdirSync(rulesDir);
+  const files = fs6.readdirSync(rulesDir);
   for (const file2 of files) {
     if (!file2.endsWith(".rules")) {
       continue;
     }
-    const rulesFilePath = path9.join(rulesDir, file2);
-    const stat = fs7.statSync(rulesFilePath);
+    const rulesFilePath = path8.join(rulesDir, file2);
+    const stat = fs6.statSync(rulesFilePath);
     if (!stat.isFile()) {
       continue;
     }
-    const content = fs7.readFileSync(rulesFilePath, "utf-8");
+    const content = fs6.readFileSync(rulesFilePath, "utf-8");
     const sourcePath = parseSourceDirective(content);
     if (!sourcePath) {
       continue;
@@ -23446,22 +23227,22 @@ function findRulesForCsv(csvPath, mapping) {
   if (mapping[csvPath]) {
     return mapping[csvPath];
   }
-  const normalizedCsvPath = path9.normalize(csvPath);
+  const normalizedCsvPath = path8.normalize(csvPath);
   for (const [mappedCsv, rulesFile] of Object.entries(mapping)) {
-    const normalizedMappedCsv = path9.normalize(mappedCsv);
+    const normalizedMappedCsv = path8.normalize(mappedCsv);
     if (normalizedMappedCsv === normalizedCsvPath) {
       return rulesFile;
     }
   }
   for (const [pattern, rulesFile] of Object.entries(mapping)) {
-    if (minimatch(csvPath, pattern) || minimatch(normalizedCsvPath, path9.normalize(pattern))) {
+    if (minimatch(csvPath, pattern) || minimatch(normalizedCsvPath, path8.normalize(pattern))) {
       return rulesFile;
     }
   }
-  const csvBasename = path9.basename(csvPath);
+  const csvBasename = path8.basename(csvPath);
   const matches = [];
   for (const rulesFile of Object.values(mapping)) {
-    const rulesBasename = path9.basename(rulesFile, ".rules");
+    const rulesBasename = path8.basename(rulesFile, ".rules");
     if (csvBasename.startsWith(rulesBasename)) {
       matches.push({ rulesFile, prefixLength: rulesBasename.length });
     }
@@ -23592,7 +23373,7 @@ async function getAccountBalance(mainJournalPath, account, asOfDate, executor =
 }
 
 // src/utils/rulesParser.ts
-import * as fs8 from "fs";
+import * as fs7 from "fs";
 function parseSkipRows(rulesContent) {
   const match2 = rulesContent.match(/^skip\s+(\d+)/m);
   return match2 ? parseInt(match2[1], 10) : 0;
@@ -23658,7 +23439,7 @@ function parseAccount1(rulesContent) {
 }
 function getAccountFromRulesFile(rulesFilePath) {
   try {
-    const content = fs8.readFileSync(rulesFilePath, "utf-8");
+    const content = fs7.readFileSync(rulesFilePath, "utf-8");
     return parseAccount1(content);
   } catch {
     return null;
@@ -23678,7 +23459,7 @@ function parseRulesFile(rulesContent) {
 
 // src/utils/csvParser.ts
 var import_convert_csv_to_json = __toESM(require_convert_csv_to_json(), 1);
-import * as fs9 from "fs";
+import * as fs8 from "fs";
 
 // src/utils/balanceUtils.ts
 function parseAmountValue(amountStr) {
@@ -23727,7 +23508,7 @@ function balancesMatch(balance1, balance2) {
 
 // src/utils/csvParser.ts
 function parseCsvFile(csvPath, config2) {
-  const csvContent = fs9.readFileSync(csvPath, "utf-8");
+  const csvContent = fs8.readFileSync(csvPath, "utf-8");
   const lines = csvContent.split(`
 `);
   const headerIndex = config2.skipRows;
@@ -23885,21 +23666,21 @@ function buildSuccessResult3(files, summary, message) {
   });
 }
 function findCsvFromRulesFile(rulesFile) {
-  const content = fs10.readFileSync(rulesFile, "utf-8");
+  const content = fs9.readFileSync(rulesFile, "utf-8");
   const match2 = content.match(/^source\s+([^\n#]+)/m);
   if (!match2) {
     return null;
   }
   const sourcePath = match2[1].trim();
-  const rulesDir = path10.dirname(rulesFile);
-  const absolutePattern = path10.resolve(rulesDir, sourcePath);
+  const rulesDir = path9.dirname(rulesFile);
+  const absolutePattern = path9.resolve(rulesDir, sourcePath);
   const matches = glob.sync(absolutePattern);
   if (matches.length === 0) {
     return null;
   }
   matches.sort((a, b) => {
-    const aStat = fs10.statSync(a);
-    const bStat = fs10.statSync(b);
+    const aStat = fs9.statSync(a);
+    const bStat = fs9.statSync(b);
     return bStat.mtime.getTime() - aStat.mtime.getTime();
   });
   return matches[0];
@@ -23907,7 +23688,7 @@ function findCsvFromRulesFile(rulesFile) {
 async function executeImports(fileResults, directory, pendingDir, doneDir, hledgerExecutor) {
   const importedFiles = [];
   for (const fileResult of fileResults) {
-    const rulesFile = fileResult.rulesFile ? path10.join(directory, fileResult.rulesFile) : null;
+    const rulesFile = fileResult.rulesFile ? path9.join(directory, fileResult.rulesFile) : null;
     if (!rulesFile)
       continue;
     const year = fileResult.transactionYear;
@@ -23939,7 +23720,7 @@ async function executeImports(fileResults, directory, pendingDir, doneDir, hledg
       importedFiles.push(importedCsv);
     }
   }
-  const mainJournalPath = path10.join(directory, ".hledger.journal");
+  const mainJournalPath = path9.join(directory, ".hledger.journal");
   const validationResult = await validateLedger(mainJournalPath, hledgerExecutor);
   if (!validationResult.valid) {
     return {
@@ -23949,13 +23730,13 @@ async function executeImports(fileResults, directory, pendingDir, doneDir, hledg
     };
   }
   for (const csvFile of importedFiles) {
-    const relativePath = path10.relative(pendingDir, csvFile);
-    const destPath = path10.join(doneDir, relativePath);
-    const destDir = path10.dirname(destPath);
-    if (!fs10.existsSync(destDir)) {
-      fs10.mkdirSync(destDir, { recursive: true });
+    const relativePath = path9.relative(pendingDir, csvFile);
+    const destPath = path9.join(doneDir, relativePath);
+    const destDir = path9.dirname(destPath);
+    if (!fs9.existsSync(destDir)) {
+      fs9.mkdirSync(destDir, { recursive: true });
     }
-    fs10.renameSync(csvFile, destPath);
+    fs9.renameSync(csvFile, destPath);
   }
   return {
     success: true,
@@ -23966,7 +23747,7 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   const rulesFile = findRulesForCsv(csvFile, rulesMapping);
   if (!rulesFile) {
     return {
-      csv: path10.relative(directory, csvFile),
+      csv: path9.relative(directory, csvFile),
       rulesFile: null,
       totalTransactions: 0,
       matchedTransactions: 0,
@@ -23977,8 +23758,8 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   const result = await hledgerExecutor(["print", "-f", rulesFile]);
   if (result.exitCode !== 0) {
     return {
-      csv: path10.relative(directory, csvFile),
-      rulesFile: path10.relative(directory, rulesFile),
+      csv: path9.relative(directory, csvFile),
+      rulesFile: path9.relative(directory, rulesFile),
       totalTransactions: 0,
       matchedTransactions: 0,
       unknownPostings: [],
@@ -23992,8 +23773,8 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   if (years.size > 1) {
     const yearList = Array.from(years).sort().join(", ");
     return {
-      csv: path10.relative(directory, csvFile),
-      rulesFile: path10.relative(directory, rulesFile),
+      csv: path9.relative(directory, csvFile),
+      rulesFile: path9.relative(directory, rulesFile),
       totalTransactions: transactionCount,
       matchedTransactions: matchedCount,
       unknownPostings: [],
@@ -24003,7 +23784,7 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   const transactionYear = years.size === 1 ? Array.from(years)[0] : undefined;
   if (unknownPostings.length > 0) {
     try {
-      const rulesContent = fs10.readFileSync(rulesFile, "utf-8");
+      const rulesContent = fs9.readFileSync(rulesFile, "utf-8");
       const rulesConfig = parseRulesFile(rulesContent);
       const csvRows = parseCsvFile(csvFile, rulesConfig);
       for (const posting of unknownPostings) {
@@ -24020,22 +23801,19 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
     }
   }
   return {
-    csv: path10.relative(directory, csvFile),
-    rulesFile: path10.relative(directory, rulesFile),
+    csv: path9.relative(directory, csvFile),
+    rulesFile: path9.relative(directory, rulesFile),
     totalTransactions: transactionCount,
     matchedTransactions: matchedCount,
     unknownPostings,
     transactionYear
   };
 }
-async function importStatements(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
+async function importStatements(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
   const restrictionError = checkAccountantAgent(agent, "import statements");
   if (restrictionError) {
     return restrictionError;
   }
-  if (!worktreeChecker(directory)) {
-    return buildErrorResult3("import-statements must be run inside an import worktree", "Use import-pipeline tool to orchestrate the full workflow");
-  }
   let config2;
   try {
     config2 = configLoader(directory);
@@ -24043,9 +23821,9 @@ async function importStatements(directory, agent, options, configLoader = loadIm
     const errorMessage = `Failed to load configuration: ${error45 instanceof Error ? error45.message : String(error45)}`;
     return buildErrorResult3(errorMessage, 'Ensure config/import/providers.yaml exists with required paths including "rules"');
   }
-  const pendingDir = path10.join(directory, config2.paths.pending);
-  const rulesDir = path10.join(directory, config2.paths.rules);
-  const doneDir = path10.join(directory, config2.paths.done);
+  const pendingDir = path9.join(directory, config2.paths.pending);
+  const rulesDir = path9.join(directory, config2.paths.rules);
+  const doneDir = path9.join(directory, config2.paths.done);
   const rulesMapping = loadRulesMapping(rulesDir);
   const csvFiles = findCsvFiles(pendingDir, options.provider, options.currency);
   if (csvFiles.length === 0) {
@@ -24089,8 +23867,8 @@ async function importStatements(directory, agent, options, configLoader = loadIm
   }
   for (const [_rulesFile, matchingCSVs] of rulesFileToCSVs.entries()) {
     matchingCSVs.sort((a, b) => {
-      const aStat = fs10.statSync(a);
-      const bStat = fs10.statSync(b);
+      const aStat = fs9.statSync(a);
+      const bStat = fs9.statSync(b);
       return bStat.mtime.getTime() - aStat.mtime.getTime();
     });
     const newestCSV = matchingCSVs[0];
@@ -24179,7 +23957,9 @@ This tool processes CSV files in the pending import directory and uses hledger's
 1. Run with checkOnly: true (or no args)
 2. If unknowns found, add rules to the appropriate .rules file
 3. Repeat until no unknowns
-4. Run with checkOnly: false to import`,
+4. Run with checkOnly: false to import
+
+Note: This tool is typically called via import-pipeline for the full workflow.`,
   args: {
     provider: tool.schema.string().optional().describe('Filter by provider (e.g., "revolut", "ubs"). If omitted, process all providers.'),
     currency: tool.schema.string().optional().describe('Filter by currency (e.g., "chf", "eur"). If omitted, process all currencies for the provider.'),
@@ -24195,23 +23975,14 @@ This tool processes CSV files in the pending import directory and uses hledger's
   }
 });
 // src/tools/reconcile-statement.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 function buildErrorResult4(params) {
   return JSON.stringify({
     success: false,
     ...params
   });
 }
-function validateWorktree(directory, worktreeChecker) {
-  if (!worktreeChecker(directory)) {
-    return buildErrorResult4({
-      error: "reconcile-statement must be run inside an import worktree",
-      hint: "Use import-pipeline tool to orchestrate the full workflow"
-    });
-  }
-  return null;
-}
 function loadConfiguration(directory, configLoader) {
   try {
     const config2 = configLoader(directory);
@@ -24238,14 +24009,14 @@ function findCsvToReconcile(doneDir, options) {
     };
   }
   const csvFile = csvFiles[csvFiles.length - 1];
-  const relativePath = path11.relative(path11.dirname(path11.dirname(doneDir)), csvFile);
+  const relativePath = path10.relative(path10.dirname(path10.dirname(doneDir)), csvFile);
   return { csvFile, relativePath };
 }
 function determineClosingBalance(csvFile, config2, options, relativeCsvPath, rulesDir) {
   let metadata;
   try {
-    const content = fs11.readFileSync(csvFile, "utf-8");
-    const filename = path11.basename(csvFile);
+    const content = fs10.readFileSync(csvFile, "utf-8");
+    const filename = path10.basename(csvFile);
     const detectionResult = detectProvider(filename, content, config2);
     metadata = detectionResult?.metadata;
   } catch {
@@ -24327,7 +24098,7 @@ function tryExtractClosingBalanceFromCSV(csvFile, rulesDir) {
     if (!rulesFile) {
       return null;
     }
-    const rulesContent = fs11.readFileSync(rulesFile, "utf-8");
+    const rulesContent = fs10.readFileSync(rulesFile, "utf-8");
     const rulesConfig = parseRulesFile(rulesContent);
     const csvRows = parseCsvFile(csvFile, rulesConfig);
     if (csvRows.length === 0) {
@@ -24384,23 +24155,19 @@ function tryExtractClosingBalanceFromCSV(csvFile, rulesDir) {
     return null;
   }
 }
-async function reconcileStatement(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
+async function reconcileStatement(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
   const restrictionError = checkAccountantAgent(agent, "reconcile statement");
   if (restrictionError) {
     return restrictionError;
   }
-  const worktreeError = validateWorktree(directory, worktreeChecker);
-  if (worktreeError) {
-    return worktreeError;
-  }
   const configResult = loadConfiguration(directory, configLoader);
   if ("error" in configResult) {
     return configResult.error;
   }
   const { config: config2 } = configResult;
-  const doneDir = path11.join(directory, config2.paths.done);
-  const rulesDir = path11.join(directory, config2.paths.rules);
-  const mainJournalPath = path11.join(directory, ".hledger.journal");
+  const doneDir = path10.join(directory, config2.paths.done);
+  const rulesDir = path10.join(directory, config2.paths.rules);
+  const mainJournalPath = path10.join(directory, ".hledger.journal");
   const csvResult = findCsvToReconcile(doneDir, options);
   if ("error" in csvResult) {
     return csvResult.error;
@@ -24496,7 +24263,6 @@ var reconcile_statement_default = tool({
   description: `ACCOUNTANT AGENT ONLY: Reconcile imported bank statement against closing balance.
 
 This tool validates that the imported transactions result in the correct closing balance.
-It must be run inside an import worktree (use import-pipeline for the full workflow).
 
 **Workflow:**
 1. Finds the most recently imported CSV in the done directory
@@ -24529,17 +24295,16 @@ 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";
 
 // src/utils/accountDeclarations.ts
-import * as fs12 from "fs";
+import * as fs11 from "fs";
 function extractAccountsFromRulesFile(rulesPath) {
   const accounts = new Set;
-  if (!fs12.existsSync(rulesPath)) {
+  if (!fs11.existsSync(rulesPath)) {
     return accounts;
   }
-  const content = fs12.readFileSync(rulesPath, "utf-8");
+  const content = fs11.readFileSync(rulesPath, "utf-8");
   const lines = content.split(`
 `);
   for (const line of lines) {
@@ -24574,10 +24339,10 @@ function sortAccountDeclarations(accounts) {
   return Array.from(accounts).sort((a, b) => a.localeCompare(b));
 }
 function ensureAccountDeclarations(yearJournalPath, accounts) {
-  if (!fs12.existsSync(yearJournalPath)) {
+  if (!fs11.existsSync(yearJournalPath)) {
     throw new Error(`Year journal not found: ${yearJournalPath}`);
   }
-  const content = fs12.readFileSync(yearJournalPath, "utf-8");
+  const content = fs11.readFileSync(yearJournalPath, "utf-8");
   const lines = content.split(`
 `);
   const existingAccounts = new Set;
@@ -24639,7 +24404,7 @@ function ensureAccountDeclarations(yearJournalPath, accounts) {
     newContent.push("");
   }
   newContent.push(...otherLines);
-  fs12.writeFileSync(yearJournalPath, newContent.join(`
+  fs11.writeFileSync(yearJournalPath, newContent.join(`
 `));
   return {
     added: Array.from(missingAccounts).sort(),
@@ -24647,6 +24412,158 @@ function ensureAccountDeclarations(yearJournalPath, accounts) {
   };
 }
 
+// src/utils/logger.ts
+import fs12 from "fs/promises";
+import path11 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 = path11.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 fs12.mkdir(path11.dirname(this.logPath), { recursive: true });
+      await fs12.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: path11.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() {
@@ -24674,73 +24591,38 @@ function buildErrorResult5(result, error45, hint) {
   }
   return JSON.stringify(result);
 }
-function buildCommitMessage(provider, currency, fromDate, untilDate, transactionCount) {
-  const providerStr = provider?.toUpperCase() || "statements";
-  const currencyStr = currency?.toUpperCase();
-  const dateRange = fromDate && untilDate ? ` ${fromDate} to ${untilDate}` : "";
-  const txStr = transactionCount > 0 ? ` (${transactionCount} transactions)` : "";
-  const parts = ["Import:", providerStr];
-  if (currencyStr) {
-    parts.push(currencyStr);
-  }
-  return `${parts.join(" ")}${dateRange}${txStr}`;
-}
-function cleanupIncomingFiles(worktree, context) {
-  const incomingDir = path12.join(worktree.mainRepoPath, "import/incoming");
-  if (!fs13.existsSync(incomingDir)) {
-    return;
-  }
-  const importStep = context.result.steps.import;
-  if (!importStep?.success || !importStep.details) {
-    return;
-  }
-  const importResult = importStep.details;
-  if (!importResult.files || !Array.isArray(importResult.files)) {
-    return;
-  }
-  let deletedCount = 0;
-  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)) {
-      try {
-        fs13.unlinkSync(filePath);
-        deletedCount++;
-      } catch (error45) {
-        console.error(`[ERROR] Failed to delete ${filename}: ${error45 instanceof Error ? error45.message : String(error45)}`);
-      }
-    }
-  }
-  if (deletedCount > 0) {
-    console.log(`[INFO] Cleaned up ${deletedCount} file(s) from import/incoming/`);
-  }
-}
-async function executeClassifyStep(context, worktree) {
+async function executeClassifyStep(context, logger) {
+  logger?.startSection("Step 1: 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;
-  const classifyResult = await classifyStatements(worktree.path, context.agent, context.configLoader, inWorktree);
+  const classifyResult = await classifyStatements(context.directory, context.agent, context.configLoader);
   const classifyParsed = JSON.parse(classifyResult);
   const success2 = classifyParsed.success !== false;
   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);
-}
-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);
+  logger?.endSection();
+}
+async function executeAccountDeclarationsStep(context, logger) {
+  logger?.startSection("Step 2: Check Account Declarations");
+  logger?.logStep("Check Accounts", "start");
+  const config2 = context.configLoader(context.directory);
+  const pendingDir = path12.join(context.directory, config2.paths.pending);
+  const rulesDir = path12.join(context.directory, config2.paths.rules);
   const csvFiles = findCsvFiles(pendingDir, context.options.provider, context.options.currency);
   if (csvFiles.length === 0) {
     context.result.steps.accountDeclarations = buildStepResult(true, "No CSV files to process", {
@@ -24771,7 +24653,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) => path12.relative(context.directory, f))
     });
     return;
   }
@@ -24794,80 +24676,107 @@ 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) => path12.relative(context.directory, f))
     });
     return;
   }
   let yearJournalPath;
   try {
-    yearJournalPath = ensureYearJournalExists(worktree.path, transactionYear);
+    yearJournalPath = ensureYearJournalExists(context.directory, 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))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(context.directory, 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 ${path12.relative(context.directory, 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: path12.relative(context.directory, yearJournalPath),
+    rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(context.directory, f))
   });
+  logger?.endSection();
 }
-async function executeDryRunStep(context, worktree) {
-  const inWorktree = () => true;
-  const dryRunResult = await importStatements(worktree.path, context.agent, {
+async function executeDryRunStep(context, logger) {
+  logger?.startSection("Step 3: Dry Run Import");
+  logger?.logStep("Dry Run", "start");
+  const dryRunResult = await importStatements(context.directory, context.agent, {
     provider: context.options.provider,
     currency: context.options.currency,
     checkOnly: true
-  }, context.configLoader, context.hledgerExecutor, inWorktree);
+  }, context.configLoader, context.hledgerExecutor);
   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) {
-  const inWorktree = () => true;
-  const importResult = await importStatements(worktree.path, context.agent, {
+async function executeImportStep(context, logger) {
+  logger?.startSection("Step 4: Import Transactions");
+  logger?.logStep("Import", "start");
+  const importResult = await importStatements(context.directory, context.agent, {
     provider: context.options.provider,
     currency: context.options.currency,
     checkOnly: false
-  }, context.configLoader, context.hledgerExecutor, inWorktree);
+  }, context.configLoader, context.hledgerExecutor);
   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) {
-  const inWorktree = () => true;
-  const reconcileResult = await reconcileStatement(worktree.path, context.agent, {
+async function executeReconcileStep(context, logger) {
+  logger?.startSection("Step 5: Reconcile Balance");
+  logger?.logStep("Reconcile", "start");
+  const reconcileResult = await reconcileStatement(context.directory, context.agent, {
     provider: context.options.provider,
     currency: context.options.currency,
     closingBalance: context.options.closingBalance,
     account: context.options.account
-  }, context.configLoader, context.hledgerExecutor, inWorktree);
+  }, context.configLoader, context.hledgerExecutor);
   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,
@@ -24876,39 +24785,17 @@ 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");
   }
-}
-async function executeMergeStep(context, worktree) {
-  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"]
-  };
-  const transactionCount = importDetails.summary?.totalTransactions || 0;
-  const commitMessage = buildCommitMessage(context.options.provider, context.options.currency, commitInfo.fromDate, commitInfo.untilDate, transactionCount);
-  try {
-    mergeWorktree(worktree, commitMessage);
-    const mergeDetails = { commitMessage };
-    context.result.steps.merge = buildStepResult(true, `Merged to main: "${commitMessage}"`, mergeDetails);
-    cleanupIncomingFiles(worktree, context);
-  } catch (error45) {
-    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";
-    throw new Error("Merge failed");
-  }
+  logger?.endSection();
 }
 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 buildSuccessResult4(result, "No transactions found to import");
 }
 async function importPipeline(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
@@ -24916,6 +24803,12 @@ 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("");
   const result = {
     success: false,
     steps: {}
@@ -24929,113 +24822,61 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     result
   };
   try {
-    return await withWorktree(directory, async (worktree) => {
-      result.worktreeId = worktree.uuid;
-      result.steps.worktree = buildStepResult(true, `Created worktree at ${worktree.path}`, {
-        path: worktree.path,
-        branch: worktree.branch
-      });
-      try {
-        const config2 = configLoader(directory);
-        const syncResult = syncCSVFilesToWorktree(directory, worktree.path, config2.paths.import);
-        if (syncResult.synced.length === 0 && syncResult.errors.length === 0) {
-          result.steps.sync = buildStepResult(true, "No CSV files to sync", {
-            synced: []
-          });
-        } else if (syncResult.errors.length > 0) {
-          result.steps.sync = buildStepResult(true, `Synced ${syncResult.synced.length} file(s) with ${syncResult.errors.length} error(s)`, { synced: syncResult.synced, errors: syncResult.errors });
-        } else {
-          result.steps.sync = buildStepResult(true, `Synced ${syncResult.synced.length} CSV file(s) to worktree`, { synced: syncResult.synced });
-        }
-      } catch (error45) {
-        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);
-        try {
-          const config2 = configLoader(directory);
-          const cleanupResult = cleanupProcessedCSVFiles(directory, config2.paths.import);
-          if (cleanupResult.deleted.length === 0 && cleanupResult.errors.length === 0) {
-            result.steps.cleanup = buildStepResult(true, "No CSV files to cleanup", { csvCleanup: { deleted: [] } });
-          } else if (cleanupResult.errors.length > 0) {
-            result.steps.cleanup = buildStepResult(true, `Deleted ${cleanupResult.deleted.length} CSV file(s) with ${cleanupResult.errors.length} error(s)`, {
-              csvCleanup: {
-                deleted: cleanupResult.deleted,
-                errors: cleanupResult.errors
-              }
-            });
-          } else {
-            result.steps.cleanup = buildStepResult(true, `Deleted ${cleanupResult.deleted.length} CSV file(s) from main repo`, { csvCleanup: { deleted: cleanupResult.deleted } });
-          }
-        } catch (error45) {
-          const errorMsg = error45 instanceof Error ? error45.message : String(error45);
-          result.steps.cleanup = buildStepResult(false, `Failed to cleanup CSV files: ${errorMsg}`, {
-            csvCleanup: {
-              deleted: [],
-              errors: [{ file: "unknown", error: errorMsg }]
-            }
-          });
-        }
-        await executeMergeStep(context, worktree);
-        const existingCleanup = result.steps.cleanup;
-        if (existingCleanup) {
-          existingCleanup.message += ", worktree cleaned up";
-          existingCleanup.details = {
-            ...existingCleanup.details,
-            cleanedAfterSuccess: true
-          };
-        }
-        const transactionCount = context.result.steps.import?.details?.summary?.totalTransactions || 0;
-        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,
-          csvCleanup: { deleted: [] }
-        });
-        if (error45 instanceof NoTransactionsError) {
-          return handleNoTransactions(result);
-        }
-        if (!result.error) {
-          result.error = error45 instanceof Error ? error45.message : String(error45);
-        }
-        return buildErrorResult5(result, result.error, result.hint);
-      }
-    });
+    await executeClassifyStep(context, logger);
+    await executeAccountDeclarationsStep(context, logger);
+    await executeDryRunStep(context, logger);
+    await executeImportStep(context, logger);
+    await executeReconcileStep(context, logger);
+    const transactionCount = context.result.steps.import?.details?.summary?.totalTransactions || 0;
+    logger.startSection("Summary");
+    logger.info(`Import completed successfully`);
+    logger.info(`Total transactions imported: ${transactionCount}`);
+    if (context.result.steps.reconcile?.details?.actualBalance) {
+      logger.info(`Balance: ${context.result.steps.reconcile.details.actualBalance}`);
+    }
+    logger.info(`Log file: ${logger.getLogPath()}`);
+    logger.endSection();
+    return buildSuccessResult4(result, `Successfully imported ${transactionCount} transaction(s)`);
   } catch (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);
+    logger.error("Pipeline step failed", error45);
+    logger.info(`Log file: ${logger.getLogPath()}`);
+    if (error45 instanceof NoTransactionsError) {
+      return handleNoTransactions(result);
+    }
+    if (!result.error) {
+      result.error = error45 instanceof Error ? error45.message : String(error45);
+    }
+    return buildErrorResult5(result, result.error, result.hint);
+  } finally {
+    logger.endSection();
+    await logger.flush();
   }
 }
 var import_pipeline_default = tool({
-  description: `ACCOUNTANT AGENT ONLY: Complete import pipeline with git worktree isolation and balance reconciliation.
+  description: `ACCOUNTANT AGENT ONLY: Complete import pipeline with balance reconciliation.
 
-This tool orchestrates the full import workflow in an isolated git worktree:
+This tool orchestrates the full import workflow:
 
 **Pipeline Steps:**
-1. **Create Worktree**: Creates an isolated git worktree for safe import
-2. **Classify**: Moves CSVs from import to pending directory (optional, skip with skipClassify)
+1. **Classify**: Moves CSVs from import/incoming to import/pending (optional, skip with skipClassify)
+2. **Account Declarations**: Ensures all required accounts are declared in year journal
 3. **Dry Run**: Validates all transactions have known accounts
-4. **Import**: Imports transactions to the journal
+4. **Import**: Imports transactions to the journal (moves CSVs to import/done)
 5. **Reconcile**: Validates closing balance matches CSV metadata
-6. **Merge**: Merges worktree to main with --no-ff
-7. **Cleanup**: Removes worktree
 
-**Safety Features:**
-- All changes happen in isolated worktree
-- If any step fails, worktree is discarded (main branch untouched)
-- Balance reconciliation ensures data integrity
-- Atomic commit with merge --no-ff preserves history
+**Important:**
+- All changes remain uncommitted in your working directory
+- If any step fails, changes remain in place for inspection
+- CSV files move from incoming/ \u2192 pending/ \u2192 done/ during the process
+
+**Logging:**
+- All operations logged to .memory/import-<timestamp>.md
+- Log includes command output, timing, and error details
 
 **Usage:**
-- Basic: import-pipeline (processes all pending CSVs)
+- Basic: import-pipeline (processes all CSVs in incoming/)
 - Filtered: import-pipeline --provider ubs --currency chf
-- With manual balance: import-pipeline --closingBalance "CHF 1234.56"
+- Manual balance: import-pipeline --closingBalance "CHF 1234.56"
 - Skip classify: import-pipeline --skipClassify true`,
   args: {
     provider: tool.schema.string().optional().describe('Filter by provider (e.g., "ubs", "revolut")'),
@@ -25056,7 +24897,7 @@ This tool orchestrates the full import workflow in an isolated git worktree:
   }
 });
 // src/tools/init-directories.ts
-import * as fs14 from "fs";
+import * as fs13 from "fs";
 import * as path13 from "path";
 async function initDirectories(directory) {
   try {
@@ -25064,8 +24905,8 @@ async function initDirectories(directory) {
     const directoriesCreated = [];
     const gitkeepFiles = [];
     const importBase = path13.join(directory, "import");
-    if (!fs14.existsSync(importBase)) {
-      fs14.mkdirSync(importBase, { recursive: true });
+    if (!fs13.existsSync(importBase)) {
+      fs13.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -25076,19 +24917,19 @@ async function initDirectories(directory) {
     ];
     for (const { path: dirPath } of pathsToCreate) {
       const fullPath = path13.join(directory, dirPath);
-      if (!fs14.existsSync(fullPath)) {
-        fs14.mkdirSync(fullPath, { recursive: true });
+      if (!fs13.existsSync(fullPath)) {
+        fs13.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
       const gitkeepPath = path13.join(fullPath, ".gitkeep");
-      if (!fs14.existsSync(gitkeepPath)) {
-        fs14.writeFileSync(gitkeepPath, "");
+      if (!fs13.existsSync(gitkeepPath)) {
+        fs13.writeFileSync(gitkeepPath, "");
         gitkeepFiles.push(path13.join(dirPath, ".gitkeep"));
       }
     }
     const gitignorePath = path13.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs14.existsSync(gitignorePath)) {
+    if (!fs13.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -25106,7 +24947,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs14.writeFileSync(gitignorePath, gitignoreContent);
+      fs13.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];
@@ -25182,8 +25023,8 @@ You can now drop CSV files into import/incoming/ and run import-pipeline.`);
   }
 });
 // src/index.ts
-var __dirname2 = dirname6(fileURLToPath3(import.meta.url));
-var AGENT_FILE = join13(__dirname2, "..", "agent", "accountant.md");
+var __dirname2 = dirname5(fileURLToPath3(import.meta.url));
+var AGENT_FILE = join12(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {