@agenit/cli 1.0.1 → 1.0.3

package/cli.js

@@ -148,8 +148,8 @@ var init_soul = __esm({
     "use strict";
     SoulEngine = class {
       path;
-      constructor(path55) {
-        this.path = path55;
+      constructor(path56) {
+        this.path = path56;
       }
       async load() {
         return await fs2.readFile(this.path, "utf8");
@@ -1529,14 +1529,14 @@ var require_url_state_machine = __commonJS({
       return url.replace(/\u0009|\u000A|\u000D/g, "");
     }
     function shortenPath(url) {
-      const path55 = url.path;
-      if (path55.length === 0) {
+      const path56 = url.path;
+      if (path56.length === 0) {
         return;
       }
-      if (url.scheme === "file" && path55.length === 1 && isNormalizedWindowsDriveLetter(path55[0])) {
+      if (url.scheme === "file" && path56.length === 1 && isNormalizedWindowsDriveLetter(path56[0])) {
         return;
       }
-      path55.pop();
+      path56.pop();
     }
     function includesCredentials(url) {
       return url.username !== "" || url.password !== "";
@@ -7117,14 +7117,14 @@ __export(fileFromPath_exports, {
 });
 import { statSync, createReadStream, promises as fs9 } from "fs";
 import { basename } from "path";
-function createFileFromPath(path55, { mtimeMs, size }, filenameOrOptions, options = {}) {
+function createFileFromPath(path56, { mtimeMs, size }, filenameOrOptions, options = {}) {
   let filename;
   if (isPlainObject_default2(filenameOrOptions)) {
     [options, filename] = [filenameOrOptions, void 0];
   } else {
     filename = filenameOrOptions;
   }
-  const file = new FileFromPath({ path: path55, size, lastModified: mtimeMs });
+  const file = new FileFromPath({ path: path56, size, lastModified: mtimeMs });
   if (!filename) {
     filename = file.name;
   }
@@ -7133,13 +7133,13 @@ function createFileFromPath(path55, { mtimeMs, size }, filenameOrOptions, option
     lastModified: file.lastModified
   });
 }
-function fileFromPathSync(path55, filenameOrOptions, options = {}) {
-  const stats = statSync(path55);
-  return createFileFromPath(path55, stats, filenameOrOptions, options);
+function fileFromPathSync(path56, filenameOrOptions, options = {}) {
+  const stats = statSync(path56);
+  return createFileFromPath(path56, stats, filenameOrOptions, options);
 }
-async function fileFromPath2(path55, filenameOrOptions, options) {
-  const stats = await fs9.stat(path55);
-  return createFileFromPath(path55, stats, filenameOrOptions, options);
+async function fileFromPath2(path56, filenameOrOptions, options) {
+  const stats = await fs9.stat(path56);
+  return createFileFromPath(path56, stats, filenameOrOptions, options);
 }
 var import_node_domexception, __classPrivateFieldSet4, __classPrivateFieldGet5, _FileFromPath_path, _FileFromPath_start, MESSAGE, FileFromPath;
 var init_fileFromPath = __esm({
@@ -10797,12 +10797,12 @@ var init_esm5 = __esm({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path55) {
-        if (!path55) {
+      resolve(path56) {
+        if (!path56) {
           return this;
         }
-        const rootPath = this.getRootString(path55);
-        const dir = path55.substring(rootPath.length);
+        const rootPath = this.getRootString(path56);
+        const dir = path56.substring(rootPath.length);
         const dirParts = dir.split(this.splitSep);
         const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
         return result;
@@ -11554,8 +11554,8 @@ var init_esm5 = __esm({
       /**
        * @internal
        */
-      getRootString(path55) {
-        return win32.parse(path55).root;
+      getRootString(path56) {
+        return win32.parse(path56).root;
       }
       /**
        * @internal
@@ -11601,8 +11601,8 @@ var init_esm5 = __esm({
       /**
        * @internal
        */
-      getRootString(path55) {
-        return path55.startsWith("/") ? "/" : "";
+      getRootString(path56) {
+        return path56.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -11651,8 +11651,8 @@ var init_esm5 = __esm({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs54 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs54);
+      constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs55 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs55);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = fileURLToPath(cwd);
         }
@@ -11691,11 +11691,11 @@ var init_esm5 = __esm({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path55 = this.cwd) {
-        if (typeof path55 === "string") {
-          path55 = this.cwd.resolve(path55);
+      depth(path56 = this.cwd) {
+        if (typeof path56 === "string") {
+          path56 = this.cwd.resolve(path56);
         }
-        return path55.depth();
+        return path56.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -12182,9 +12182,9 @@ var init_esm5 = __esm({
         process2();
         return results;
       }
-      chdir(path55 = this.cwd) {
+      chdir(path56 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path55 === "string" ? this.cwd.resolve(path55) : path55;
+        this.cwd = typeof path56 === "string" ? this.cwd.resolve(path56) : path56;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -12210,8 +12210,8 @@ var init_esm5 = __esm({
       /**
        * @internal
        */
-      newRoot(fs54) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs54 });
+      newRoot(fs55) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs55 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -12239,8 +12239,8 @@ var init_esm5 = __esm({
       /**
        * @internal
        */
-      newRoot(fs54) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs54 });
+      newRoot(fs55) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs55 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -12559,8 +12559,8 @@ var init_processor = __esm({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path55, n2]) => [
-          path55,
+        return [...this.store.entries()].map(([path56, n2]) => [
+          path56,
           !!(n2 & 2),
           !!(n2 & 1)
         ]);
@@ -12773,9 +12773,9 @@ var init_walker = __esm({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path55, opts) {
+      constructor(patterns, path56, opts) {
         this.patterns = patterns;
-        this.path = path55;
+        this.path = path56;
         this.opts = opts;
         this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -12794,11 +12794,11 @@ var init_walker = __esm({
           });
         }
       }
-      #ignored(path55) {
-        return this.seen.has(path55) || !!this.#ignore?.ignored?.(path55);
+      #ignored(path56) {
+        return this.seen.has(path56) || !!this.#ignore?.ignored?.(path56);
       }
-      #childrenIgnored(path55) {
-        return !!this.#ignore?.childrenIgnored?.(path55);
+      #childrenIgnored(path56) {
+        return !!this.#ignore?.childrenIgnored?.(path56);
       }
       // backpressure mechanism
       pause() {
@@ -13013,8 +13013,8 @@ var init_walker = __esm({
     };
     GlobWalker = class extends GlobUtil {
       matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path55, opts) {
-        super(patterns, path55, opts);
+      constructor(patterns, path56, opts) {
+        super(patterns, path56, opts);
       }
       matchEmit(e2) {
         this.matches.add(e2);
@@ -13051,8 +13051,8 @@ var init_walker = __esm({
     };
     GlobStream = class extends GlobUtil {
       results;
-      constructor(patterns, path55, opts) {
-        super(patterns, path55, opts);
+      constructor(patterns, path56, opts) {
+        super(patterns, path56, opts);
         this.results = new Minipass({
           signal: this.signal,
           objectMode: true
@@ -14062,7 +14062,7 @@ var init_esm7 = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? lstat2 : stat;
         if (wantBigintFsStats) {
-          this._stat = (path55) => statMethod(path55, { bigint: true });
+          this._stat = (path56) => statMethod(path56, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -14087,8 +14087,8 @@ var init_esm7 = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path55, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path55));
+              const { path: path56, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path56));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -14128,20 +14128,20 @@ var init_esm7 = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path55, depth) {
+      async _exploreDir(path56, depth) {
         let files;
         try {
-          files = await readdir2(path55, this._rdOptions);
+          files = await readdir2(path56, this._rdOptions);
         } catch (error) {
           this._onError(error);
         }
-        return { files, depth, path: path55 };
+        return { files, depth, path: path56 };
       }
-      async _formatEntry(dirent, path55) {
+      async _formatEntry(dirent, path56) {
         let entry;
         const basename4 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = presolve(pjoin(path55, basename4));
+          const fullPath = presolve(pjoin(path56, basename4));
           entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
@@ -14202,16 +14202,16 @@ import { watchFile, unwatchFile, watch as fs_watch } from "fs";
 import { open, stat as stat2, lstat as lstat3, realpath as fsrealpath } from "fs/promises";
 import * as sysPath from "path";
 import { type as osType } from "os";
-function createFsWatchInstance(path55, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path56, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path55);
-    emitRaw(rawEvent, evPath, { watchedPath: path55 });
-    if (evPath && path55 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path55, evPath), KEY_LISTENERS, sysPath.join(path55, evPath));
+    listener(path56);
+    emitRaw(rawEvent, evPath, { watchedPath: path56 });
+    if (evPath && path56 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path56, evPath), KEY_LISTENERS, sysPath.join(path56, evPath));
     }
   };
   try {
-    return fs_watch(path55, {
+    return fs_watch(path56, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -14555,12 +14555,12 @@ var init_handler = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path55, fullPath, options, handlers) => {
+    setFsWatchListener = (path56, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path55, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path56, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -14571,7 +14571,7 @@ var init_handler = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path55,
+          path56,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -14586,7 +14586,7 @@ var init_handler = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error.code === "EPERM") {
             try {
-              const fd = await open(path55, "r");
+              const fd = await open(path56, "r");
               await fd.close();
               broadcastErr(error);
             } catch (err) {
@@ -14617,7 +14617,7 @@ var init_handler = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path55, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path56, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -14639,7 +14639,7 @@ var init_handler = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path55, curr));
+              foreach(cont.listeners, (listener2) => listener2(path56, curr));
             }
           })
         };
@@ -14667,13 +14667,13 @@ var init_handler = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path55, listener) {
+      _watchWithNodeFs(path56, listener) {
         const opts = this.fsw.options;
-        const directory = sysPath.dirname(path55);
-        const basename4 = sysPath.basename(path55);
+        const directory = sysPath.dirname(path56);
+        const basename4 = sysPath.basename(path56);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename4);
-        const absolutePath = sysPath.resolve(path55);
+        const absolutePath = sysPath.resolve(path56);
         const options = {
           persistent: opts.persistent
         };
@@ -14683,12 +14683,12 @@ var init_handler = __esm({
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
           options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path55, absolutePath, options, {
+          closer = setFsWatchFileListener(path56, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path55, absolutePath, options, {
+          closer = setFsWatchListener(path56, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -14710,7 +14710,7 @@ var init_handler = __esm({
         let prevStats = stats;
         if (parent.has(basename4))
           return;
-        const listener = async (path55, newStats) => {
+        const listener = async (path56, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -14724,11 +14724,11 @@ var init_handler = __esm({
                 this.fsw._emit(EV.CHANGE, file, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path55);
+                this.fsw._closeFile(path56);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path55, closer2);
+                  this.fsw._addPathCloser(path56, closer2);
               } else {
                 prevStats = newStats2;
               }
@@ -14760,7 +14760,7 @@ var init_handler = __esm({
        * @param item basename of this item
        * @returns true if no more processing is needed for this entry.
        */
-      async _handleSymlink(entry, directory, path55, item) {
+      async _handleSymlink(entry, directory, path56, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -14770,7 +14770,7 @@ var init_handler = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await fsrealpath(path55);
+            linkPath = await fsrealpath(path56);
           } catch (e2) {
             this.fsw._emitReady();
             return true;
@@ -14780,12 +14780,12 @@ var init_handler = __esm({
           if (dir.has(item)) {
             if (this.fsw._symlinkPaths.get(full) !== linkPath) {
               this.fsw._symlinkPaths.set(full, linkPath);
-              this.fsw._emit(EV.CHANGE, path55, entry.stats);
+              this.fsw._emit(EV.CHANGE, path56, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path55, entry.stats);
+            this.fsw._emit(EV.ADD, path56, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -14814,9 +14814,9 @@ var init_handler = __esm({
             return;
           }
           const item = entry.path;
-          let path55 = sysPath.join(directory, item);
+          let path56 = sysPath.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path55, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path56, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -14825,8 +14825,8 @@ var init_handler = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path55 = sysPath.join(dir, sysPath.relative(dir, path55));
-            this._addToNodeFs(path55, initialAdd, wh, depth + 1);
+            path56 = sysPath.join(dir, sysPath.relative(dir, path56));
+            this._addToNodeFs(path56, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve3, reject) => {
@@ -14895,13 +14895,13 @@ var init_handler = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path55, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path56, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path55) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path56) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path55);
+        const wh = this.fsw._getWatchHelpers(path56);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -14917,8 +14917,8 @@ var init_handler = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sysPath.resolve(path55);
-            const targetPath = follow ? await fsrealpath(path55) : path55;
+            const absPath = sysPath.resolve(path56);
+            const targetPath = follow ? await fsrealpath(path56) : path56;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -14928,29 +14928,29 @@ var init_handler = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await fsrealpath(path55) : path55;
+            const targetPath = follow ? await fsrealpath(path56) : path56;
             if (this.fsw.closed)
               return;
             const parent = sysPath.dirname(wh.watchPath);
             this.fsw._getWatchedDir(parent).add(wh.watchPath);
             this.fsw._emit(EV.ADD, wh.watchPath, stats);
-            closer = await this._handleDir(parent, stats, initialAdd, depth, path55, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path56, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sysPath.resolve(path55), targetPath);
+              this.fsw._symlinkPaths.set(sysPath.resolve(path56), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path55, closer);
+            this.fsw._addPathCloser(path56, closer);
           return false;
         } catch (error) {
           if (this.fsw._handleError(error)) {
             ready();
-            return path55;
+            return path56;
           }
         }
       }
@@ -14989,26 +14989,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path55) {
-  if (typeof path55 !== "string")
+function normalizePath(path56) {
+  if (typeof path56 !== "string")
     throw new Error("string expected");
-  path55 = sysPath2.normalize(path55);
-  path55 = path55.replace(/\\/g, "/");
+  path56 = sysPath2.normalize(path56);
+  path56 = path56.replace(/\\/g, "/");
   let prepend = false;
-  if (path55.startsWith("//"))
+  if (path56.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path55.match(DOUBLE_SLASH_RE2))
-    path55 = path55.replace(DOUBLE_SLASH_RE2, "/");
+  while (path56.match(DOUBLE_SLASH_RE2))
+    path56 = path56.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path55 = "/" + path55;
-  return path55;
+    path56 = "/" + path56;
+  return path56;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path55 = normalizePath(testString);
+  const path56 = normalizePath(testString);
   for (let index2 = 0; index2 < patterns.length; index2++) {
     const pattern = patterns[index2];
-    if (pattern(path55, stats)) {
+    if (pattern(path56, stats)) {
       return true;
     }
   }
@@ -15068,19 +15068,19 @@ var init_esm8 = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path55) => toUnix(sysPath2.normalize(toUnix(path55)));
-    normalizeIgnored = (cwd = "") => (path55) => {
-      if (typeof path55 === "string") {
-        return normalizePathToUnix(sysPath2.isAbsolute(path55) ? path55 : sysPath2.join(cwd, path55));
+    normalizePathToUnix = (path56) => toUnix(sysPath2.normalize(toUnix(path56)));
+    normalizeIgnored = (cwd = "") => (path56) => {
+      if (typeof path56 === "string") {
+        return normalizePathToUnix(sysPath2.isAbsolute(path56) ? path56 : sysPath2.join(cwd, path56));
       } else {
-        return path55;
+        return path56;
       }
     };
-    getAbsolutePath = (path55, cwd) => {
-      if (sysPath2.isAbsolute(path55)) {
-        return path55;
+    getAbsolutePath = (path56, cwd) => {
+      if (sysPath2.isAbsolute(path56)) {
+        return path56;
       }
-      return sysPath2.join(cwd, path55);
+      return sysPath2.join(cwd, path56);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -15135,10 +15135,10 @@ var init_esm8 = __esm({
     STAT_METHOD_F = "stat";
     STAT_METHOD_L = "lstat";
     WatchHelper = class {
-      constructor(path55, follow, fsw) {
+      constructor(path56, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path55;
-        this.path = path55 = path55.replace(REPLACER_RE, "");
+        const watchPath = path56;
+        this.path = path56 = path56.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sysPath2.resolve(watchPath);
         this.dirParts = [];
@@ -15260,20 +15260,20 @@ var init_esm8 = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path55) => {
-            const absPath = getAbsolutePath(path55, cwd);
+          paths = paths.map((path56) => {
+            const absPath = getAbsolutePath(path56, cwd);
             return absPath;
           });
         }
-        paths.forEach((path55) => {
-          this._removeIgnoredPath(path55);
+        paths.forEach((path56) => {
+          this._removeIgnoredPath(path56);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path55) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path55, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path56) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path56, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -15295,17 +15295,17 @@ var init_esm8 = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path55) => {
-          if (!sysPath2.isAbsolute(path55) && !this._closers.has(path55)) {
+        paths.forEach((path56) => {
+          if (!sysPath2.isAbsolute(path56) && !this._closers.has(path56)) {
             if (cwd)
-              path55 = sysPath2.join(cwd, path55);
-            path55 = sysPath2.resolve(path55);
+              path56 = sysPath2.join(cwd, path56);
+            path56 = sysPath2.resolve(path56);
           }
-          this._closePath(path55);
-          this._addIgnoredPath(path55);
-          if (this._watched.has(path55)) {
+          this._closePath(path56);
+          this._addIgnoredPath(path56);
+          if (this._watched.has(path56)) {
             this._addIgnoredPath({
-              path: path55,
+              path: path56,
               recursive: true
             });
           }
@@ -15369,38 +15369,38 @@ var init_esm8 = __esm({
        * @param stats arguments to be passed with event
        * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
        */
-      async _emit(event, path55, stats) {
+      async _emit(event, path56, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path55 = sysPath2.normalize(path55);
+          path56 = sysPath2.normalize(path56);
         if (opts.cwd)
-          path55 = sysPath2.relative(opts.cwd, path55);
-        const args = [path55];
+          path56 = sysPath2.relative(opts.cwd, path56);
+        const args = [path56];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path55))) {
+        if (awf && (pw = this._pendingWrites.get(path56))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path55, [event, ...args]);
+            this._pendingUnlinks.set(path56, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path56) => {
+              this._pendingUnlinks.forEach((entry, path57) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path56);
+                this._pendingUnlinks.delete(path57);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path55)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path56)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path55);
+            this._pendingUnlinks.delete(path56);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -15418,16 +15418,16 @@ var init_esm8 = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path55, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path56, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path55, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path56, 50);
           if (isThrottled)
             return this;
         }
         if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path55) : path55;
+          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path56) : path56;
           let stats2;
           try {
             stats2 = await stat3(fullPath);
@@ -15458,23 +15458,23 @@ var init_esm8 = __esm({
        * @param timeout duration of time to suppress duplicate actions
        * @returns tracking object or false if action should be suppressed
        */
-      _throttle(actionType, path55, timeout) {
+      _throttle(actionType, path56, timeout) {
         if (!this._throttled.has(actionType)) {
           this._throttled.set(actionType, /* @__PURE__ */ new Map());
         }
         const action = this._throttled.get(actionType);
         if (!action)
           throw new Error("invalid throttle");
-        const actionPath = action.get(path55);
+        const actionPath = action.get(path56);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear2 = () => {
-          const item = action.get(path55);
+          const item = action.get(path56);
           const count = item ? item.count : 0;
-          action.delete(path55);
+          action.delete(path56);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -15482,7 +15482,7 @@ var init_esm8 = __esm({
         };
         timeoutObject = setTimeout(clear2, timeout);
         const thr = { timeoutObject, clear: clear2, count: 0 };
-        action.set(path55, thr);
+        action.set(path56, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -15496,44 +15496,44 @@ var init_esm8 = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path55, threshold, event, awfEmit) {
+      _awaitWriteFinish(path56, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path55;
-        if (this.options.cwd && !sysPath2.isAbsolute(path55)) {
-          fullPath = sysPath2.join(this.options.cwd, path55);
+        let fullPath = path56;
+        if (this.options.cwd && !sysPath2.isAbsolute(path56)) {
+          fullPath = sysPath2.join(this.options.cwd, path56);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           statcb(fullPath, (err, curStat) => {
-            if (err || !writes.has(path55)) {
+            if (err || !writes.has(path56)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path55).lastChange = now2;
+              writes.get(path56).lastChange = now2;
             }
-            const pw = writes.get(path55);
+            const pw = writes.get(path56);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path55);
+              writes.delete(path56);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path55)) {
-          writes.set(path55, {
+        if (!writes.has(path56)) {
+          writes.set(path56, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path55);
+              writes.delete(path56);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -15544,8 +15544,8 @@ var init_esm8 = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path55, stats) {
-        if (this.options.atomic && DOT_RE.test(path55))
+      _isIgnored(path56, stats) {
+        if (this.options.atomic && DOT_RE.test(path56))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -15555,17 +15555,17 @@ var init_esm8 = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path55, stats);
+        return this._userIgnored(path56, stats);
       }
-      _isntIgnored(path55, stat4) {
-        return !this._isIgnored(path55, stat4);
+      _isntIgnored(path56, stat4) {
+        return !this._isIgnored(path56, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path55) {
-        return new WatchHelper(path55, this.options.followSymlinks, this);
+      _getWatchHelpers(path56) {
+        return new WatchHelper(path56, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -15597,63 +15597,63 @@ var init_esm8 = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path55 = sysPath2.join(directory, item);
-        const fullPath = sysPath2.resolve(path55);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path55) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path55, 100))
+        const path56 = sysPath2.join(directory, item);
+        const fullPath = sysPath2.resolve(path56);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path56) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path56, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path55);
+        const wp = this._getWatchedDir(path56);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path55, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path56, nested));
         const parent = this._getWatchedDir(directory);
         const wasTracked = parent.has(item);
         parent.remove(item);
         if (this._symlinkPaths.has(fullPath)) {
           this._symlinkPaths.delete(fullPath);
         }
-        let relPath = path55;
+        let relPath = path56;
         if (this.options.cwd)
-          relPath = sysPath2.relative(this.options.cwd, path55);
+          relPath = sysPath2.relative(this.options.cwd, path56);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path55);
+        this._watched.delete(path56);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path55))
-          this._emit(eventName, path55);
-        this._closePath(path55);
+        if (wasTracked && !this._isIgnored(path56))
+          this._emit(eventName, path56);
+        this._closePath(path56);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path55) {
-        this._closeFile(path55);
-        const dir = sysPath2.dirname(path55);
-        this._getWatchedDir(dir).remove(sysPath2.basename(path55));
+      _closePath(path56) {
+        this._closeFile(path56);
+        const dir = sysPath2.dirname(path56);
+        this._getWatchedDir(dir).remove(sysPath2.basename(path56));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path55) {
-        const closers = this._closers.get(path55);
+      _closeFile(path56) {
+        const closers = this._closers.get(path56);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path55);
+        this._closers.delete(path56);
       }
-      _addPathCloser(path55, closer) {
+      _addPathCloser(path56, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path55);
+        let list = this._closers.get(path56);
         if (!list) {
           list = [];
-          this._closers.set(path55, list);
+          this._closers.set(path56, list);
         }
         list.push(closer);
       }
@@ -37854,8 +37854,8 @@ var require_lib3 = __commonJS({
 
 // src/cli.tsx
 init_dist();
-import { promises as fs53 } from "node:fs";
-import path54 from "node:path";
+import { promises as fs54 } from "node:fs";
+import path55 from "node:path";
 import { spawn as spawn17 } from "node:child_process";
 import { render as render2 } from "ink";
 import yargs from "yargs";
@@ -39050,13 +39050,13 @@ var MultipartBody = class {
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.30.1/node_modules/@anthropic-ai/sdk/_shims/node-runtime.mjs
 import { ReadableStream as ReadableStream3 } from "node:stream/web";
 var fileFromPathWarned = false;
-async function fileFromPath3(path55, ...args) {
+async function fileFromPath3(path56, ...args) {
   const { fileFromPath: _fileFromPath } = await Promise.resolve().then(() => (init_fileFromPath(), fileFromPath_exports));
   if (!fileFromPathWarned) {
-    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path55)}) instead`);
+    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path56)}) instead`);
     fileFromPathWarned = true;
   }
-  return await _fileFromPath(path55, ...args);
+  return await _fileFromPath(path56, ...args);
 }
 var defaultHttpAgent = new import_agentkeepalive.default({ keepAlive: true, timeout: 5 * 60 * 1e3 });
 var defaultHttpsAgent = new import_agentkeepalive.default.HttpsAgent({ keepAlive: true, timeout: 5 * 60 * 1e3 });
@@ -39655,29 +39655,29 @@ var APIClient = class {
   defaultIdempotencyKey() {
     return `stainless-node-retry-${uuid4()}`;
   }
-  get(path55, opts) {
-    return this.methodRequest("get", path55, opts);
+  get(path56, opts) {
+    return this.methodRequest("get", path56, opts);
   }
-  post(path55, opts) {
-    return this.methodRequest("post", path55, opts);
+  post(path56, opts) {
+    return this.methodRequest("post", path56, opts);
   }
-  patch(path55, opts) {
-    return this.methodRequest("patch", path55, opts);
+  patch(path56, opts) {
+    return this.methodRequest("patch", path56, opts);
   }
-  put(path55, opts) {
-    return this.methodRequest("put", path55, opts);
+  put(path56, opts) {
+    return this.methodRequest("put", path56, opts);
   }
-  delete(path55, opts) {
-    return this.methodRequest("delete", path55, opts);
+  delete(path56, opts) {
+    return this.methodRequest("delete", path56, opts);
   }
-  methodRequest(method, path55, opts) {
+  methodRequest(method, path56, opts) {
     return this.request(Promise.resolve(opts).then(async (opts2) => {
       const body = opts2 && isBlobLike(opts2?.body) ? new DataView(await opts2.body.arrayBuffer()) : opts2?.body instanceof DataView ? opts2.body : opts2?.body instanceof ArrayBuffer ? new DataView(opts2.body) : opts2 && ArrayBuffer.isView(opts2?.body) ? new DataView(opts2.body.buffer) : opts2?.body;
-      return { method, path: path55, ...opts2, body };
+      return { method, path: path56, ...opts2, body };
     }));
   }
-  getAPIList(path55, Page2, opts) {
-    return this.requestAPIList(Page2, { method: "get", path: path55, ...opts });
+  getAPIList(path56, Page2, opts) {
+    return this.requestAPIList(Page2, { method: "get", path: path56, ...opts });
   }
   calculateContentLength(body) {
     if (typeof body === "string") {
@@ -39695,10 +39695,10 @@ var APIClient = class {
     return null;
   }
   buildRequest(options, { retryCount = 0 } = {}) {
-    const { method, path: path55, query, headers = {} } = options;
+    const { method, path: path56, query, headers = {} } = options;
     const body = ArrayBuffer.isView(options.body) || options.__binaryRequest && typeof options.body === "string" ? options.body : isMultipartBody(options.body) ? options.body.body : options.body ? JSON.stringify(options.body, null, 2) : null;
     const contentLength = this.calculateContentLength(body);
-    const url = this.buildURL(path55, query);
+    const url = this.buildURL(path56, query);
     if ("timeout" in options)
       validatePositiveInteger("timeout", options.timeout);
     const timeout = options.timeout ?? this.timeout;
@@ -39811,8 +39811,8 @@ var APIClient = class {
     const request = this.makeRequest(options, null);
     return new PagePromise(this, request, Page2);
   }
-  buildURL(path55, query) {
-    const url = isAbsoluteURL(path55) ? new URL(path55) : new URL(this.baseURL + (this.baseURL.endsWith("/") && path55.startsWith("/") ? path55.slice(1) : path55));
+  buildURL(path56, query) {
+    const url = isAbsoluteURL(path56) ? new URL(path56) : new URL(this.baseURL + (this.baseURL.endsWith("/") && path56.startsWith("/") ? path56.slice(1) : path56));
     const defaultQuery = this.defaultQuery();
     if (!isEmptyObj(defaultQuery)) {
       query = { ...defaultQuery, ...query };
@@ -47813,8 +47813,8 @@ import path29 from "node:path";
 var GoalLock = class _GoalLock {
   path;
   released = false;
-  constructor(path55) {
-    this.path = path55;
+  constructor(path56) {
+    this.path = path56;
   }
   /**
    * Try to acquire the lock, polling every 50 ms up to `timeoutMs`. If a
@@ -48016,13 +48016,13 @@ async function gitChangedFiles(workspace) {
   return out.stdout.split("\n").map(parsePorcelainLine).filter((p2) => p2 !== null);
 }
 function parsePorcelainLine(line) {
-  const path55 = line.slice(3).trim();
-  if (!path55)
+  const path56 = line.slice(3).trim();
+  if (!path56)
     return null;
-  const renameIdx = path55.indexOf(" -> ");
+  const renameIdx = path56.indexOf(" -> ");
   if (renameIdx >= 0)
-    return path55.slice(renameIdx + 4);
-  return path55;
+    return path56.slice(renameIdx + 4);
+  return path56;
 }
 function countTestChanges(files) {
   return files.filter(isTestPath).length;
@@ -51349,6 +51349,11 @@ var speckitCommand = {
 
 // src/commands/feature.ts
 import chalk24 from "chalk";
+function setOuterStage(label) {
+  tuiBus.update((s2) => {
+    s2.status.stage = label;
+  });
+}
 var featureCommand = {
   name: "feature",
   description: "End-to-end feature pipeline: speckit run \u2192 export-to-swe1 \u2192 squad implement \u2192 tests \u2192 audit",
@@ -51367,6 +51372,7 @@ var featureCommand = {
     log += `### 1/7 \u2014 Spec-Kit pipeline
 
 `;
+    setOuterStage("Spec-Kit (specify \u2192 plan \u2192 tasks)");
     try {
       const speckitLog = await speckitCommand.execute(`run ${task}`, state, cfg);
       log += `${speckitLog}
@@ -51390,6 +51396,7 @@ var featureCommand = {
     log += `### 2/7 \u2014 Export to SWE.1 requirements
 
 `;
+    setOuterStage("Export spec \u2192 SWE.1");
     try {
       const exportLog = await speckitCommand.execute(`export-to-swe1 ${fid}`, state, cfg);
       log += `${exportLog}
@@ -53733,7 +53740,17 @@ function App({
   const [tuiState, setTuiState] = useState(tuiBus.get());
   const [picker, setPicker] = useState(null);
   const nextId = useRef(1);
-  const cols = stdout?.columns ?? 100;
+  const [cols, setCols] = useState(stdout?.columns ?? 100);
+  useEffect(() => {
+    if (!stdout) return;
+    const onResize = () => {
+      setCols(stdout.columns ?? 100);
+    };
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
   const railEnabled = railVisible && cols >= RAIL_MIN_WIDTH;
   useEffect(() => {
     process.env.FLOW_TUI_ACTIVE = "1";
@@ -54132,12 +54149,71 @@ var History = class _History {
   }
 };
 
-// src/config.ts
+// src/binary-resolver.ts
 import { promises as fs51 } from "node:fs";
 import path52 from "node:path";
+import os3 from "node:os";
+async function resolveBinary(nameOrPath) {
+  if (!nameOrPath) return null;
+  const isWindows2 = process.platform === "win32";
+  const exts = isWindows2 ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((e2) => e2.toLowerCase()).filter(Boolean) : [""];
+  const candidate = async (full) => {
+    for (const ext2 of exts) {
+      const probe = ext2 && !full.toLowerCase().endsWith(ext2) ? full + ext2 : full;
+      try {
+        await fs51.access(probe, fs51.constants.F_OK);
+        return probe;
+      } catch {
+      }
+    }
+    return null;
+  };
+  if (path52.isAbsolute(nameOrPath) || nameOrPath.includes(path52.sep)) {
+    return await candidate(nameOrPath);
+  }
+  const pathEntries = (process.env.PATH ?? "").split(path52.delimiter).filter(Boolean);
+  for (const dir of pathEntries) {
+    const found = await candidate(path52.join(dir, nameOrPath));
+    if (found) return found;
+  }
+  const fallbackDirs = wellKnownBinDirs();
+  for (const dir of fallbackDirs) {
+    const found = await candidate(path52.join(dir, nameOrPath));
+    if (found) return found;
+  }
+  return null;
+}
+function wellKnownBinDirs() {
+  const home = os3.homedir();
+  const dirs = [];
+  if (process.platform === "darwin") {
+    dirs.push("/opt/homebrew/bin", "/usr/local/bin");
+    dirs.push(path52.join(home, ".npm-global/bin"));
+  } else if (process.platform === "linux") {
+    dirs.push("/usr/local/bin", "/usr/bin");
+    dirs.push("/home/linuxbrew/.linuxbrew/bin");
+    dirs.push(path52.join(home, ".npm-global/bin"));
+    dirs.push(path52.join(home, ".local/bin"));
+  } else if (process.platform === "win32") {
+    if (process.env.APPDATA) {
+      dirs.push(path52.join(process.env.APPDATA, "npm"));
+    }
+    if (process.env.ProgramFiles) {
+      dirs.push(path52.join(process.env.ProgramFiles, "nodejs"));
+    }
+    if (process.env.LOCALAPPDATA) {
+      dirs.push(path52.join(process.env.LOCALAPPDATA, "Programs", "gemini-cli"));
+    }
+  }
+  return dirs;
+}
+
+// src/config.ts
+import { promises as fs52 } from "node:fs";
+import path53 from "node:path";
 import toml2 from "@iarna/toml";
 function resolvePath(raw, base) {
-  return path52.isAbsolute(raw) ? raw : path52.resolve(base, raw);
+  return path53.isAbsolute(raw) ? raw : path53.resolve(base, raw);
 }
 function asString2(v2, fallback = "") {
   return typeof v2 === "string" ? v2 : fallback;
@@ -54175,10 +54251,10 @@ var DEFAULT_WEB_ALLOWLIST = [
   "*.espressif.com",
   "developer.arm.com"
 ];
-async function loadConfig(configPath) {
-  const raw = await fs51.readFile(configPath, "utf8");
+async function loadConfig(configPath, projectDir2 = process.cwd()) {
+  const raw = await fs52.readFile(configPath, "utf8");
   const parsed = toml2.parse(raw);
-  const baseDir = path52.dirname(path52.resolve(configPath));
+  const baseDir = path53.dirname(path53.resolve(configPath));
   const gemini = parsed.gemini ?? {};
   const tools = parsed.tools ?? {};
   const jlink = parsed.jlink ?? {};
@@ -54199,7 +54275,7 @@ async function loadConfig(configPath) {
   const planMode = modes.plan ?? {};
   const buildMode = modes.build ?? {};
   const cfg = {
-    configPath: path52.resolve(configPath),
+    configPath: path53.resolve(configPath),
     baseDir,
     gemini: {
       binary: asString2(gemini.binary, "gemini"),
@@ -54221,9 +54297,11 @@ async function loadConfig(configPath) {
     },
     flow: {
       flowHome: resolvePath(asString2(flow.flow_home, "."), baseDir),
+      // Project-scoped: memory/codedigest follow the user's invocation
+      // dir so each project owns its own artefacts.
       memoryDir: resolvePath(
         asString2(flow.memory_dir, "memory/projects"),
-        baseDir
+        projectDir2
       ),
       soulPath: resolvePath(
         asString2(flow.soul_path, ".flow/soul.md"),
@@ -54239,7 +54317,7 @@ async function loadConfig(configPath) {
       ),
       codedigestDir: resolvePath(
         asString2(flow.codedigest_dir, "memory/codedigest"),
-        baseDir
+        projectDir2
       )
     },
     backend: {
@@ -54348,7 +54426,7 @@ async function loadConfig(configPath) {
       binary: asString2(mempalaceCfg.binary, "mempalace"),
       palaceDir: resolvePath(
         asString2(mempalaceCfg.palace_dir, "memory/mempalace"),
-        baseDir
+        projectDir2
       ),
       topK: asNumber2(mempalaceCfg.top_k, 5),
       queryTimeoutSecs: asNumber2(mempalaceCfg.query_timeout_secs, 5)
@@ -54377,11 +54455,11 @@ async function loadConfig(configPath) {
       pythonTimeoutMs: asNumber2(memoryCfg.python_timeout_ms, 6e4),
       reasoningDir: resolvePath(
         asString2(memoryCfg.reasoning_dir, "memory/reasoning"),
-        baseDir
+        projectDir2
       ),
       rvfDir: resolvePath(
         asString2(memoryCfg.rvf_dir, "memory/rvf"),
-        baseDir
+        projectDir2
       ),
       reasoningOnGoalComplete: asBool(memoryCfg.reasoning_on_goal_complete, true),
       rvfOnGoalComplete: asBool(memoryCfg.rvf_on_goal_complete, true),
@@ -54390,7 +54468,7 @@ async function loadConfig(configPath) {
       sonaEnabled: asBool(memoryCfg.sona_enabled, true),
       sonaDir: resolvePath(
         asString2(memoryCfg.sona_dir, "memory/sona"),
-        baseDir
+        projectDir2
       )
     },
     routing: {
@@ -54418,26 +54496,24 @@ async function loadConfig(configPath) {
       })()
     }
   };
-  if (cfg.gemini.workingDir) {
-    cfg.gemini.workingDir = resolvePath(cfg.gemini.workingDir, baseDir);
-  }
+  cfg.gemini.workingDir = cfg.gemini.workingDir ? resolvePath(cfg.gemini.workingDir, projectDir2) : projectDir2;
   return cfg;
 }
 async function resolveDefaultConfig() {
   const candidates = [];
   const agenitHome = process.env.AGENIT_HOME;
   const flowHome = process.env.FLOW_HOME;
-  const here = path52.dirname(new URL(import.meta.url).pathname);
-  const siblingDir = path52.resolve(here, "..", "..", "..", "..", "config");
+  const here = path53.dirname(new URL(import.meta.url).pathname);
+  const siblingDir = path53.resolve(here, "..", "..", "..", "..", "config");
   for (const name of ["agenit.toml", "flow.toml"]) {
-    if (agenitHome) candidates.push(path52.join(agenitHome, "config", name));
-    if (flowHome) candidates.push(path52.join(flowHome, "config", name));
-    candidates.push(path52.join(siblingDir, name));
-    candidates.push(path52.join(process.cwd(), "config", name));
+    if (agenitHome) candidates.push(path53.join(agenitHome, "config", name));
+    if (flowHome) candidates.push(path53.join(flowHome, "config", name));
+    candidates.push(path53.join(siblingDir, name));
+    candidates.push(path53.join(process.cwd(), "config", name));
   }
   for (const c2 of candidates) {
     try {
-      await fs51.access(c2);
+      await fs52.access(c2);
       return c2;
     } catch {
     }
@@ -54640,18 +54716,18 @@ async function readStdin() {
 }
 
 // src/update-check.ts
-import { promises as fs52 } from "node:fs";
-import os3 from "node:os";
-import path53 from "node:path";
+import { promises as fs53 } from "node:fs";
+import os4 from "node:os";
+import path54 from "node:path";
 var DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 function defaultCachePath() {
   const xdg = process.env.XDG_CACHE_HOME;
-  const base = xdg ? xdg : path53.join(os3.homedir(), ".cache");
-  return path53.join(base, "flow", "version-check.json");
+  const base = xdg ? xdg : path54.join(os4.homedir(), ".cache");
+  return path54.join(base, "flow", "version-check.json");
 }
 async function readCache(p2) {
   try {
-    const raw = await fs52.readFile(p2, "utf8");
+    const raw = await fs53.readFile(p2, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.checked_at === "number" && typeof parsed.installed === "string") {
       return {
@@ -54667,8 +54743,8 @@ async function readCache(p2) {
 }
 async function writeCache(p2, entry) {
   try {
-    await fs52.mkdir(path53.dirname(p2), { recursive: true });
-    await fs52.writeFile(p2, JSON.stringify(entry, null, 2));
+    await fs53.mkdir(path54.dirname(p2), { recursive: true });
+    await fs53.writeFile(p2, JSON.stringify(entry, null, 2));
   } catch {
   }
 }
@@ -54787,14 +54863,31 @@ var SoulKeeperWorker = class {
 
 // src/cli.tsx
 import { jsx as jsx5 } from "react/jsx-runtime";
-var FLOW_VERSION = "0.5.0";
+var FLOW_VERSION = "1.0.3";
 var MIN_GEMINI_MAJOR = 0;
 var MIN_GEMINI_MINOR = 37;
-async function checkGeminiCli(binary) {
+async function checkGeminiCli(cfg) {
+  const configured = cfg.gemini.binary;
+  const resolved = await resolveBinary(configured) ?? // Last-ditch: try the literal name in case spawn() can find it via
+  // shell semantics we didn't model (cygwin, WSL bridge, etc.).
+  (configured ? configured : null);
+  if (!resolved) {
+    throw new Error(
+      `Gemini CLI not found.
+Configured binary: '${configured}' is not on PATH and was not found in any well-known install location.
+Install: npm install -g @google/gemini-cli
+Or set [gemini] binary = "<path>" in agenit.toml (or flow.toml)`
+    );
+  }
+  cfg.gemini.binary = resolved;
   const out = await new Promise(
     (resolve3, reject) => {
-      const child = spawn17(binary, ["--version"], {
-        stdio: ["ignore", "pipe", "pipe"]
+      const child = spawn17(resolved, ["--version"], {
+        stdio: ["ignore", "pipe", "pipe"],
+        // shell:true on Windows lets .cmd/.bat shims execute correctly
+        // when invoked without their extension. POSIX leaves shell=false
+        // (the default) so we don't pay the spawn-a-shell tax.
+        shell: process.platform === "win32"
       });
       let stdout = "";
       child.stdout.setEncoding("utf8");
@@ -54807,9 +54900,8 @@ async function checkGeminiCli(binary) {
   ).catch(() => null);
   if (!out) {
     throw new Error(
-      `Gemini CLI not found at '${binary}'.
-Install: npm install -g @google/gemini-cli
-Then update [gemini] binary = "<path>" in agenit.toml (or flow.toml)`
+      `Gemini CLI at '${resolved}' could not be executed.
+Reinstall: npm install -g @google/gemini-cli`
     );
   }
   for (const tok of out.stdout.split(/\s+/)) {
@@ -54828,13 +54920,13 @@ Upgrade: npm install -g @google/gemini-cli@latest`
     }
   }
   process.stderr.write(
-    `warning: could not parse Gemini CLI version from \`${binary} --version\`
+    `warning: could not parse Gemini CLI version from \`${resolved} --version\`
 `
   );
 }
 async function readActiveProject() {
   try {
-    const txt = await fs53.readFile(".agenit_project", "utf8");
+    const txt = await fs54.readFile(".agenit_project", "utf8");
     const trimmed = txt.trim();
     if (!trimmed) return null;
     if (trimmed.includes("=")) {
@@ -54846,16 +54938,17 @@ async function readActiveProject() {
   } catch {
   }
   try {
-    const txt = await fs53.readFile(".flow_project", "utf8");
+    const txt = await fs54.readFile(".flow_project", "utf8");
     const trimmed = txt.trim();
     return trimmed || null;
   } catch {
     return null;
   }
 }
+var INVOCATION_CWD = process.cwd();
 async function loadFlowConfig(configFlag) {
   const configPath = configFlag ?? await resolveDefaultConfig();
-  const cfg = await loadConfig(configPath);
+  const cfg = await loadConfig(configPath, INVOCATION_CWD);
   initTelemetry(cfg.telemetry);
   initMetrics(cfg.telemetry);
   return cfg;
@@ -54874,7 +54967,7 @@ async function cmdResume(cfg, idHint) {
 `);
     process.exit(1);
   }
-  await checkGeminiCli(cfg.gemini.binary);
+  await checkGeminiCli(cfg);
   const initialProject = session.meta.project ?? await readActiveProject();
   const history = await History.load();
   await writeGuard(cfg, null);
@@ -54915,7 +55008,7 @@ async function cmdSessionsList() {
   }
 }
 async function cmdRepl(cfg) {
-  await checkGeminiCli(cfg.gemini.binary);
+  await checkGeminiCli(cfg);
   const initialProject = await readActiveProject();
   const history = await History.load();
   await writeGuard(cfg, null);
@@ -54948,12 +55041,12 @@ async function cmdRepl(cfg) {
   }
   if (cfg.memory.soulKeeperEnabled && initialProject) {
     try {
-      const projectMemoryDir = path54.join(cfg.flow.memoryDir, initialProject);
+      const projectMemoryDir = path55.join(cfg.flow.memoryDir, initialProject);
       getLoopWorkerPool().spawn(
         new SoulKeeperWorker({
           project: initialProject,
           soulPath: cfg.flow.soulPath,
-          contextPath: path54.join(projectMemoryDir, "context.md")
+          contextPath: path55.join(projectMemoryDir, "context.md")
         }),
         { gapMs: cfg.memory.soulKeeperGapMs }
       );
@@ -55003,7 +55096,7 @@ async function cmdCompletions(shell) {
   process.stdout.write(completionScript(shell));
 }
 async function cmdRun(cfg, project, input) {
-  await checkGeminiCli(cfg.gemini.binary);
+  await checkGeminiCli(cfg);
   await writeGuard(cfg, null);
   await ensureGuardHookRegistered();
   const out = await runFlow(cfg, project, input);
@@ -55020,7 +55113,7 @@ async function cmdProjects(cfg) {
   const dir = cfg.flow.memoryDir;
   let entries = [];
   try {
-    entries = await fs53.readdir(dir, { withFileTypes: true });
+    entries = await fs54.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -55030,20 +55123,20 @@ async function cmdProjects(cfg) {
   }
 }
 async function cmdInit(cfg, projectDir2, name) {
-  const target = path54.resolve(projectDir2);
-  const projectName = name ?? path54.basename(target);
-  const memDir = path54.join(cfg.flow.memoryDir, projectName);
-  await fs53.mkdir(memDir, { recursive: true });
+  const target = path55.resolve(projectDir2);
+  const projectName = name ?? path55.basename(target);
+  const memDir = path55.join(cfg.flow.memoryDir, projectName);
+  await fs54.mkdir(memDir, { recursive: true });
   for (const file of ["context.md", "decisions.md", "requirements.md"]) {
-    const p2 = path54.join(memDir, file);
+    const p2 = path55.join(memDir, file);
     try {
-      await fs53.access(p2);
+      await fs54.access(p2);
     } catch {
-      await fs53.writeFile(p2, "");
+      await fs54.writeFile(p2, "");
     }
   }
-  await fs53.writeFile(
-    path54.join(target, ".agenit_project"),
+  await fs54.writeFile(
+    path55.join(target, ".agenit_project"),
     `project = "${projectName}"
 profile = "automotive"
 `
@@ -55052,12 +55145,12 @@ profile = "automotive"
 `);
 }
 async function cmdUnflow(projectDir2) {
-  const target = path54.resolve(projectDir2);
+  const target = path55.resolve(projectDir2);
   let removed = false;
   for (const fname of [".agenit_project", ".flow_project"]) {
-    const marker = path54.join(target, fname);
+    const marker = path55.join(target, fname);
     try {
-      await fs53.unlink(marker);
+      await fs54.unlink(marker);
       process.stdout.write(`\u2713 Removed ${marker}
 `);
       removed = true;