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

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 fs8 = __require("fs");
+  var fs9 = __require("fs");
 
   class FileUtils {
     readFile(fileInputName, encoding) {
-      return fs8.readFileSync(fileInputName, encoding).toString();
+      return fs9.readFileSync(fileInputName, encoding).toString();
     }
     readFileAsync(fileInputName, encoding = "utf8") {
-      if (fs8.promises && typeof fs8.promises.readFile === "function") {
-        return fs8.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
+      if (fs9.promises && typeof fs9.promises.readFile === "function") {
+        return fs9.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
       }
       return new Promise((resolve2, reject) => {
-        fs8.readFile(fileInputName, encoding, (err, data) => {
+        fs9.readFile(fileInputName, encoding, (err, data) => {
           if (err) {
             reject(err);
             return;
@@ -1569,7 +1569,7 @@ var require_fileUtils = __commonJS((exports, module) => {
       });
     }
     writeFile(json3, fileOutputName) {
-      fs8.writeFile(fileOutputName, json3, function(err) {
+      fs9.writeFile(fileOutputName, json3, function(err) {
         if (err) {
           throw err;
         } else {
@@ -1578,11 +1578,11 @@ var require_fileUtils = __commonJS((exports, module) => {
       });
     }
     writeFileAsync(json3, fileOutputName) {
-      if (fs8.promises && typeof fs8.promises.writeFile === "function") {
-        return fs8.promises.writeFile(fileOutputName, json3);
+      if (fs9.promises && typeof fs9.promises.writeFile === "function") {
+        return fs9.promises.writeFile(fileOutputName, json3);
       }
       return new Promise((resolve2, reject) => {
-        fs8.writeFile(fileOutputName, json3, (err) => {
+        fs9.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 dirname5, join as join12 } from "path";
+import { dirname as dirname6, join as join13 } 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 fs5 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 
 // src/utils/importConfig.ts
 import * as fs3 from "fs";
@@ -17751,23 +17751,263 @@ function detectProvider(filename, content, config2) {
   return null;
 }
 
-// src/utils/fileUtils.ts
+// 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
 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, options) {
+  let createdWorktree = null;
+  let operationSucceeded = false;
+  const logger = options?.logger;
+  const keepOnError = options?.keepOnError ?? true;
+  try {
+    logger?.logStep("Create Worktree", "start");
+    createdWorktree = createImportWorktree(directory);
+    logger?.logStep("Create Worktree", "success", `Path: ${createdWorktree.path}`);
+    logger?.info(`Branch: ${createdWorktree.branch}`);
+    logger?.info(`UUID: ${createdWorktree.uuid}`);
+    const result = await operation(createdWorktree);
+    operationSucceeded = true;
+    return result;
+  } finally {
+    if (createdWorktree) {
+      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`);
+      }
+    }
+  }
+}
+
+// src/utils/fileUtils.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
 function findCSVFiles(importsDir) {
-  if (!fs4.existsSync(importsDir)) {
+  if (!fs5.existsSync(importsDir)) {
     return [];
   }
-  return fs4.readdirSync(importsDir).filter((file2) => file2.toLowerCase().endsWith(".csv")).filter((file2) => {
-    const fullPath = path5.join(importsDir, file2);
-    return fs4.statSync(fullPath).isFile();
+  return fs5.readdirSync(importsDir).filter((file2) => file2.toLowerCase().endsWith(".csv")).filter((file2) => {
+    const fullPath = path6.join(importsDir, file2);
+    return fs5.statSync(fullPath).isFile();
   });
 }
 function ensureDirectory(dirPath) {
-  if (!fs4.existsSync(dirPath)) {
-    fs4.mkdirSync(dirPath, { recursive: true });
+  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 });
+    }
+  }
+  return result;
+}
 
 // src/tools/classify-statements.ts
 function buildSuccessResult2(classified, unrecognized, message) {
@@ -17806,20 +18046,20 @@ function planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2) {
   const plannedMoves = [];
   const collisions = [];
   for (const filename of csvFiles) {
-    const sourcePath = path6.join(importsDir, filename);
-    const content = fs5.readFileSync(sourcePath, "utf-8");
+    const sourcePath = path7.join(importsDir, filename);
+    const content = fs6.readFileSync(sourcePath, "utf-8");
     const detection = detectProvider(filename, content, config2);
     let targetPath;
     let targetFilename;
     if (detection) {
       targetFilename = detection.outputFilename || filename;
-      const targetDir = path6.join(pendingDir, detection.provider, detection.currency);
-      targetPath = path6.join(targetDir, targetFilename);
+      const targetDir = path7.join(pendingDir, detection.provider, detection.currency);
+      targetPath = path7.join(targetDir, targetFilename);
     } else {
       targetFilename = filename;
-      targetPath = path6.join(unrecognizedDir, filename);
+      targetPath = path7.join(unrecognizedDir, filename);
     }
-    if (fs5.existsSync(targetPath)) {
+    if (fs6.existsSync(targetPath)) {
       collisions.push({
         filename,
         existingPath: targetPath
@@ -17840,28 +18080,28 @@ function executeMoves(plannedMoves, config2, unrecognizedDir) {
   const unrecognized = [];
   for (const move of plannedMoves) {
     if (move.detection) {
-      const targetDir = path6.dirname(move.targetPath);
+      const targetDir = path7.dirname(move.targetPath);
       ensureDirectory(targetDir);
-      fs5.renameSync(move.sourcePath, move.targetPath);
+      fs6.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: path6.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename)
+        targetPath: path7.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename)
       });
     } else {
       ensureDirectory(unrecognizedDir);
-      fs5.renameSync(move.sourcePath, move.targetPath);
+      fs6.renameSync(move.sourcePath, move.targetPath);
       unrecognized.push({
         filename: move.filename,
-        targetPath: path6.join(config2.paths.unrecognized, move.filename)
+        targetPath: path7.join(config2.paths.unrecognized, move.filename)
       });
     }
   }
   return { classified, unrecognized };
 }
-async function classifyStatements(directory, agent, configLoader = loadImportConfig) {
+async function classifyStatements(directory, agent, configLoader = loadImportConfig, worktreeChecker = isInWorktree) {
   const restrictionError = checkAccountantAgent(agent, "classify statements", {
     classified: [],
     unrecognized: []
@@ -17869,6 +18109,9 @@ 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);
@@ -17876,9 +18119,9 @@ async function classifyStatements(directory, agent, configLoader = loadImportCon
     const errorMessage = err instanceof Error ? err.message : String(err);
     return buildErrorResult2(errorMessage);
   }
-  const importsDir = path6.join(directory, config2.paths.import);
-  const pendingDir = path6.join(directory, config2.paths.pending);
-  const unrecognizedDir = path6.join(directory, config2.paths.unrecognized);
+  const importsDir = path7.join(directory, config2.paths.import);
+  const pendingDir = path7.join(directory, config2.paths.pending);
+  const unrecognizedDir = path7.join(directory, config2.paths.unrecognized);
   const csvFiles = findCSVFiles(importsDir);
   if (csvFiles.length === 0) {
     return buildSuccessResult2([], [], `No CSV files found in ${config2.paths.import}`);
@@ -17899,8 +18142,8 @@ var classify_statements_default = tool({
   }
 });
 // src/tools/import-statements.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 
 // node_modules/minimatch/dist/esm/index.js
 var import_brace_expansion = __toESM(require_brace_expansion(), 1);
@@ -18493,11 +18736,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 path7 = {
+var path8 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep = defaultPlatform === "win32" ? path7.win32.sep : path7.posix.sep;
+var sep = defaultPlatform === "win32" ? path8.win32.sep : path8.posix.sep;
 minimatch.sep = sep;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -20231,7 +20474,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 readdirSync3, readlinkSync, realpathSync as rps } from "fs";
+import { lstatSync, readdir as readdirCB, readdirSync as readdirSync4, readlinkSync, realpathSync as rps } from "fs";
 import * as actualFS from "fs";
 import { lstat, readdir, readlink, realpath } from "fs/promises";
 
@@ -20903,7 +21146,7 @@ var realpathSync = rps.native;
 var defaultFS = {
   lstatSync,
   readdir: readdirCB,
-  readdirSync: readdirSync3,
+  readdirSync: readdirSync4,
   readlinkSync,
   realpathSync,
   promises: {
@@ -21102,12 +21345,12 @@ class PathBase {
   childrenCache() {
     return this.#children;
   }
-  resolve(path8) {
-    if (!path8) {
+  resolve(path9) {
+    if (!path9) {
       return this;
     }
-    const rootPath = this.getRootString(path8);
-    const dir = path8.substring(rootPath.length);
+    const rootPath = this.getRootString(path9);
+    const dir = path9.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -21636,8 +21879,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(path8) {
-    return win32.parse(path8).root;
+  getRootString(path9) {
+    return win32.parse(path9).root;
   }
   getRoot(rootPath) {
     rootPath = uncToDrive(rootPath.toUpperCase());
@@ -21663,8 +21906,8 @@ class PathPosix extends PathBase {
   constructor(name, type2 = UNKNOWN, root, roots, nocase, children, opts) {
     super(name, type2, root, roots, nocase, children, opts);
   }
-  getRootString(path8) {
-    return path8.startsWith("/") ? "/" : "";
+  getRootString(path9) {
+    return path9.startsWith("/") ? "/" : "";
   }
   getRoot(_rootPath) {
     return this.root;
@@ -21684,8 +21927,8 @@ class PathScurryBase {
   #children;
   nocase;
   #fs;
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs6);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs7 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs7);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = fileURLToPath(cwd);
     }
@@ -21721,11 +21964,11 @@ class PathScurryBase {
     }
     this.cwd = prev;
   }
-  depth(path8 = this.cwd) {
-    if (typeof path8 === "string") {
-      path8 = this.cwd.resolve(path8);
+  depth(path9 = this.cwd) {
+    if (typeof path9 === "string") {
+      path9 = this.cwd.resolve(path9);
     }
-    return path8.depth();
+    return path9.depth();
   }
   childrenCache() {
     return this.#children;
@@ -22141,9 +22384,9 @@ class PathScurryBase {
     process2();
     return results;
   }
-  chdir(path8 = this.cwd) {
+  chdir(path9 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path8 === "string" ? this.cwd.resolve(path8) : path8;
+    this.cwd = typeof path9 === "string" ? this.cwd.resolve(path9) : path9;
     this.cwd[setAsCwd](oldCwd);
   }
 }
@@ -22161,8 +22404,8 @@ class PathScurryWin32 extends PathScurryBase {
   parseRootPath(dir) {
     return win32.parse(dir).root.toUpperCase();
   }
-  newRoot(fs6) {
-    return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+  newRoot(fs7) {
+    return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
   }
   isAbsolute(p) {
     return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
@@ -22179,8 +22422,8 @@ class PathScurryPosix extends PathScurryBase {
   parseRootPath(_dir) {
     return "/";
   }
-  newRoot(fs6) {
-    return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+  newRoot(fs7) {
+    return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
   }
   isAbsolute(p) {
     return p.startsWith("/");
@@ -22432,8 +22675,8 @@ class MatchRecord {
     this.store.set(target, current === undefined ? n : n & current);
   }
   entries() {
-    return [...this.store.entries()].map(([path8, n]) => [
-      path8,
+    return [...this.store.entries()].map(([path9, n]) => [
+      path9,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -22636,9 +22879,9 @@ class GlobUtil {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path8, opts) {
+  constructor(patterns, path9, opts) {
     this.patterns = patterns;
-    this.path = path8;
+    this.path = path9;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -22657,11 +22900,11 @@ class GlobUtil {
       });
     }
   }
-  #ignored(path8) {
-    return this.seen.has(path8) || !!this.#ignore?.ignored?.(path8);
+  #ignored(path9) {
+    return this.seen.has(path9) || !!this.#ignore?.ignored?.(path9);
   }
-  #childrenIgnored(path8) {
-    return !!this.#ignore?.childrenIgnored?.(path8);
+  #childrenIgnored(path9) {
+    return !!this.#ignore?.childrenIgnored?.(path9);
   }
   pause() {
     this.paused = true;
@@ -22874,8 +23117,8 @@ class GlobUtil {
 
 class GlobWalker extends GlobUtil {
   matches = new Set;
-  constructor(patterns, path8, opts) {
-    super(patterns, path8, opts);
+  constructor(patterns, path9, opts) {
+    super(patterns, path9, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -22913,8 +23156,8 @@ class GlobWalker extends GlobUtil {
 
 class GlobStream extends GlobUtil {
   results;
-  constructor(patterns, path8, opts) {
-    super(patterns, path8, opts);
+  constructor(patterns, path9, opts) {
+    super(patterns, path9, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -23182,8 +23425,8 @@ var glob = Object.assign(glob_, {
 glob.glob = glob;
 
 // src/utils/rulesMatcher.ts
-import * as fs6 from "fs";
-import * as path8 from "path";
+import * as fs7 from "fs";
+import * as path9 from "path";
 function parseSourceDirective(content) {
   const match2 = content.match(/^source\s+([^\n#]+)/m);
   if (!match2) {
@@ -23192,28 +23435,28 @@ function parseSourceDirective(content) {
   return match2[1].trim();
 }
 function resolveSourcePath(sourcePath, rulesFilePath) {
-  if (path8.isAbsolute(sourcePath)) {
+  if (path9.isAbsolute(sourcePath)) {
     return sourcePath;
   }
-  const rulesDir = path8.dirname(rulesFilePath);
-  return path8.resolve(rulesDir, sourcePath);
+  const rulesDir = path9.dirname(rulesFilePath);
+  return path9.resolve(rulesDir, sourcePath);
 }
 function loadRulesMapping(rulesDir) {
   const mapping = {};
-  if (!fs6.existsSync(rulesDir)) {
+  if (!fs7.existsSync(rulesDir)) {
     return mapping;
   }
-  const files = fs6.readdirSync(rulesDir);
+  const files = fs7.readdirSync(rulesDir);
   for (const file2 of files) {
     if (!file2.endsWith(".rules")) {
       continue;
     }
-    const rulesFilePath = path8.join(rulesDir, file2);
-    const stat = fs6.statSync(rulesFilePath);
+    const rulesFilePath = path9.join(rulesDir, file2);
+    const stat = fs7.statSync(rulesFilePath);
     if (!stat.isFile()) {
       continue;
     }
-    const content = fs6.readFileSync(rulesFilePath, "utf-8");
+    const content = fs7.readFileSync(rulesFilePath, "utf-8");
     const sourcePath = parseSourceDirective(content);
     if (!sourcePath) {
       continue;
@@ -23227,22 +23470,22 @@ function findRulesForCsv(csvPath, mapping) {
   if (mapping[csvPath]) {
     return mapping[csvPath];
   }
-  const normalizedCsvPath = path8.normalize(csvPath);
+  const normalizedCsvPath = path9.normalize(csvPath);
   for (const [mappedCsv, rulesFile] of Object.entries(mapping)) {
-    const normalizedMappedCsv = path8.normalize(mappedCsv);
+    const normalizedMappedCsv = path9.normalize(mappedCsv);
     if (normalizedMappedCsv === normalizedCsvPath) {
       return rulesFile;
     }
   }
   for (const [pattern, rulesFile] of Object.entries(mapping)) {
-    if (minimatch(csvPath, pattern) || minimatch(normalizedCsvPath, path8.normalize(pattern))) {
+    if (minimatch(csvPath, pattern) || minimatch(normalizedCsvPath, path9.normalize(pattern))) {
       return rulesFile;
     }
   }
-  const csvBasename = path8.basename(csvPath);
+  const csvBasename = path9.basename(csvPath);
   const matches = [];
   for (const rulesFile of Object.values(mapping)) {
-    const rulesBasename = path8.basename(rulesFile, ".rules");
+    const rulesBasename = path9.basename(rulesFile, ".rules");
     if (csvBasename.startsWith(rulesBasename)) {
       matches.push({ rulesFile, prefixLength: rulesBasename.length });
     }
@@ -23373,7 +23616,7 @@ async function getAccountBalance(mainJournalPath, account, asOfDate, executor =
 }
 
 // src/utils/rulesParser.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 function parseSkipRows(rulesContent) {
   const match2 = rulesContent.match(/^skip\s+(\d+)/m);
   return match2 ? parseInt(match2[1], 10) : 0;
@@ -23439,7 +23682,7 @@ function parseAccount1(rulesContent) {
 }
 function getAccountFromRulesFile(rulesFilePath) {
   try {
-    const content = fs7.readFileSync(rulesFilePath, "utf-8");
+    const content = fs8.readFileSync(rulesFilePath, "utf-8");
     return parseAccount1(content);
   } catch {
     return null;
@@ -23459,7 +23702,7 @@ function parseRulesFile(rulesContent) {
 
 // src/utils/csvParser.ts
 var import_convert_csv_to_json = __toESM(require_convert_csv_to_json(), 1);
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 
 // src/utils/balanceUtils.ts
 function parseAmountValue(amountStr) {
@@ -23508,7 +23751,7 @@ function balancesMatch(balance1, balance2) {
 
 // src/utils/csvParser.ts
 function parseCsvFile(csvPath, config2) {
-  const csvContent = fs8.readFileSync(csvPath, "utf-8");
+  const csvContent = fs9.readFileSync(csvPath, "utf-8");
   const lines = csvContent.split(`
 `);
   const headerIndex = config2.skipRows;
@@ -23666,21 +23909,21 @@ function buildSuccessResult3(files, summary, message) {
   });
 }
 function findCsvFromRulesFile(rulesFile) {
-  const content = fs9.readFileSync(rulesFile, "utf-8");
+  const content = fs10.readFileSync(rulesFile, "utf-8");
   const match2 = content.match(/^source\s+([^\n#]+)/m);
   if (!match2) {
     return null;
   }
   const sourcePath = match2[1].trim();
-  const rulesDir = path9.dirname(rulesFile);
-  const absolutePattern = path9.resolve(rulesDir, sourcePath);
+  const rulesDir = path10.dirname(rulesFile);
+  const absolutePattern = path10.resolve(rulesDir, sourcePath);
   const matches = glob.sync(absolutePattern);
   if (matches.length === 0) {
     return null;
   }
   matches.sort((a, b) => {
-    const aStat = fs9.statSync(a);
-    const bStat = fs9.statSync(b);
+    const aStat = fs10.statSync(a);
+    const bStat = fs10.statSync(b);
     return bStat.mtime.getTime() - aStat.mtime.getTime();
   });
   return matches[0];
@@ -23688,7 +23931,7 @@ function findCsvFromRulesFile(rulesFile) {
 async function executeImports(fileResults, directory, pendingDir, doneDir, hledgerExecutor) {
   const importedFiles = [];
   for (const fileResult of fileResults) {
-    const rulesFile = fileResult.rulesFile ? path9.join(directory, fileResult.rulesFile) : null;
+    const rulesFile = fileResult.rulesFile ? path10.join(directory, fileResult.rulesFile) : null;
     if (!rulesFile)
       continue;
     const year = fileResult.transactionYear;
@@ -23720,7 +23963,7 @@ async function executeImports(fileResults, directory, pendingDir, doneDir, hledg
       importedFiles.push(importedCsv);
     }
   }
-  const mainJournalPath = path9.join(directory, ".hledger.journal");
+  const mainJournalPath = path10.join(directory, ".hledger.journal");
   const validationResult = await validateLedger(mainJournalPath, hledgerExecutor);
   if (!validationResult.valid) {
     return {
@@ -23730,13 +23973,13 @@ async function executeImports(fileResults, directory, pendingDir, doneDir, hledg
     };
   }
   for (const csvFile of importedFiles) {
-    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 });
+    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 });
     }
-    fs9.renameSync(csvFile, destPath);
+    fs10.renameSync(csvFile, destPath);
   }
   return {
     success: true,
@@ -23747,7 +23990,7 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   const rulesFile = findRulesForCsv(csvFile, rulesMapping);
   if (!rulesFile) {
     return {
-      csv: path9.relative(directory, csvFile),
+      csv: path10.relative(directory, csvFile),
       rulesFile: null,
       totalTransactions: 0,
       matchedTransactions: 0,
@@ -23758,8 +24001,8 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   const result = await hledgerExecutor(["print", "-f", rulesFile]);
   if (result.exitCode !== 0) {
     return {
-      csv: path9.relative(directory, csvFile),
-      rulesFile: path9.relative(directory, rulesFile),
+      csv: path10.relative(directory, csvFile),
+      rulesFile: path10.relative(directory, rulesFile),
       totalTransactions: 0,
       matchedTransactions: 0,
       unknownPostings: [],
@@ -23773,8 +24016,8 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   if (years.size > 1) {
     const yearList = Array.from(years).sort().join(", ");
     return {
-      csv: path9.relative(directory, csvFile),
-      rulesFile: path9.relative(directory, rulesFile),
+      csv: path10.relative(directory, csvFile),
+      rulesFile: path10.relative(directory, rulesFile),
       totalTransactions: transactionCount,
       matchedTransactions: matchedCount,
       unknownPostings: [],
@@ -23784,7 +24027,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 = fs9.readFileSync(rulesFile, "utf-8");
+      const rulesContent = fs10.readFileSync(rulesFile, "utf-8");
       const rulesConfig = parseRulesFile(rulesContent);
       const csvRows = parseCsvFile(csvFile, rulesConfig);
       for (const posting of unknownPostings) {
@@ -23801,19 +24044,22 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
     }
   }
   return {
-    csv: path9.relative(directory, csvFile),
-    rulesFile: path9.relative(directory, rulesFile),
+    csv: path10.relative(directory, csvFile),
+    rulesFile: path10.relative(directory, rulesFile),
     totalTransactions: transactionCount,
     matchedTransactions: matchedCount,
     unknownPostings,
     transactionYear
   };
 }
-async function importStatements(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
+async function importStatements(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree, _logger) {
   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);
@@ -23821,9 +24067,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 = path9.join(directory, config2.paths.pending);
-  const rulesDir = path9.join(directory, config2.paths.rules);
-  const doneDir = path9.join(directory, config2.paths.done);
+  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 rulesMapping = loadRulesMapping(rulesDir);
   const csvFiles = findCsvFiles(pendingDir, options.provider, options.currency);
   if (csvFiles.length === 0) {
@@ -23867,8 +24113,8 @@ async function importStatements(directory, agent, options, configLoader = loadIm
   }
   for (const [_rulesFile, matchingCSVs] of rulesFileToCSVs.entries()) {
     matchingCSVs.sort((a, b) => {
-      const aStat = fs9.statSync(a);
-      const bStat = fs9.statSync(b);
+      const aStat = fs10.statSync(a);
+      const bStat = fs10.statSync(b);
       return bStat.mtime.getTime() - aStat.mtime.getTime();
     });
     const newestCSV = matchingCSVs[0];
@@ -23957,9 +24203,7 @@ 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
-
-Note: This tool is typically called via import-pipeline for the full workflow.`,
+4. Run with checkOnly: false to import`,
   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.'),
@@ -23975,14 +24219,23 @@ Note: This tool is typically called via import-pipeline for the full workflow.`,
   }
 });
 // src/tools/reconcile-statement.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs11 from "fs";
+import * as path11 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);
@@ -24009,14 +24262,14 @@ function findCsvToReconcile(doneDir, options) {
     };
   }
   const csvFile = csvFiles[csvFiles.length - 1];
-  const relativePath = path10.relative(path10.dirname(path10.dirname(doneDir)), csvFile);
+  const relativePath = path11.relative(path11.dirname(path11.dirname(doneDir)), csvFile);
   return { csvFile, relativePath };
 }
 function determineClosingBalance(csvFile, config2, options, relativeCsvPath, rulesDir) {
   let metadata;
   try {
-    const content = fs10.readFileSync(csvFile, "utf-8");
-    const filename = path10.basename(csvFile);
+    const content = fs11.readFileSync(csvFile, "utf-8");
+    const filename = path11.basename(csvFile);
     const detectionResult = detectProvider(filename, content, config2);
     metadata = detectionResult?.metadata;
   } catch {
@@ -24098,7 +24351,7 @@ function tryExtractClosingBalanceFromCSV(csvFile, rulesDir) {
     if (!rulesFile) {
       return null;
     }
-    const rulesContent = fs10.readFileSync(rulesFile, "utf-8");
+    const rulesContent = fs11.readFileSync(rulesFile, "utf-8");
     const rulesConfig = parseRulesFile(rulesContent);
     const csvRows = parseCsvFile(csvFile, rulesConfig);
     if (csvRows.length === 0) {
@@ -24155,19 +24408,23 @@ function tryExtractClosingBalanceFromCSV(csvFile, rulesDir) {
     return null;
   }
 }
-async function reconcileStatement(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
+async function reconcileStatement(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
   const restrictionError = checkAccountantAgent(agent, "reconcile statement");
   if (restrictionError) {
     return restrictionError;
   }
+  const worktreeError = validateWorktree(directory, worktreeChecker);
+  if (worktreeError) {
+    return worktreeError;
+  }
   const configResult = loadConfiguration(directory, configLoader);
   if ("error" in configResult) {
     return configResult.error;
   }
   const { config: config2 } = configResult;
-  const doneDir = path10.join(directory, config2.paths.done);
-  const rulesDir = path10.join(directory, config2.paths.rules);
-  const mainJournalPath = path10.join(directory, ".hledger.journal");
+  const doneDir = path11.join(directory, config2.paths.done);
+  const rulesDir = path11.join(directory, config2.paths.rules);
+  const mainJournalPath = path11.join(directory, ".hledger.journal");
   const csvResult = findCsvToReconcile(doneDir, options);
   if ("error" in csvResult) {
     return csvResult.error;
@@ -24263,6 +24520,7 @@ 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
@@ -24295,16 +24553,17 @@ This tool validates that the imported transactions result in the correct closing
   }
 });
 // src/tools/import-pipeline.ts
-import * as path12 from "path";
+import * as fs14 from "fs";
+import * as path13 from "path";
 
 // src/utils/accountDeclarations.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 function extractAccountsFromRulesFile(rulesPath) {
   const accounts = new Set;
-  if (!fs11.existsSync(rulesPath)) {
+  if (!fs12.existsSync(rulesPath)) {
     return accounts;
   }
-  const content = fs11.readFileSync(rulesPath, "utf-8");
+  const content = fs12.readFileSync(rulesPath, "utf-8");
   const lines = content.split(`
 `);
   for (const line of lines) {
@@ -24339,10 +24598,10 @@ function sortAccountDeclarations(accounts) {
   return Array.from(accounts).sort((a, b) => a.localeCompare(b));
 }
 function ensureAccountDeclarations(yearJournalPath, accounts) {
-  if (!fs11.existsSync(yearJournalPath)) {
+  if (!fs12.existsSync(yearJournalPath)) {
     throw new Error(`Year journal not found: ${yearJournalPath}`);
   }
-  const content = fs11.readFileSync(yearJournalPath, "utf-8");
+  const content = fs12.readFileSync(yearJournalPath, "utf-8");
   const lines = content.split(`
 `);
   const existingAccounts = new Set;
@@ -24404,7 +24663,7 @@ function ensureAccountDeclarations(yearJournalPath, accounts) {
     newContent.push("");
   }
   newContent.push(...otherLines);
-  fs11.writeFileSync(yearJournalPath, newContent.join(`
+  fs12.writeFileSync(yearJournalPath, newContent.join(`
 `));
   return {
     added: Array.from(missingAccounts).sort(),
@@ -24413,8 +24672,8 @@ function ensureAccountDeclarations(yearJournalPath, accounts) {
 }
 
 // src/utils/logger.ts
-import fs12 from "fs/promises";
-import path11 from "path";
+import fs13 from "fs/promises";
+import path12 from "path";
 
 class MarkdownLogger {
   buffer = [];
@@ -24426,7 +24685,7 @@ class MarkdownLogger {
     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.logPath = path12.join(config2.logDir, filename);
     this.buffer.push(`# Import Pipeline Log`);
     this.buffer.push(`**Started**: ${new Date().toLocaleString()}`);
     this.buffer.push("");
@@ -24523,8 +24782,8 @@ class MarkdownLogger {
     if (this.buffer.length === 0)
       return;
     try {
-      await fs12.mkdir(path11.dirname(this.logPath), { recursive: true });
-      await fs12.writeFile(this.logPath, this.buffer.join(`
+      await fs13.mkdir(path12.dirname(this.logPath), { recursive: true });
+      await fs13.writeFile(this.logPath, this.buffer.join(`
 `), "utf-8");
     } catch {}
   }
@@ -24551,7 +24810,7 @@ function createImportLogger(directory, worktreeId, provider) {
   if (provider)
     context.provider = provider;
   const logger = createLogger({
-    logDir: path11.join(directory, ".memory"),
+    logDir: path12.join(directory, ".memory"),
     autoFlush: true,
     context
   });
@@ -24591,8 +24850,51 @@ function buildErrorResult5(result, error45, hint) {
   }
   return JSON.stringify(result);
 }
-async function executeClassifyStep(context, logger) {
-  logger?.startSection("Step 1: Classify Transactions");
+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 = path13.join(worktree.mainRepoPath, "import/incoming");
+  if (!fs14.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 = path13.basename(fileResult.csv);
+    const filePath = path13.join(incomingDir, filename);
+    if (fs14.existsSync(filePath)) {
+      try {
+        fs14.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, logger) {
+  logger?.startSection("Step 2: Classify Transactions");
   logger?.logStep("Classify", "start");
   if (context.options.skipClassify) {
     logger?.info("Classification skipped (skipClassify: true)");
@@ -24600,7 +24902,8 @@ async function executeClassifyStep(context, logger) {
     logger?.endSection();
     return;
   }
-  const classifyResult = await classifyStatements(context.directory, context.agent, context.configLoader);
+  const inWorktree = () => true;
+  const classifyResult = await classifyStatements(worktree.path, context.agent, context.configLoader, inWorktree);
   const classifyParsed = JSON.parse(classifyResult);
   const success2 = classifyParsed.success !== false;
   let message = success2 ? "Classification complete" : "Classification had issues";
@@ -24617,12 +24920,12 @@ async function executeClassifyStep(context, logger) {
   context.result.steps.classify = buildStepResult(success2, message, details);
   logger?.endSection();
 }
-async function executeAccountDeclarationsStep(context, logger) {
-  logger?.startSection("Step 2: Check Account Declarations");
+async function executeAccountDeclarationsStep(context, worktree, logger) {
+  logger?.startSection("Step 3: 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 config2 = context.configLoader(worktree.path);
+  const pendingDir = path13.join(worktree.path, config2.paths.pending);
+  const rulesDir = path13.join(worktree.path, config2.paths.rules);
   const csvFiles = findCsvFiles(pendingDir, context.options.provider, context.options.currency);
   if (csvFiles.length === 0) {
     context.result.steps.accountDeclarations = buildStepResult(true, "No CSV files to process", {
@@ -24653,7 +24956,7 @@ async function executeAccountDeclarationsStep(context, logger) {
     context.result.steps.accountDeclarations = buildStepResult(true, "No accounts found in rules files", {
       accountsAdded: [],
       journalUpdated: "",
-      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path13.relative(worktree.path, f))
     });
     return;
   }
@@ -24676,23 +24979,23 @@ async function executeAccountDeclarationsStep(context, logger) {
     context.result.steps.accountDeclarations = buildStepResult(false, "Could not determine transaction year from CSV files", {
       accountsAdded: [],
       journalUpdated: "",
-      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path13.relative(worktree.path, f))
     });
     return;
   }
   let yearJournalPath;
   try {
-    yearJournalPath = ensureYearJournalExists(context.directory, transactionYear);
+    yearJournalPath = ensureYearJournalExists(worktree.path, transactionYear);
   } catch (error45) {
     context.result.steps.accountDeclarations = buildStepResult(false, `Failed to create year journal: ${error45 instanceof Error ? error45.message : String(error45)}`, {
       accountsAdded: [],
       journalUpdated: "",
-      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path13.relative(worktree.path, f))
     });
     return;
   }
   const result = ensureAccountDeclarations(yearJournalPath, allAccounts);
-  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path12.relative(context.directory, yearJournalPath)}` : "All required accounts already declared";
+  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path13.relative(worktree.path, yearJournalPath)}` : "All required accounts already declared";
   logger?.logStep("Check Accounts", "success", message);
   if (result.added.length > 0) {
     for (const account of result.added) {
@@ -24701,19 +25004,20 @@ async function executeAccountDeclarationsStep(context, logger) {
   }
   context.result.steps.accountDeclarations = buildStepResult(true, message, {
     accountsAdded: result.added,
-    journalUpdated: path12.relative(context.directory, yearJournalPath),
-    rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(context.directory, f))
+    journalUpdated: path13.relative(worktree.path, yearJournalPath),
+    rulesScanned: Array.from(matchedRulesFiles).map((f) => path13.relative(worktree.path, f))
   });
   logger?.endSection();
 }
-async function executeDryRunStep(context, logger) {
-  logger?.startSection("Step 3: Dry Run Import");
+async function executeDryRunStep(context, worktree, logger) {
+  logger?.startSection("Step 4: Dry Run Import");
   logger?.logStep("Dry Run", "start");
-  const dryRunResult = await importStatements(context.directory, context.agent, {
+  const inWorktree = () => true;
+  const dryRunResult = await importStatements(worktree.path, context.agent, {
     provider: context.options.provider,
     currency: context.options.currency,
     checkOnly: true
-  }, context.configLoader, context.hledgerExecutor);
+  }, 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);
@@ -24737,14 +25041,15 @@ async function executeDryRunStep(context, logger) {
   }
   logger?.endSection();
 }
-async function executeImportStep(context, logger) {
-  logger?.startSection("Step 4: Import Transactions");
+async function executeImportStep(context, worktree, logger) {
+  logger?.startSection("Step 5: Import Transactions");
   logger?.logStep("Import", "start");
-  const importResult = await importStatements(context.directory, context.agent, {
+  const inWorktree = () => true;
+  const importResult = await importStatements(worktree.path, context.agent, {
     provider: context.options.provider,
     currency: context.options.currency,
     checkOnly: false
-  }, context.configLoader, context.hledgerExecutor);
+  }, 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);
@@ -24761,15 +25066,16 @@ async function executeImportStep(context, logger) {
   }
   logger?.endSection();
 }
-async function executeReconcileStep(context, logger) {
-  logger?.startSection("Step 5: Reconcile Balance");
+async function executeReconcileStep(context, worktree, logger) {
+  logger?.startSection("Step 6: Reconcile Balance");
   logger?.logStep("Reconcile", "start");
-  const reconcileResult = await reconcileStatement(context.directory, context.agent, {
+  const inWorktree = () => true;
+  const reconcileResult = await reconcileStatement(worktree.path, context.agent, {
     provider: context.options.provider,
     currency: context.options.currency,
     closingBalance: context.options.closingBalance,
     account: context.options.account
-  }, context.configLoader, context.hledgerExecutor);
+  }, 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);
@@ -24793,9 +25099,42 @@ async function executeReconcileStep(context, logger) {
   }
   logger?.endSection();
 }
+async function executeMergeStep(context, worktree, logger) {
+  logger?.startSection("Step 7: Merge to Main");
+  logger?.logStep("Merge", "start");
+  const importDetails = context.result.steps.import?.details;
+  const reconcileDetails = context.result.steps.reconcile?.details;
+  if (!importDetails || !reconcileDetails) {
+    throw new Error("Import or reconcile step not completed before merge");
+  }
+  const commitInfo = {
+    fromDate: reconcileDetails.metadata?.["from-date"],
+    untilDate: reconcileDetails.metadata?.["until-date"]
+  };
+  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";
+    throw new Error("Merge failed");
+  }
+}
 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) {
@@ -24808,6 +25147,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
   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,
@@ -24822,68 +25162,176 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     result
   };
   try {
-    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)`);
+    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);
+        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, logger);
+        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;
+        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,
+          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);
+      }
+    }, {
+      keepOnError: options.keepWorktreeOnError ?? true,
+      logger
+    });
   } catch (error45) {
-    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);
+    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({
-  description: `ACCOUNTANT AGENT ONLY: Complete import pipeline with balance reconciliation.
+  description: `ACCOUNTANT AGENT ONLY: Complete import pipeline with git worktree isolation and balance reconciliation.
 
-This tool orchestrates the full import workflow:
+This tool orchestrates the full import workflow in an isolated git worktree:
 
 **Pipeline Steps:**
-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
+1. **Create Worktree**: Creates an isolated git worktree for safe import
+2. **Classify**: Moves CSVs from import to pending directory (optional, skip with skipClassify)
 3. **Dry Run**: Validates all transactions have known accounts
-4. **Import**: Imports transactions to the journal (moves CSVs to import/done)
+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)
 
-**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
+**Safety Features:**
+- All changes happen in isolated worktree
+- If any step fails, worktree is preserved by default for debugging
+- Balance reconciliation ensures data integrity
+- Atomic commit with merge --no-ff preserves history
+
+**Worktree Cleanup:**
+- On success: Worktree is always cleaned up
+- On error (default): Worktree is kept at /tmp/import-worktree-<uuid> for debugging
+- On error (--keepWorktreeOnError false): Worktree is removed (old behavior)
+- Manual cleanup: git worktree remove /tmp/import-worktree-<uuid>
+- Auto cleanup: System reboot (worktrees are in /tmp)
 
 **Logging:**
-- All operations logged to .memory/import-<timestamp>.md
-- Log includes command output, timing, and error details
+- 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 CSVs in incoming/)
+- Basic: import-pipeline (processes all pending CSVs)
 - Filtered: import-pipeline --provider ubs --currency chf
-- Manual balance: import-pipeline --closingBalance "CHF 1234.56"
-- Skip classify: import-pipeline --skipClassify true`,
+- With manual balance: import-pipeline --closingBalance "CHF 1234.56"
+- Skip classify: import-pipeline --skipClassify true
+- Always cleanup: import-pipeline --keepWorktreeOnError false`,
   args: {
     provider: tool.schema.string().optional().describe('Filter by provider (e.g., "ubs", "revolut")'),
     currency: tool.schema.string().optional().describe('Filter by currency (e.g., "chf", "eur")'),
     closingBalance: tool.schema.string().optional().describe("Manual closing balance override (if not in CSV metadata)"),
     account: tool.schema.string().optional().describe("Manual account override (auto-detected from rules file if not provided)"),
-    skipClassify: tool.schema.boolean().optional().describe("Skip the classify step (default: false)")
+    skipClassify: tool.schema.boolean().optional().describe("Skip the classify step (default: false)"),
+    keepWorktreeOnError: tool.schema.boolean().optional().describe("Keep worktree on error for debugging (default: true)")
   },
   async execute(params, context) {
     const { directory, agent } = context;
@@ -24892,21 +25340,22 @@ This tool orchestrates the full import workflow:
       currency: params.currency,
       closingBalance: params.closingBalance,
       account: params.account,
-      skipClassify: params.skipClassify
+      skipClassify: params.skipClassify,
+      keepWorktreeOnError: params.keepWorktreeOnError
     });
   }
 });
 // src/tools/init-directories.ts
-import * as fs13 from "fs";
-import * as path13 from "path";
+import * as fs15 from "fs";
+import * as path14 from "path";
 async function initDirectories(directory) {
   try {
     const config2 = loadImportConfig(directory);
     const directoriesCreated = [];
     const gitkeepFiles = [];
-    const importBase = path13.join(directory, "import");
-    if (!fs13.existsSync(importBase)) {
-      fs13.mkdirSync(importBase, { recursive: true });
+    const importBase = path14.join(directory, "import");
+    if (!fs15.existsSync(importBase)) {
+      fs15.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -24916,20 +25365,20 @@ async function initDirectories(directory) {
       { key: "unrecognized", path: config2.paths.unrecognized }
     ];
     for (const { path: dirPath } of pathsToCreate) {
-      const fullPath = path13.join(directory, dirPath);
-      if (!fs13.existsSync(fullPath)) {
-        fs13.mkdirSync(fullPath, { recursive: true });
+      const fullPath = path14.join(directory, dirPath);
+      if (!fs15.existsSync(fullPath)) {
+        fs15.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
-      const gitkeepPath = path13.join(fullPath, ".gitkeep");
-      if (!fs13.existsSync(gitkeepPath)) {
-        fs13.writeFileSync(gitkeepPath, "");
-        gitkeepFiles.push(path13.join(dirPath, ".gitkeep"));
+      const gitkeepPath = path14.join(fullPath, ".gitkeep");
+      if (!fs15.existsSync(gitkeepPath)) {
+        fs15.writeFileSync(gitkeepPath, "");
+        gitkeepFiles.push(path14.join(dirPath, ".gitkeep"));
       }
     }
-    const gitignorePath = path13.join(importBase, ".gitignore");
+    const gitignorePath = path14.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs13.existsSync(gitignorePath)) {
+    if (!fs15.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -24947,7 +25396,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs13.writeFileSync(gitignorePath, gitignoreContent);
+      fs15.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];
@@ -25023,8 +25472,8 @@ You can now drop CSV files into import/incoming/ and run import-pipeline.`);
   }
 });
 // src/index.ts
-var __dirname2 = dirname5(fileURLToPath3(import.meta.url));
-var AGENT_FILE = join12(__dirname2, "..", "agent", "accountant.md");
+var __dirname2 = dirname6(fileURLToPath3(import.meta.url));
+var AGENT_FILE = join13(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {