@agenit/cli 1.0.2 → 1.0.4

package/cli.js

@@ -148,8 +148,8 @@ var init_soul = __esm({
     "use strict";
     SoulEngine = class {
       path;
-      constructor(path55) {
-        this.path = path55;
+      constructor(path57) {
+        this.path = path57;
       }
       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 path57 = url.path;
+      if (path57.length === 0) {
         return;
       }
-      if (url.scheme === "file" && path55.length === 1 && isNormalizedWindowsDriveLetter(path55[0])) {
+      if (url.scheme === "file" && path57.length === 1 && isNormalizedWindowsDriveLetter(path57[0])) {
         return;
       }
-      path55.pop();
+      path57.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(path57, { 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: path57, 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(path57, filenameOrOptions, options = {}) {
+  const stats = statSync(path57);
+  return createFileFromPath(path57, stats, filenameOrOptions, options);
 }
-async function fileFromPath2(path55, filenameOrOptions, options) {
-  const stats = await fs9.stat(path55);
-  return createFileFromPath(path55, stats, filenameOrOptions, options);
+async function fileFromPath2(path57, filenameOrOptions, options) {
+  const stats = await fs9.stat(path57);
+  return createFileFromPath(path57, 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(path57) {
+        if (!path57) {
           return this;
         }
-        const rootPath = this.getRootString(path55);
-        const dir = path55.substring(rootPath.length);
+        const rootPath = this.getRootString(path57);
+        const dir = path57.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(path57) {
+        return win32.parse(path57).root;
       }
       /**
        * @internal
@@ -11601,8 +11601,8 @@ var init_esm5 = __esm({
       /**
        * @internal
        */
-      getRootString(path55) {
-        return path55.startsWith("/") ? "/" : "";
+      getRootString(path57) {
+        return path57.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: fs56 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs56);
         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(path57 = this.cwd) {
+        if (typeof path57 === "string") {
+          path57 = this.cwd.resolve(path57);
         }
-        return path55.depth();
+        return path57.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(path57 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path55 === "string" ? this.cwd.resolve(path55) : path55;
+        this.cwd = typeof path57 === "string" ? this.cwd.resolve(path57) : path57;
         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(fs56) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs56 });
       }
       /**
        * 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(fs56) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs56 });
       }
       /**
        * 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(([path57, n2]) => [
+          path57,
           !!(n2 & 2),
           !!(n2 & 1)
         ]);
@@ -12773,9 +12773,9 @@ var init_walker = __esm({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path55, opts) {
+      constructor(patterns, path57, opts) {
         this.patterns = patterns;
-        this.path = path55;
+        this.path = path57;
         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(path57) {
+        return this.seen.has(path57) || !!this.#ignore?.ignored?.(path57);
       }
-      #childrenIgnored(path55) {
-        return !!this.#ignore?.childrenIgnored?.(path55);
+      #childrenIgnored(path57) {
+        return !!this.#ignore?.childrenIgnored?.(path57);
       }
       // 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, path57, opts) {
+        super(patterns, path57, 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, path57, opts) {
+        super(patterns, path57, 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 = (path57) => statMethod(path57, { 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: path57, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path57));
               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(path57, depth) {
         let files;
         try {
-          files = await readdir2(path55, this._rdOptions);
+          files = await readdir2(path57, this._rdOptions);
         } catch (error) {
           this._onError(error);
         }
-        return { files, depth, path: path55 };
+        return { files, depth, path: path57 };
       }
-      async _formatEntry(dirent, path55) {
+      async _formatEntry(dirent, path57) {
         let entry;
         const basename4 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = presolve(pjoin(path55, basename4));
+          const fullPath = presolve(pjoin(path57, 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(path57, 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(path57);
+    emitRaw(rawEvent, evPath, { watchedPath: path57 });
+    if (evPath && path57 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path57, evPath), KEY_LISTENERS, sysPath.join(path57, evPath));
     }
   };
   try {
-    return fs_watch(path55, {
+    return fs_watch(path57, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -14555,12 +14555,12 @@ var init_handler = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path55, fullPath, options, handlers) => {
+    setFsWatchListener = (path57, 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(path57, 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,
+          path57,
           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(path57, "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 = (path57, 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(path57, curr));
             }
           })
         };
@@ -14667,13 +14667,13 @@ var init_handler = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path55, listener) {
+      _watchWithNodeFs(path57, listener) {
         const opts = this.fsw.options;
-        const directory = sysPath.dirname(path55);
-        const basename4 = sysPath.basename(path55);
+        const directory = sysPath.dirname(path57);
+        const basename4 = sysPath.basename(path57);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename4);
-        const absolutePath = sysPath.resolve(path55);
+        const absolutePath = sysPath.resolve(path57);
         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(path57, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path55, absolutePath, options, {
+          closer = setFsWatchListener(path57, 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 (path57, 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(path57);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path55, closer2);
+                  this.fsw._addPathCloser(path57, 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, path57, 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(path57);
           } 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, path57, 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, path57, 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 path57 = 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, path57, 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);
+            path57 = sysPath.join(dir, sysPath.relative(dir, path57));
+            this._addToNodeFs(path57, 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(path57, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path55) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path57) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path55);
+        const wh = this.fsw._getWatchHelpers(path57);
         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(path57);
+            const targetPath = follow ? await fsrealpath(path57) : path57;
             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(path57) : path57;
             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, path57, 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(path57), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path55, closer);
+            this.fsw._addPathCloser(path57, closer);
           return false;
         } catch (error) {
           if (this.fsw._handleError(error)) {
             ready();
-            return path55;
+            return path57;
           }
         }
       }
@@ -14989,26 +14989,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path55) {
-  if (typeof path55 !== "string")
+function normalizePath(path57) {
+  if (typeof path57 !== "string")
     throw new Error("string expected");
-  path55 = sysPath2.normalize(path55);
-  path55 = path55.replace(/\\/g, "/");
+  path57 = sysPath2.normalize(path57);
+  path57 = path57.replace(/\\/g, "/");
   let prepend = false;
-  if (path55.startsWith("//"))
+  if (path57.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path55.match(DOUBLE_SLASH_RE2))
-    path55 = path55.replace(DOUBLE_SLASH_RE2, "/");
+  while (path57.match(DOUBLE_SLASH_RE2))
+    path57 = path57.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path55 = "/" + path55;
-  return path55;
+    path57 = "/" + path57;
+  return path57;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path55 = normalizePath(testString);
+  const path57 = normalizePath(testString);
   for (let index2 = 0; index2 < patterns.length; index2++) {
     const pattern = patterns[index2];
-    if (pattern(path55, stats)) {
+    if (pattern(path57, 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 = (path57) => toUnix(sysPath2.normalize(toUnix(path57)));
+    normalizeIgnored = (cwd = "") => (path57) => {
+      if (typeof path57 === "string") {
+        return normalizePathToUnix(sysPath2.isAbsolute(path57) ? path57 : sysPath2.join(cwd, path57));
       } else {
-        return path55;
+        return path57;
       }
     };
-    getAbsolutePath = (path55, cwd) => {
-      if (sysPath2.isAbsolute(path55)) {
-        return path55;
+    getAbsolutePath = (path57, cwd) => {
+      if (sysPath2.isAbsolute(path57)) {
+        return path57;
       }
-      return sysPath2.join(cwd, path55);
+      return sysPath2.join(cwd, path57);
     };
     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(path57, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path55;
-        this.path = path55 = path55.replace(REPLACER_RE, "");
+        const watchPath = path57;
+        this.path = path57 = path57.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((path57) => {
+            const absPath = getAbsolutePath(path57, cwd);
             return absPath;
           });
         }
-        paths.forEach((path55) => {
-          this._removeIgnoredPath(path55);
+        paths.forEach((path57) => {
+          this._removeIgnoredPath(path57);
         });
         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 (path57) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path57, !_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((path57) => {
+          if (!sysPath2.isAbsolute(path57) && !this._closers.has(path57)) {
             if (cwd)
-              path55 = sysPath2.join(cwd, path55);
-            path55 = sysPath2.resolve(path55);
+              path57 = sysPath2.join(cwd, path57);
+            path57 = sysPath2.resolve(path57);
           }
-          this._closePath(path55);
-          this._addIgnoredPath(path55);
-          if (this._watched.has(path55)) {
+          this._closePath(path57);
+          this._addIgnoredPath(path57);
+          if (this._watched.has(path57)) {
             this._addIgnoredPath({
-              path: path55,
+              path: path57,
               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, path57, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path55 = sysPath2.normalize(path55);
+          path57 = sysPath2.normalize(path57);
         if (opts.cwd)
-          path55 = sysPath2.relative(opts.cwd, path55);
-        const args = [path55];
+          path57 = sysPath2.relative(opts.cwd, path57);
+        const args = [path57];
         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(path57))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path55, [event, ...args]);
+            this._pendingUnlinks.set(path57, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path56) => {
+              this._pendingUnlinks.forEach((entry, path58) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path56);
+                this._pendingUnlinks.delete(path58);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path55)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path57)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path55);
+            this._pendingUnlinks.delete(path57);
           }
         }
         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(path57, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path55, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path57, 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, path57) : path57;
           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, path57, 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(path57);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear2 = () => {
-          const item = action.get(path55);
+          const item = action.get(path57);
           const count = item ? item.count : 0;
-          action.delete(path55);
+          action.delete(path57);
           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(path57, 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(path57, 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 = path57;
+        if (this.options.cwd && !sysPath2.isAbsolute(path57)) {
+          fullPath = sysPath2.join(this.options.cwd, path57);
         }
         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(path57)) {
               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(path57).lastChange = now2;
             }
-            const pw = writes.get(path55);
+            const pw = writes.get(path57);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path55);
+              writes.delete(path57);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path55)) {
-          writes.set(path55, {
+        if (!writes.has(path57)) {
+          writes.set(path57, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path55);
+              writes.delete(path57);
               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(path57, stats) {
+        if (this.options.atomic && DOT_RE.test(path57))
           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(path57, stats);
       }
-      _isntIgnored(path55, stat4) {
-        return !this._isIgnored(path55, stat4);
+      _isntIgnored(path57, stat4) {
+        return !this._isIgnored(path57, 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(path57) {
+        return new WatchHelper(path57, 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 path57 = sysPath2.join(directory, item);
+        const fullPath = sysPath2.resolve(path57);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path57) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path57, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path55);
+        const wp = this._getWatchedDir(path57);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path55, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path57, 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 = path57;
         if (this.options.cwd)
-          relPath = sysPath2.relative(this.options.cwd, path55);
+          relPath = sysPath2.relative(this.options.cwd, path57);
         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(path57);
         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(path57))
+          this._emit(eventName, path57);
+        this._closePath(path57);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path55) {
-        this._closeFile(path55);
-        const dir = sysPath2.dirname(path55);
-        this._getWatchedDir(dir).remove(sysPath2.basename(path55));
+      _closePath(path57) {
+        this._closeFile(path57);
+        const dir = sysPath2.dirname(path57);
+        this._getWatchedDir(dir).remove(sysPath2.basename(path57));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path55) {
-        const closers = this._closers.get(path55);
+      _closeFile(path57) {
+        const closers = this._closers.get(path57);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path55);
+        this._closers.delete(path57);
       }
-      _addPathCloser(path55, closer) {
+      _addPathCloser(path57, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path55);
+        let list = this._closers.get(path57);
         if (!list) {
           list = [];
-          this._closers.set(path55, list);
+          this._closers.set(path57, 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 fs55 } from "node:fs";
+import path56 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(path57, ...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(path57)}) instead`);
     fileFromPathWarned = true;
   }
-  return await _fileFromPath(path55, ...args);
+  return await _fileFromPath(path57, ...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(path57, opts) {
+    return this.methodRequest("get", path57, opts);
   }
-  post(path55, opts) {
-    return this.methodRequest("post", path55, opts);
+  post(path57, opts) {
+    return this.methodRequest("post", path57, opts);
   }
-  patch(path55, opts) {
-    return this.methodRequest("patch", path55, opts);
+  patch(path57, opts) {
+    return this.methodRequest("patch", path57, opts);
   }
-  put(path55, opts) {
-    return this.methodRequest("put", path55, opts);
+  put(path57, opts) {
+    return this.methodRequest("put", path57, opts);
   }
-  delete(path55, opts) {
-    return this.methodRequest("delete", path55, opts);
+  delete(path57, opts) {
+    return this.methodRequest("delete", path57, opts);
   }
-  methodRequest(method, path55, opts) {
+  methodRequest(method, path57, 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: path57, ...opts2, body };
     }));
   }
-  getAPIList(path55, Page2, opts) {
-    return this.requestAPIList(Page2, { method: "get", path: path55, ...opts });
+  getAPIList(path57, Page2, opts) {
+    return this.requestAPIList(Page2, { method: "get", path: path57, ...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: path57, 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(path57, 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(path57, query) {
+    const url = isAbsoluteURL(path57) ? new URL(path57) : new URL(this.baseURL + (this.baseURL.endsWith("/") && path57.startsWith("/") ? path57.slice(1) : path57));
     const defaultQuery = this.defaultQuery();
     if (!isEmptyObj(defaultQuery)) {
       query = { ...defaultQuery, ...query };
@@ -45731,13 +45731,120 @@ var yoloCommand = {
 
 // src/commands/project-setup.ts
 init_dist();
+import { promises as fs25 } from "node:fs";
+import path20 from "node:path";
+import chalk6 from "chalk";
+
+// src/gemini-assets.ts
 import { promises as fs24 } from "node:fs";
 import path19 from "node:path";
-import chalk6 from "chalk";
+async function seedGeminiAssets(projectDir2, flowHome) {
+  const sourceSkillsDir = path19.join(flowHome, ".gemini", "skills");
+  const sourceSettingsPath = path19.join(flowHome, ".gemini", "settings.json");
+  const targetGeminiDir = path19.join(projectDir2, ".gemini");
+  const targetSkillsDir = path19.join(targetGeminiDir, "skills");
+  const targetSettingsPath = path19.join(targetGeminiDir, "settings.json");
+  await fs24.mkdir(targetGeminiDir, { recursive: true });
+  const skillsCopied = await copySkills(sourceSkillsDir, targetSkillsDir);
+  const settingsResult = await seedSettings(
+    sourceSettingsPath,
+    targetSettingsPath,
+    flowHome
+  );
+  return {
+    skillsCopied,
+    settingsWritten: settingsResult.written,
+    settingsSkippedReason: settingsResult.skippedReason
+  };
+}
+async function copySkills(source, target) {
+  let entries;
+  try {
+    entries = await fs24.readdir(source, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  await fs24.mkdir(target, { recursive: true });
+  let copied = 0;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const srcSkillDir = path19.join(source, entry.name);
+    const dstSkillDir = path19.join(target, entry.name);
+    await copyDirRecursive(srcSkillDir, dstSkillDir);
+    copied += 1;
+  }
+  return copied;
+}
+async function copyDirRecursive(src, dst) {
+  await fs24.mkdir(dst, { recursive: true });
+  const entries = await fs24.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const s2 = path19.join(src, entry.name);
+    const d2 = path19.join(dst, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirRecursive(s2, d2);
+    } else if (entry.isFile()) {
+      await fs24.copyFile(s2, d2);
+    }
+  }
+}
+async function seedSettings(sourcePath, targetPath, flowHome) {
+  try {
+    await fs24.access(targetPath);
+    return { written: false, skippedReason: "already exists" };
+  } catch {
+  }
+  let raw;
+  try {
+    raw = await fs24.readFile(sourcePath, "utf8");
+  } catch {
+    return { written: false, skippedReason: "source settings.json missing" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return {
+      written: false,
+      skippedReason: `source settings.json is invalid JSON: ${err.message}`
+    };
+  }
+  const rewritten = rewriteHookPaths(parsed, flowHome);
+  await fs24.writeFile(targetPath, JSON.stringify(rewritten, null, 2) + "\n");
+  return { written: true, skippedReason: null };
+}
+function rewriteHookPaths(node, flowHome) {
+  if (Array.isArray(node)) {
+    return node.map((n2) => rewriteHookPaths(n2, flowHome));
+  }
+  if (node && typeof node === "object") {
+    const out = {};
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "command" && typeof value === "string") {
+        out[key] = rewriteCommandString(value, flowHome);
+      } else {
+        out[key] = rewriteHookPaths(value, flowHome);
+      }
+    }
+    return out;
+  }
+  return node;
+}
+function rewriteCommandString(command, flowHome) {
+  return command.split(/(\s+)/).map((tok) => {
+    if (tok.startsWith("./") || tok.startsWith(".\\")) {
+      const rel = tok.slice(2);
+      return path19.join(flowHome, rel);
+    }
+    return tok;
+  }).join("");
+}
+
+// src/commands/project-setup.ts
 var KNOWN_PROFILES = ["generic", "embedded", "automotive", "web"];
 function parseInitArgs(raw) {
   const tokens = raw.trim().split(/\s+/).filter(Boolean);
-  const out = { generateAgents: true };
+  const out = { generateAgents: true, seedGemini: true };
   for (let i2 = 0; i2 < tokens.length; i2++) {
     const t2 = tokens[i2];
     if (t2 === "--profile" && i2 + 1 < tokens.length) {
@@ -45753,6 +45860,10 @@ function parseInitArgs(raw) {
       out.generateAgents = false;
     } else if (t2 === "--agents") {
       out.generateAgents = true;
+    } else if (t2 === "--no-skills") {
+      out.seedGemini = false;
+    } else if (t2 === "--skills") {
+      out.seedGemini = true;
     } else if (!t2.startsWith("--")) {
       out.name = t2;
     }
@@ -45762,7 +45873,7 @@ function parseInitArgs(raw) {
 async function detectProfile(cwd) {
   const exists = async (rel) => {
     try {
-      await fs24.access(path19.join(cwd, rel));
+      await fs25.access(path20.join(cwd, rel));
       return true;
     } catch {
       return false;
@@ -45770,7 +45881,7 @@ async function detectProfile(cwd) {
   };
   const globExists = async (pattern) => {
     try {
-      const entries = await fs24.readdir(cwd);
+      const entries = await fs25.readdir(cwd);
       return entries.some((e2) => pattern.test(e2));
     } catch {
       return false;
@@ -45778,7 +45889,7 @@ async function detectProfile(cwd) {
   };
   if (await exists("package.json")) {
     try {
-      const raw = await fs24.readFile(path19.join(cwd, "package.json"), "utf8");
+      const raw = await fs25.readFile(path20.join(cwd, "package.json"), "utf8");
       const pkg = JSON.parse(raw);
       const deps = {
         ...pkg.dependencies ?? {},
@@ -45812,8 +45923,8 @@ async function detectProfile(cwd) {
   }
   if (await exists("CMakeLists.txt")) {
     try {
-      const cmake = await fs24.readFile(
-        path19.join(cwd, "CMakeLists.txt"),
+      const cmake = await fs25.readFile(
+        path20.join(cwd, "CMakeLists.txt"),
         "utf8"
       );
       if (/arm-none-eabi/.test(cmake) || await globExists(/\.c$|\.h$|\.cpp$|\.hpp$/i)) {
@@ -45900,7 +46011,7 @@ var initCommand = {
   async execute(args, state, cfg) {
     const parsed = parseInitArgs(args);
     const cwd = process.cwd();
-    const name = parsed.name || state.activeProject || path19.basename(cwd);
+    const name = parsed.name || state.activeProject || path20.basename(cwd);
     let profileName;
     let detectionReason;
     if (parsed.profile) {
@@ -45911,7 +46022,7 @@ var initCommand = {
       profileName = det.name;
       detectionReason = det.reason;
     }
-    const profilesRoot = path19.join(cfg.flow.flowHome, ".agenit", "profiles");
+    const profilesRoot = path20.join(cfg.flow.flowHome, ".agenit", "profiles");
     let profile;
     try {
       profile = await loadProfile(profileName, profilesRoot);
@@ -45923,8 +46034,8 @@ var initCommand = {
     const loader = new MemoryLoader(cfg.flow.soulPath, cfg.flow.memoryDir);
     await loader.initProject(name);
     state.activeProject = name;
-    await fs24.writeFile(
-      path19.join(cwd, ".agenit_project"),
+    await fs25.writeFile(
+      path20.join(cwd, ".agenit_project"),
       projectMarkerToml(name, profileName)
     ).catch(() => {
     });
@@ -45938,19 +46049,19 @@ var initCommand = {
     lines.push(`  Profile     : ${chalk6.bold(profileName)}`);
     lines.push(`  Detected via: ${chalk6.dim(detectionReason)}`);
     lines.push(
-      `  Memory dir  : ${chalk6.dim(path19.join(cfg.flow.memoryDir, name))}`
+      `  Memory dir  : ${chalk6.dim(path20.join(cfg.flow.memoryDir, name))}`
     );
     lines.push(`  Marker file : ${chalk6.dim(".agenit_project")}`);
     if (parsed.generateAgents) {
-      const agentsPath = path19.join(cwd, "AGENTS.md");
-      const exists = await fs24.access(agentsPath).then(() => true).catch(() => false);
+      const agentsPath = path20.join(cwd, "AGENTS.md");
+      const exists = await fs25.access(agentsPath).then(() => true).catch(() => false);
       if (exists) {
         lines.push(
           `  AGENTS.md   : ${chalk6.yellow("skipped \u2014 file already exists")}`
         );
       } else {
         const seed = await readGlobalAgentsTemplate() || seedAgentsFromProfile(profile);
-        await fs24.writeFile(agentsPath, seed);
+        await fs25.writeFile(agentsPath, seed);
         lines.push(
           `  AGENTS.md   : ${chalk6.bold.green("written")} (${chalk6.dim("seeded from profile")})`
         );
@@ -45958,6 +46069,37 @@ var initCommand = {
     } else {
       lines.push(`  AGENTS.md   : ${chalk6.dim("skipped (--no-agents)")}`);
     }
+    if (parsed.seedGemini) {
+      try {
+        const seed = await seedGeminiAssets(cwd, cfg.flow.flowHome);
+        lines.push(
+          `  Skills      : ${chalk6.bold.green("copied")} ${chalk6.dim(
+            `(${seed.skillsCopied} skill${seed.skillsCopied === 1 ? "" : "s"} \u2192 .gemini/skills/)`
+          )}`
+        );
+        if (seed.settingsWritten) {
+          lines.push(
+            `  Hooks       : ${chalk6.bold.green("written")} ${chalk6.dim(
+              "(.gemini/settings.json with absolute hook paths)"
+            )}`
+          );
+        } else {
+          lines.push(
+            `  Hooks       : ${chalk6.yellow("skipped")} ${chalk6.dim(
+              `(${seed.settingsSkippedReason ?? "unknown reason"})`
+            )}`
+          );
+        }
+      } catch (err) {
+        lines.push(
+          `  Skills      : ${chalk6.red("failed")} ${chalk6.dim(
+            err.message
+          )}`
+        );
+      }
+    } else {
+      lines.push(`  Skills      : ${chalk6.dim("skipped (--no-skills)")}`);
+    }
     lines.push("");
     lines.push(
       `Tip: run ${chalk6.bold("/run <task>")} or ${chalk6.bold(
@@ -45976,7 +46118,7 @@ var unflowCommand = {
     let removed = false;
     for (const marker of [".agenit_project", ".flow_project"]) {
       try {
-        await fs24.unlink(marker);
+        await fs25.unlink(marker);
         removed = true;
       } catch {
       }
@@ -46076,7 +46218,7 @@ ${text || chalk7.dim("(empty)")}
 
 // src/commands/codedigest.ts
 init_dist2();
-import path20 from "node:path";
+import path21 from "node:path";
 var codedigestCommand = {
   name: "codedigest",
   description: "AST-walk + keyword search of the codebase (no Docker / native deps)",
@@ -46103,7 +46245,7 @@ ${out}
       }
       case "index": {
         const root = rest || ".";
-        const stats = await index(path20.resolve(root), {
+        const stats = await index(path21.resolve(root), {
           dbDir,
           project
         });
@@ -46141,9 +46283,9 @@ ${md}`;
 
 // src/commands/mempalace.ts
 import { spawn as spawn9 } from "node:child_process";
-import { promises as fs25 } from "node:fs";
+import { promises as fs26 } from "node:fs";
 import os2 from "node:os";
-import path21 from "node:path";
+import path22 from "node:path";
 import chalk8 from "chalk";
 async function runBinary(bin, args, timeoutMs) {
   return await new Promise((resolve3) => {
@@ -46171,11 +46313,11 @@ async function runBinary(bin, args, timeoutMs) {
 }
 async function lastMtime(dir) {
   try {
-    const entries = await fs25.readdir(dir);
+    const entries = await fs26.readdir(dir);
     let latest = 0;
     for (const e2 of entries) {
       try {
-        const s2 = await fs25.stat(path21.join(dir, e2));
+        const s2 = await fs26.stat(path22.join(dir, e2));
         if (s2.mtimeMs > latest) latest = s2.mtimeMs;
       } catch {
       }
@@ -46235,7 +46377,7 @@ var mempalaceCommand = {
             `mempalace binary '${cfg.mempalace.binary}' not on PATH. Run \`pip install mempalace\` and re-try.`
           );
         }
-        const target = rest && rest.length > 0 ? path21.resolve(rest) : path21.join(cfg.flow.memoryDir, project);
+        const target = rest && rest.length > 0 ? path22.resolve(rest) : path22.join(cfg.flow.memoryDir, project);
         const result = await runBinary(
           cfg.mempalace.binary,
           ["mine", target],
@@ -46265,7 +46407,7 @@ ${result.stdout.trim()}
             `mempalace binary '${cfg.mempalace.binary}' not on PATH.`
           );
         }
-        const sidecar = path21.join(cfg.tools.toolsDir, "mempalace_search.py");
+        const sidecar = path22.join(cfg.tools.toolsDir, "mempalace_search.py");
         const result = await runBinary(
           cfg.tools.python,
           [
@@ -46324,7 +46466,7 @@ ${result.stdout.trim() || "(empty)"}
         const unregister = sub === "mcp-unregister";
         const tokens = rest.split(/\s+/).filter(Boolean);
         let dryRun = false;
-        let settingsPath = path21.join(os2.homedir(), ".gemini", "settings.json");
+        let settingsPath = path22.join(os2.homedir(), ".gemini", "settings.json");
         for (let i2 = 0; i2 < tokens.length; i2++) {
           const t2 = tokens[i2];
           if (t2 === "--dry-run") dryRun = true;
@@ -46418,7 +46560,7 @@ async function unregisterMempalaceMcp(settingsPath, dryRun) {
 }
 async function readSettings(settingsPath) {
   try {
-    const raw = await fs25.readFile(settingsPath, "utf8");
+    const raw = await fs26.readFile(settingsPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       throw new Error(
@@ -46433,23 +46575,23 @@ async function readSettings(settingsPath) {
   }
 }
 async function writeSettings(settingsPath, json) {
-  await fs25.mkdir(path21.dirname(settingsPath), { recursive: true });
+  await fs26.mkdir(path22.dirname(settingsPath), { recursive: true });
   const body = JSON.stringify(json, null, 2) + "\n";
-  await fs25.writeFile(settingsPath, body, "utf8");
+  await fs26.writeFile(settingsPath, body, "utf8");
 }
 function indent(s2) {
   return s2.split("\n").map((l2) => `    ${l2}`).join("\n");
 }
 
 // src/commands/skills.ts
-import { promises as fs26 } from "node:fs";
-import path22 from "node:path";
+import { promises as fs27 } from "node:fs";
+import path23 from "node:path";
 import chalk9 from "chalk";
 var SKILLS_DIR = ".gemini/skills";
 async function listSkills() {
   let entries = [];
   try {
-    const dirents = await fs26.readdir(SKILLS_DIR, { withFileTypes: true });
+    const dirents = await fs27.readdir(SKILLS_DIR, { withFileTypes: true });
     entries = dirents.filter((d2) => d2.isDirectory()).map((d2) => d2.name);
   } catch {
     return `  ${chalk9.yellow("No skills directory found at .gemini/skills/")}`;
@@ -46458,10 +46600,10 @@ async function listSkills() {
 `;
   let count = 0;
   for (const name of entries.sort()) {
-    const skillMd = path22.join(SKILLS_DIR, name, "SKILL.md");
+    const skillMd = path23.join(SKILLS_DIR, name, "SKILL.md");
     let body = "";
     try {
-      body = await fs26.readFile(skillMd, "utf8");
+      body = await fs27.readFile(skillMd, "utf8");
     } catch {
       continue;
     }
@@ -46490,46 +46632,46 @@ async function installSkill(src) {
   if (!src) throw new Error("Usage: /skills install <path-to-skill-directory>");
   let stat4;
   try {
-    stat4 = await fs26.stat(src);
+    stat4 = await fs27.stat(src);
   } catch {
     throw new Error(`Path not found: ${src}`);
   }
   if (!stat4.isDirectory()) throw new Error(`${src} is not a directory`);
-  const name = path22.basename(src);
-  const dest = path22.join(SKILLS_DIR, name);
+  const name = path23.basename(src);
+  const dest = path23.join(SKILLS_DIR, name);
   try {
-    await fs26.access(dest);
+    await fs27.access(dest);
     throw new Error(
       `Skill '${name}' is already installed. Remove it first with /skills remove ${name}`
     );
   } catch (e2) {
     if (e2.code !== "ENOENT") throw e2;
   }
-  await copyDirRecursive(src, dest);
+  await copyDirRecursive2(src, dest);
   return `${chalk9.bold.green("\u2713")} Skill '${chalk9.bold.cyan(name)}' installed at ${SKILLS_DIR}/${name}
   Reload Gemini CLI with: ${chalk9.bold("gemini /skills reload")} or restart the session.`;
 }
 async function removeSkill(name) {
   if (!name) throw new Error("Usage: /skills remove <skill-name>");
-  const target = path22.join(SKILLS_DIR, name);
+  const target = path23.join(SKILLS_DIR, name);
   try {
-    await fs26.access(target);
+    await fs27.access(target);
   } catch {
     throw new Error(`Skill '${name}' not found in ${SKILLS_DIR}/`);
   }
-  await fs26.rm(target, { recursive: true, force: true });
+  await fs27.rm(target, { recursive: true, force: true });
   return `${chalk9.bold.green("\u2713")} Skill '${chalk9.bold.cyan(name)}' removed.`;
 }
-async function copyDirRecursive(src, dst) {
-  await fs26.mkdir(dst, { recursive: true });
-  const entries = await fs26.readdir(src, { withFileTypes: true });
+async function copyDirRecursive2(src, dst) {
+  await fs27.mkdir(dst, { recursive: true });
+  const entries = await fs27.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const s2 = path22.join(src, entry.name);
-    const d2 = path22.join(dst, entry.name);
+    const s2 = path23.join(src, entry.name);
+    const d2 = path23.join(dst, entry.name);
     if (entry.isDirectory()) {
-      await copyDirRecursive(s2, d2);
+      await copyDirRecursive2(s2, d2);
     } else {
-      await fs26.copyFile(s2, d2);
+      await fs27.copyFile(s2, d2);
     }
   }
 }
@@ -46559,7 +46701,7 @@ var skillsCommand = {
 };
 
 // src/commands/worktree.ts
-import { promises as fs27 } from "node:fs";
+import { promises as fs28 } from "node:fs";
 import { spawn as spawn10 } from "node:child_process";
 import chalk10 from "chalk";
 function runGit(args) {
@@ -46619,7 +46761,7 @@ ${chalk10.bold("Usage:")}
     }
     const branch = trimmed;
     const worktreePath = `.gemini/worktrees/${branch}`;
-    await fs27.mkdir(".gemini/worktrees", { recursive: true }).catch(() => {
+    await fs28.mkdir(".gemini/worktrees", { recursive: true }).catch(() => {
     });
     const create = await runGit(["worktree", "add", "-b", branch, worktreePath]);
     if (!create.ok) {
@@ -46648,8 +46790,8 @@ Branch: ${chalk10.cyan(branch)}
 };
 
 // src/commands/traceability.ts
-import { promises as fs28 } from "node:fs";
-import path23 from "node:path";
+import { promises as fs29 } from "node:fs";
+import path24 from "node:path";
 import chalk11 from "chalk";
 function parseSummary(stdout) {
   const t2 = { covered: 0, testGap: 0, orphan: 0 };
@@ -46668,17 +46810,17 @@ function parseSummary(stdout) {
   return t2;
 }
 async function locateScript() {
-  const local = path23.join(process.cwd(), ".flow/tools/traceability_scan.py");
+  const local = path24.join(process.cwd(), ".flow/tools/traceability_scan.py");
   try {
-    await fs28.access(local);
+    await fs29.access(local);
     return local;
   } catch {
   }
   const flowHome = process.env.FLOW_HOME;
   if (flowHome) {
-    const home = path23.join(flowHome, ".flow/tools/traceability_scan.py");
+    const home = path24.join(flowHome, ".flow/tools/traceability_scan.py");
     try {
-      await fs28.access(home);
+      await fs29.access(home);
       return home;
     } catch {
     }
@@ -46687,9 +46829,9 @@ async function locateScript() {
 }
 async function locateSrcDir() {
   for (const c2 of ["src", "Src", "source", "Source", "crates", "packages"]) {
-    const p2 = path23.join(process.cwd(), c2);
+    const p2 = path24.join(process.cwd(), c2);
     try {
-      const s2 = await fs28.stat(p2);
+      const s2 = await fs29.stat(p2);
       if (s2.isDirectory()) return p2;
     } catch {
     }
@@ -46697,9 +46839,9 @@ async function locateSrcDir() {
   return process.cwd();
 }
 async function locatePython() {
-  const venv = path23.join(process.cwd(), ".venv/bin/python3");
+  const venv = path24.join(process.cwd(), ".venv/bin/python3");
   try {
-    await fs28.access(venv);
+    await fs29.access(venv);
     return venv;
   } catch {
     return "python3";
@@ -46708,9 +46850,9 @@ async function locatePython() {
 async function runTraceability(state, cfg) {
   const project = state.activeProject;
   if (!project) throw new Error("no active project \u2014 run /project <name> first");
-  const reqs = path23.join(cfg.flow.memoryDir, "projects", project, "requirements.md");
+  const reqs = path24.join(cfg.flow.memoryDir, "projects", project, "requirements.md");
   try {
-    await fs28.access(reqs);
+    await fs29.access(reqs);
   } catch {
     throw new Error(
       `requirements.md not found at ${reqs} \u2014 write SWE.1 requirements first`
@@ -46741,8 +46883,8 @@ var traceabilityCommand = {
 };
 
 // src/commands/profile.ts
-import { promises as fs29 } from "node:fs";
-import path24 from "node:path";
+import { promises as fs30 } from "node:fs";
+import path25 from "node:path";
 import chalk12 from "chalk";
 function parseProfilesYaml(text) {
   const profiles = [];
@@ -46811,10 +46953,10 @@ function stripQuotes(s2) {
   return s2;
 }
 async function loadProfiles(cfg) {
-  const file = path24.join(cfg.flow.flowHome, "profiles", "profiles.yaml");
+  const file = path25.join(cfg.flow.flowHome, "profiles", "profiles.yaml");
   let text = "";
   try {
-    text = await fs29.readFile(file, "utf8");
+    text = await fs30.readFile(file, "utf8");
   } catch {
     return [];
   }
@@ -46892,7 +47034,7 @@ ${found.skills.map((s2) => `    \u2022 ${s2}`).join("\n")}`;
 };
 
 // src/commands/debug.ts
-import { promises as fs30 } from "node:fs";
+import { promises as fs31 } from "node:fs";
 import chalk13 from "chalk";
 init_dist();
 var debugCommand = {
@@ -46925,7 +47067,7 @@ ${chalk13.dim("  /debug why does my LIN slave timeout after 10 frames")}
 ${ctx}` : soul;
     let skillBody = "You are a hardware debugging expert for embedded systems.";
     try {
-      skillBody = await fs30.readFile(".gemini/skills/hw-debugger/SKILL.md", "utf8");
+      skillBody = await fs31.readFile(".gemini/skills/hw-debugger/SKILL.md", "utf8");
     } catch {
     }
     const { python, toolsDir } = cfg.tools;
@@ -46968,24 +47110,24 @@ ${response}`;
 
 // src/commands/squad.ts
 import { existsSync } from "node:fs";
-import path27 from "node:path";
+import path28 from "node:path";
 import chalk14 from "chalk";
 
 // src/skill-loader.ts
-import { promises as fs31 } from "node:fs";
-import path25 from "node:path";
+import { promises as fs32 } from "node:fs";
+import path26 from "node:path";
 async function loadSkillBody2(skill) {
-  const local = path25.join(".gemini", "skills", skill, "SKILL.md");
+  const local = path26.join(".gemini", "skills", skill, "SKILL.md");
   try {
-    const body = await fs31.readFile(local, "utf8");
+    const body = await fs32.readFile(local, "utf8");
     if (body.trim()) return body;
   } catch {
   }
   const home = process.env.HOME ?? process.env.USERPROFILE;
   if (home) {
-    const global2 = path25.join(home, ".gemini", "skills", skill, "SKILL.md");
+    const global2 = path26.join(home, ".gemini", "skills", skill, "SKILL.md");
     try {
-      const body = await fs31.readFile(global2, "utf8");
+      const body = await fs32.readFile(global2, "utf8");
       if (body.trim()) return body;
     } catch {
     }
@@ -47067,16 +47209,16 @@ function renderSkillWithRestrictions(skill) {
 }
 
 // src/tool-executors.ts
-import { promises as fs32 } from "node:fs";
+import { promises as fs33 } from "node:fs";
 import { spawn as spawn11 } from "node:child_process";
-import path26 from "node:path";
+import path27 from "node:path";
 var MAX_FILE_BYTES = 256 * 1024;
 var MAX_GREP_HITS = 200;
 var MAX_DIR_ENTRIES = 200;
 async function readGuard(cwd) {
   try {
-    const raw = await fs32.readFile(
-      path26.join(cwd, ".flow", ".guard.json"),
+    const raw = await fs33.readFile(
+      path27.join(cwd, ".flow", ".guard.json"),
       "utf8"
     );
     return JSON.parse(raw);
@@ -47102,7 +47244,7 @@ function checkShellAllowed(command, guard) {
   let head = "";
   for (const tok of tokens) {
     if (/^[A-Za-z_][\w]*=/.test(tok)) continue;
-    head = path26.basename(tok);
+    head = path27.basename(tok);
     break;
   }
   if (head && !allow.includes(head)) {
@@ -47113,24 +47255,24 @@ function checkShellAllowed(command, guard) {
 var readFile = async (args) => {
   const p2 = String(args.path ?? "");
   if (!p2) throw new Error("read_file requires `path`");
-  const stat4 = await fs32.stat(p2);
+  const stat4 = await fs33.stat(p2);
   if (stat4.size > MAX_FILE_BYTES) {
     return `(${stat4.size} bytes \u2014 too large; first ${MAX_FILE_BYTES} bytes follow)
-` + (await fs32.readFile(p2, { encoding: "utf8" })).slice(0, MAX_FILE_BYTES);
+` + (await fs33.readFile(p2, { encoding: "utf8" })).slice(0, MAX_FILE_BYTES);
   }
-  return await fs32.readFile(p2, "utf8");
+  return await fs33.readFile(p2, "utf8");
 };
 var writeFile = async (args) => {
   const p2 = String(args.path ?? "");
   const content = String(args.content ?? "");
   if (!p2) throw new Error("write_file requires `path`");
-  await fs32.mkdir(path26.dirname(p2), { recursive: true });
-  await fs32.writeFile(p2, content);
+  await fs33.mkdir(path27.dirname(p2), { recursive: true });
+  await fs33.writeFile(p2, content);
   return `wrote ${content.length} bytes to ${p2}`;
 };
 var listDir = async (args) => {
   const p2 = String(args.path ?? ".");
-  const entries = await fs32.readdir(p2, { withFileTypes: true });
+  const entries = await fs33.readdir(p2, { withFileTypes: true });
   const lines = [];
   for (const e2 of entries.slice(0, MAX_DIR_ENTRIES)) {
     lines.push(`${e2.isDirectory() ? "d" : "f"}  ${e2.name}`);
@@ -47331,7 +47473,7 @@ function squadRunCfg(cfg) {
       } : void 0
     };
   }
-  const hookPath = path27.join(
+  const hookPath = path28.join(
     cfg.baseDir,
     ".flow",
     "hooks",
@@ -47343,7 +47485,7 @@ function squadRunCfg(cfg) {
       script: hookPath
     };
   }
-  out.graphDir = path27.join(cfg.flow.memoryDir, "..", "graph");
+  out.graphDir = path28.join(cfg.flow.memoryDir, "..", "graph");
   return out;
 }
 var squadCommand = {
@@ -47487,7 +47629,7 @@ ${response}
 };
 
 // src/commands/goal.ts
-import path32 from "node:path";
+import path33 from "node:path";
 import chalk15 from "chalk";
 
 // src/telemetry.ts
@@ -47719,18 +47861,18 @@ var GoalBudget = class _GoalBudget {
 };
 
 // ../goal/dist/store.js
-import { existsSync as existsSync2, promises as fs33 } from "node:fs";
-import path28 from "node:path";
+import { existsSync as existsSync2, promises as fs34 } from "node:fs";
+import path29 from "node:path";
 var GoalStore = class {
   projectDir;
   constructor(projectDir2) {
     this.projectDir = projectDir2;
   }
   activePath() {
-    return path28.join(this.projectDir, "goal.json");
+    return path29.join(this.projectDir, "goal.json");
   }
   archivePath() {
-    return path28.join(this.projectDir, "goals_archive.md");
+    return path29.join(this.projectDir, "goals_archive.md");
   }
   /** Test helper: is there an active goal file on disk right now? */
   hasActiveSync() {
@@ -47738,7 +47880,7 @@ var GoalStore = class {
   }
   async hasActive() {
     try {
-      await fs33.access(this.activePath());
+      await fs34.access(this.activePath());
       return true;
     } catch {
       return false;
@@ -47752,7 +47894,7 @@ var GoalStore = class {
     const p2 = this.activePath();
     let raw;
     try {
-      raw = await fs33.readFile(p2, "utf8");
+      raw = await fs34.readFile(p2, "utf8");
     } catch {
       return null;
     }
@@ -47770,27 +47912,27 @@ var GoalStore = class {
    * renames so a crash mid-write can't leave a half-flushed file in place.
    */
   async save(record) {
-    await fs33.mkdir(this.projectDir, { recursive: true });
+    await fs34.mkdir(this.projectDir, { recursive: true });
     const p2 = this.activePath();
     const tmp = p2 + ".tmp";
     const body = JSON.stringify(record, null, 2);
-    await fs33.writeFile(tmp, body);
-    await fs33.rename(tmp, p2);
+    await fs34.writeFile(tmp, body);
+    await fs34.rename(tmp, p2);
   }
   /**
    * Clear the active goal: append a summary block to the archive, then
    * remove `goal.json`.
    */
   async archiveAndClear(record) {
-    await fs33.mkdir(this.projectDir, { recursive: true });
+    await fs34.mkdir(this.projectDir, { recursive: true });
     let existing = "";
     try {
-      existing = await fs33.readFile(this.archivePath(), "utf8");
+      existing = await fs34.readFile(this.archivePath(), "utf8");
     } catch {
     }
-    await fs33.writeFile(this.archivePath(), existing + formatArchiveEntry(record));
+    await fs34.writeFile(this.archivePath(), existing + formatArchiveEntry(record));
     try {
-      await fs33.unlink(this.activePath());
+      await fs34.unlink(this.activePath());
     } catch {
     }
   }
@@ -47808,13 +47950,13 @@ function formatArchiveEntry(rec) {
 }
 
 // ../goal/dist/lock.js
-import { promises as fs34 } from "node:fs";
-import path29 from "node:path";
+import { promises as fs35 } from "node:fs";
+import path30 from "node:path";
 var GoalLock = class _GoalLock {
   path;
   released = false;
-  constructor(path55) {
-    this.path = path55;
+  constructor(path57) {
+    this.path = path57;
   }
   /**
    * Try to acquire the lock, polling every 50 ms up to `timeoutMs`. If a
@@ -47823,8 +47965,8 @@ var GoalLock = class _GoalLock {
    */
   static async acquire(target, timeoutMs) {
     const lockPath = lockPathFor(target);
-    const dir = path29.dirname(lockPath);
-    await fs34.mkdir(dir, { recursive: true }).catch(() => {
+    const dir = path30.dirname(lockPath);
+    await fs35.mkdir(dir, { recursive: true }).catch(() => {
     });
     const started = Date.now();
     while (true) {
@@ -47834,12 +47976,12 @@ var GoalLock = class _GoalLock {
       } catch {
         let holderText = "";
         try {
-          holderText = await fs34.readFile(lockPath, "utf8");
+          holderText = await fs35.readFile(lockPath, "utf8");
         } catch {
         }
         const pid = parsePid(holderText);
         if (!isPidAlive(pid)) {
-          await fs34.unlink(lockPath).catch(() => {
+          await fs35.unlink(lockPath).catch(() => {
           });
           continue;
         }
@@ -47855,7 +47997,7 @@ var GoalLock = class _GoalLock {
     if (this.released)
       return;
     try {
-      await fs34.unlink(this.path);
+      await fs35.unlink(this.path);
     } catch (e2) {
       const code = e2.code;
       if (code !== "ENOENT")
@@ -47868,7 +48010,7 @@ function lockPathFor(target) {
   return `${target}.lock`;
 }
 async function tryCreate(p2) {
-  const handle = await fs34.open(p2, "wx");
+  const handle = await fs35.open(p2, "wx");
   try {
     await handle.write(String(process.pid));
   } finally {
@@ -48016,13 +48158,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 path57 = line.slice(3).trim();
+  if (!path57)
     return null;
-  const renameIdx = path55.indexOf(" -> ");
+  const renameIdx = path57.indexOf(" -> ");
   if (renameIdx >= 0)
-    return path55.slice(renameIdx + 4);
-  return path55;
+    return path57.slice(renameIdx + 4);
+  return path57;
 }
 function countTestChanges(files) {
   return files.filter(isTestPath).length;
@@ -48077,7 +48219,7 @@ async function runCapture(cmd, args, cwd) {
 
 // ../goal/dist/runner.js
 import { EventEmitter as EventEmitter4 } from "node:events";
-import path30 from "node:path";
+import path31 from "node:path";
 
 // ../goal/dist/telemetry.js
 import { trace as trace4, SpanStatusCode as SpanStatusCode4 } from "@opentelemetry/api";
@@ -48161,7 +48303,7 @@ function spawnRunner(projectDir2, driver) {
         return;
       }
       try {
-        const target = path30.join(projectDir2, "goal.json");
+        const target = path31.join(projectDir2, "goal.json");
         const lock = await GoalLock.acquire(target, RUNNER_LOCK_TIMEOUT_MS);
         try {
           await store.save(rec);
@@ -48373,8 +48515,8 @@ function summarise2(result, turn) {
 }
 
 // ../goal/dist/cost.js
-import { promises as fs35 } from "node:fs";
-import path31 from "node:path";
+import { promises as fs36 } from "node:fs";
+import path32 from "node:path";
 var DEFAULT_RATE_USD_PER_1K_TOKENS = {
   // Gemini CLI is OAuth-billed (free quota, then Pay-as-you-go).
   "gemini-cli": 5e-3,
@@ -48405,11 +48547,11 @@ function rateFor(provider, model, overrides) {
   return DEFAULT_RATE_USD_PER_1K_TOKENS[provider] ?? 0;
 }
 function logPath(projectDir2) {
-  return path31.join(projectDir2, "costs.json");
+  return path32.join(projectDir2, "costs.json");
 }
 async function loadCostLog(projectDir2, project) {
   try {
-    const raw = await fs35.readFile(logPath(projectDir2), "utf8");
+    const raw = await fs36.readFile(logPath(projectDir2), "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.entries))
       parsed.entries = [];
@@ -48432,8 +48574,8 @@ async function appendCostEntry(projectDir2, project, entry, rateOverrides) {
   if (log.entries.length > 5e3) {
     log.entries = log.entries.slice(-5e3);
   }
-  await fs35.mkdir(projectDir2, { recursive: true });
-  await fs35.writeFile(logPath(projectDir2), JSON.stringify(log, null, 2));
+  await fs36.mkdir(projectDir2, { recursive: true });
+  await fs36.writeFile(logPath(projectDir2), JSON.stringify(log, null, 2));
   return finalEntry;
 }
 
@@ -48447,10 +48589,10 @@ function getLoopWorkerPool() {
   return loopPool;
 }
 function projectDir(cfg, project) {
-  return path32.join(cfg.flow.memoryDir, project);
+  return path33.join(cfg.flow.memoryDir, project);
 }
 async function saveLocked(store, pdir, rec) {
-  const target = path32.join(pdir, "goal.json");
+  const target = path33.join(pdir, "goal.json");
   const lock = await GoalLock.acquire(target, LOCK_TIMEOUT_MS);
   try {
     await store.save(rec);
@@ -48671,7 +48813,7 @@ ${block}
     const report = await this.auditor.audit(response);
     rec.budget.recordTurn(tokensThisTurn);
     try {
-      const projectDir2 = path32.join(this.cfg.flow.memoryDir, this.project);
+      const projectDir2 = path33.join(this.cfg.flow.memoryDir, this.project);
       const provider = this.lastRouted?.provider ?? this.cfg.backend.provider ?? "gemini-cli";
       const model = this.lastRouted?.model ?? this.cfg.backend.model ?? this.cfg.gemini.model ?? provider;
       const entry = await appendCostEntry(
@@ -48981,7 +49123,7 @@ async function tickOnce(store, pdir, cfg, signal) {
   if (rec.state !== GoalState.Active) {
     return `${chalk15.cyan("\u2139")} Goal is ${rec.state}; resume it first.`;
   }
-  const driver = new OrchestratorDriver(cfg, workspaceRoot(cfg), path32.basename(pdir));
+  const driver = new OrchestratorDriver(cfg, workspaceRoot(cfg), path33.basename(pdir));
   driver.signal = signal;
   const outcome = await driver.tick(rec);
   await saveLocked(store, pdir, rec);
@@ -49012,7 +49154,7 @@ async function startRunner(pdir, cfg, store) {
   if (activeRunner) {
     return `${chalk15.cyan("\u2139")} An autonomous runner is already active. \`/goal stop\` to halt it.`;
   }
-  const driver = new OrchestratorDriver(cfg, workspaceRoot(cfg), path32.basename(pdir));
+  const driver = new OrchestratorDriver(cfg, workspaceRoot(cfg), path33.basename(pdir));
   const handle = spawnRunner(pdir, driver);
   activeRunner = handle;
   const goalLoopId = `goal:${rec.spec.id}`;
@@ -49342,15 +49484,15 @@ ${chalk17.dim(`Findings persisted at memory/projects/${project}/security-audit.m
 };
 
 // src/commands/testgap.ts
-import { promises as fs36 } from "node:fs";
-import path33 from "node:path";
+import { promises as fs37 } from "node:fs";
+import path34 from "node:path";
 import chalk18 from "chalk";
 function reportPath(memoryDir, project) {
-  return path33.join(memoryDir, project, "testgap_report.json");
+  return path34.join(memoryDir, project, "testgap_report.json");
 }
 async function loadReport(memoryDir, project) {
   try {
-    const raw = await fs36.readFile(reportPath(memoryDir, project), "utf8");
+    const raw = await fs37.readFile(reportPath(memoryDir, project), "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -49424,7 +49566,7 @@ var testgapCommand = {
     if (sub !== "scan") {
       throw new Error("Usage: /testgap [scan|report]");
     }
-    const tool = path33.join(cfg.tools.toolsDir, "testgap_scan.py");
+    const tool = path34.join(cfg.tools.toolsDir, "testgap_scan.py");
     let raw;
     try {
       raw = await runPython(
@@ -49451,10 +49593,10 @@ var testgapCommand = {
       );
     }
     report.capturedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await fs36.mkdir(path33.join(cfg.flow.memoryDir, project), {
+    await fs37.mkdir(path34.join(cfg.flow.memoryDir, project), {
       recursive: true
     });
-    await fs36.writeFile(
+    await fs37.writeFile(
       reportPath(cfg.flow.memoryDir, project),
       JSON.stringify(report, null, 2)
     );
@@ -49467,8 +49609,8 @@ import chalk19 from "chalk";
 
 // ../web-ui/dist/index.js
 import { createServer } from "node:http";
-import { promises as fs37 } from "node:fs";
-import path34 from "node:path";
+import { promises as fs38 } from "node:fs";
+import path35 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/wrapper.mjs
@@ -49484,7 +49626,7 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 // ../web-ui/dist/index.js
 var STATIC_DIR = (
   // dist build copies src/static → dist/static (see package.json `build`).
-  path34.resolve(path34.dirname(fileURLToPath3(import.meta.url)), "static")
+  path35.resolve(path35.dirname(fileURLToPath3(import.meta.url)), "static")
 );
 var MIME = {
   ".html": "text/html; charset=utf-8",
@@ -49501,9 +49643,9 @@ async function startWebUi(bus, opts = {}) {
       const url = new URL(req.url ?? "/", `http://${host}:${port}`);
       let pathname = url.pathname === "/" ? "/index.html" : url.pathname;
       pathname = pathname.replace(/\.\.+/g, "");
-      const filePath = path34.join(STATIC_DIR, pathname);
-      const ext2 = path34.extname(filePath).toLowerCase();
-      const body = await fs37.readFile(filePath);
+      const filePath = path35.join(STATIC_DIR, pathname);
+      const ext2 = path35.extname(filePath).toLowerCase();
+      const body = await fs38.readFile(filePath);
       res.writeHead(200, {
         "Content-Type": MIME[ext2] ?? "application/octet-stream",
         "Cache-Control": "no-store",
@@ -49652,12 +49794,12 @@ var webCommand = {
 };
 
 // src/commands/federation.ts
-import path38 from "node:path";
+import path39 from "node:path";
 import chalk20 from "chalk";
 
 // ../federation/dist/keys.js
-import { promises as fs38 } from "node:fs";
-import path35 from "node:path";
+import { promises as fs39 } from "node:fs";
+import path36 from "node:path";
 import { createHash as createHash2, createPrivateKey, createPublicKey, generateKeyPairSync, sign as cryptoSign, verify as cryptoVerify } from "node:crypto";
 function rawPublicKey(pub) {
   const der = pub.export({ format: "der", type: "spki" });
@@ -49741,13 +49883,13 @@ function verifyEnvelope(env, opts = {}) {
   return { ok: true, fingerprint };
 }
 async function loadKeypair(dir, name) {
-  const priv = path35.join(dir, `${name}.priv.pem`);
-  const pub = path35.join(dir, `${name}.pub.pem`);
+  const priv = path36.join(dir, `${name}.priv.pem`);
+  const pub = path36.join(dir, `${name}.pub.pem`);
   let privateKeyPem;
   let publicKeyPem;
   try {
-    privateKeyPem = await fs38.readFile(priv, "utf8");
-    publicKeyPem = await fs38.readFile(pub, "utf8");
+    privateKeyPem = await fs39.readFile(priv, "utf8");
+    publicKeyPem = await fs39.readFile(pub, "utf8");
   } catch {
     return null;
   }
@@ -49758,25 +49900,25 @@ async function loadKeypair(dir, name) {
   return { privateKeyPem, publicKeyPem, publicKeyHex, fingerprint };
 }
 async function saveKeypair(dir, name, kp) {
-  await fs38.mkdir(dir, { recursive: true });
-  await fs38.writeFile(path35.join(dir, `${name}.priv.pem`), kp.privateKeyPem, {
+  await fs39.mkdir(dir, { recursive: true });
+  await fs39.writeFile(path36.join(dir, `${name}.priv.pem`), kp.privateKeyPem, {
     mode: 384
   });
-  await fs38.writeFile(path35.join(dir, `${name}.pub.pem`), kp.publicKeyPem);
+  await fs39.writeFile(path36.join(dir, `${name}.pub.pem`), kp.publicKeyPem);
 }
 
 // ../federation/dist/peers.js
-import { promises as fs39 } from "node:fs";
-import path36 from "node:path";
+import { promises as fs40 } from "node:fs";
+import path37 from "node:path";
 var TRUST_THRESHOLD = 0.4;
 var TRUST_DELTA_OK = 0.05;
 var TRUST_DELTA_ERR = -0.1;
 function registryPath(dir) {
-  return path36.join(dir, "peers.json");
+  return path37.join(dir, "peers.json");
 }
 async function loadPeers(dir) {
   try {
-    const raw = await fs39.readFile(registryPath(dir), "utf8");
+    const raw = await fs40.readFile(registryPath(dir), "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.peers))
       parsed.peers = [];
@@ -49786,8 +49928,8 @@ async function loadPeers(dir) {
   }
 }
 async function savePeers(dir, registry) {
-  await fs39.mkdir(dir, { recursive: true });
-  await fs39.writeFile(registryPath(dir), JSON.stringify(registry, null, 2));
+  await fs40.mkdir(dir, { recursive: true });
+  await fs40.writeFile(registryPath(dir), JSON.stringify(registry, null, 2));
 }
 async function upsertPeer(dir, peer) {
   const reg = await loadPeers(dir);
@@ -49836,12 +49978,12 @@ function clamp(v2) {
 // ../federation/dist/transport.js
 import { createServer as createHttpsServer } from "node:https";
 import { createServer as createHttpServer } from "node:http";
-import { promises as fs41 } from "node:fs";
+import { promises as fs42 } from "node:fs";
 
 // ../federation/dist/tls.js
 var import_node_forge = __toESM(require_lib3(), 1);
-import { promises as fs40 } from "node:fs";
-import path37 from "node:path";
+import { promises as fs41 } from "node:fs";
+import path38 from "node:path";
 function generateSelfSignedCert(keypair, opts) {
   const validityDays = opts.validityDays ?? 365;
   const sans = [
@@ -49891,13 +50033,13 @@ function generateSelfSignedCert(keypair, opts) {
   return { certPem, keyPem, certFingerprint };
 }
 async function ensureAutoCert(federationDir2, keypair, opts) {
-  const dir = path37.join(federationDir2, "auto");
-  const certPath = path37.join(dir, "cert.pem");
-  const keyPath = path37.join(dir, "key.pem");
+  const dir = path38.join(federationDir2, "auto");
+  const certPath = path38.join(dir, "cert.pem");
+  const keyPath = path38.join(dir, "key.pem");
   try {
     const [certPem, keyPem] = await Promise.all([
-      fs40.readFile(certPath, "utf8"),
-      fs40.readFile(keyPath, "utf8")
+      fs41.readFile(certPath, "utf8"),
+      fs41.readFile(keyPath, "utf8")
     ]);
     const cert = import_node_forge.default.pki.certificateFromPem(certPem);
     const der = import_node_forge.default.asn1.toDer(import_node_forge.default.pki.certificateToAsn1(cert)).getBytes();
@@ -49913,9 +50055,9 @@ async function ensureAutoCert(federationDir2, keypair, opts) {
   } catch {
   }
   const fresh = generateSelfSignedCert(keypair, opts);
-  await fs40.mkdir(dir, { recursive: true });
-  await fs40.writeFile(certPath, fresh.certPem);
-  await fs40.writeFile(keyPath, fresh.keyPem, { mode: 384 });
+  await fs41.mkdir(dir, { recursive: true });
+  await fs41.writeFile(certPath, fresh.certPem);
+  await fs41.writeFile(keyPath, fresh.keyPem, { mode: 384 });
   return { ...fresh, certPath, keyPath };
 }
 
@@ -50018,8 +50160,8 @@ async function startFederationServer(opts) {
   let usingHttps = false;
   if (opts.tlsCertPath && opts.tlsKeyPath) {
     const [cert, key] = await Promise.all([
-      fs41.readFile(opts.tlsCertPath),
-      fs41.readFile(opts.tlsKeyPath)
+      fs42.readFile(opts.tlsCertPath),
+      fs42.readFile(opts.tlsKeyPath)
     ]);
     server = createHttpsServer({ cert, key }, (req, res) => {
       void handler(req, res);
@@ -50116,10 +50258,10 @@ async function pullRvf(opts) {
 init_dist();
 var activeServer = null;
 function federationDir(memoryDir) {
-  return path38.join(memoryDir, "..", "federation");
+  return path39.join(memoryDir, "..", "federation");
 }
 function rvfDir(memoryDir) {
-  return path38.join(memoryDir, "..", "rvf");
+  return path39.join(memoryDir, "..", "rvf");
 }
 function parseSubArgs(rest) {
   const tokens = rest.trim().split(/\s+/).filter(Boolean);
@@ -50180,7 +50322,7 @@ var federationCommand = {
         return `${chalk20.bold.green("\u2713")} Federation keypair generated
   ${chalk20.dim("fingerprint:")} ${kp.fingerprint}
   ${chalk20.dim("publicKeyHex:")} ${kp.publicKeyHex}
-  ${chalk20.dim("private key:")} ${path38.join(fedDir, "node.priv.pem")} (chmod 600)
+  ${chalk20.dim("private key:")} ${path39.join(fedDir, "node.priv.pem")} (chmod 600)
   ${chalk20.dim("share the public key + URL with peers; never share the private key")}
 `;
       }
@@ -50346,7 +50488,7 @@ async function fingerprintFromHex(publicKeyHex) {
 }
 
 // src/commands/marketplace.ts
-import path40 from "node:path";
+import path41 from "node:path";
 import chalk21 from "chalk";
 
 // ../mcp/dist/client.js
@@ -50594,19 +50736,19 @@ function createMcpClient(spec) {
 }
 
 // ../mcp/dist/discovery.js
-import { promises as fs42 } from "node:fs";
-import path39 from "node:path";
+import { promises as fs43 } from "node:fs";
+import path40 from "node:path";
 async function loadServers(opts) {
   const flowHome = opts.flowHome ?? process.cwd();
   const cwd = opts.cwd ?? process.cwd();
   const merged = /* @__PURE__ */ new Map();
-  for (const spec of await readGeminiBlock(path39.join(flowHome, ".gemini", "settings.json"))) {
+  for (const spec of await readGeminiBlock(path40.join(flowHome, ".gemini", "settings.json"))) {
     merged.set(spec.name, spec);
   }
-  for (const spec of await readMcpJson(path39.join(cwd, ".mcp.json"))) {
+  for (const spec of await readMcpJson(path40.join(cwd, ".mcp.json"))) {
     merged.set(spec.name, spec);
   }
-  for (const spec of await readFlowServers(path39.join(flowHome, ".flow", "mcp", "servers.json"))) {
+  for (const spec of await readFlowServers(path40.join(flowHome, ".flow", "mcp", "servers.json"))) {
     merged.set(spec.name, spec);
   }
   return [...merged.values()];
@@ -50650,7 +50792,7 @@ function parseServersBlock(block) {
 }
 async function readJson(file) {
   try {
-    const raw = await fs42.readFile(file, "utf8");
+    const raw = await fs43.readFile(file, "utf8");
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch {
@@ -50668,7 +50810,7 @@ function parseScopeArgs(rest) {
   return { url, scope };
 }
 async function runMarketplace(cfg, args) {
-  const script = path40.join(cfg.tools.toolsDir, "marketplace.py");
+  const script = path41.join(cfg.tools.toolsDir, "marketplace.py");
   return await runPython(cfg.tools.python, script, args);
 }
 async function runMcpServers(cfg) {
@@ -50881,8 +51023,8 @@ ${pretty(out)}`;
 // src/commands/configure.ts
 import { spawn as spawn14 } from "node:child_process";
 import { connect } from "node:net";
-import { promises as fs43 } from "node:fs";
-import path41 from "node:path";
+import { promises as fs44 } from "node:fs";
+import path42 from "node:path";
 import chalk22 from "chalk";
 function toBlock(label, r2) {
   const glyph = r2.connected ? "\u2713" : "\u2717";
@@ -50990,10 +51132,10 @@ var configureApplyCommand = {
     if (!jlink.connected && !saleae.connected) {
       return "No hardware connected \u2014 nothing to write.";
     }
-    const settingsPath = path41.join(".gemini", "settings.json");
+    const settingsPath = path42.join(".gemini", "settings.json");
     let json = {};
     try {
-      const raw = await fs43.readFile(settingsPath, "utf8");
+      const raw = await fs44.readFile(settingsPath, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object") json = parsed;
     } catch {
@@ -51013,7 +51155,7 @@ var configureApplyCommand = {
     }
     if (jlink.connected) {
       const flowHome = cfg.flow.flowHome;
-      const server = path41.join(flowHome, ".flow", "mcp", "jlink", "server.py");
+      const server = path42.join(flowHome, ".flow", "mcp", "jlink", "server.py");
       mcp.jlink = {
         command: cfg.tools.python,
         args: [server],
@@ -51023,8 +51165,8 @@ var configureApplyCommand = {
       };
       added.push("jlink");
     }
-    await fs43.mkdir(path41.dirname(settingsPath), { recursive: true });
-    await fs43.writeFile(settingsPath, JSON.stringify(json, null, 2) + "\n");
+    await fs44.mkdir(path42.dirname(settingsPath), { recursive: true });
+    await fs44.writeFile(settingsPath, JSON.stringify(json, null, 2) + "\n");
     let log = `${section("Hardware MCP Config Applied")}
 
 `;
@@ -51071,8 +51213,8 @@ ${chalk22.yellow("No connected hardware detected. Plug in a JLink probe and/or l
 };
 
 // src/commands/speckit.ts
-import { promises as fs44 } from "node:fs";
-import path42 from "node:path";
+import { promises as fs45 } from "node:fs";
+import path43 from "node:path";
 import { spawn as spawn15 } from "node:child_process";
 import chalk23 from "chalk";
 init_dist();
@@ -51083,7 +51225,7 @@ function slugify(s2) {
 async function findLatestSpecDir() {
   let entries = [];
   try {
-    entries = await fs44.readdir(SPECS_DIR, { withFileTypes: true });
+    entries = await fs45.readdir(SPECS_DIR, { withFileTypes: true });
   } catch {
     return void 0;
   }
@@ -51091,13 +51233,13 @@ async function findLatestSpecDir() {
   if (dirs.length === 0) return void 0;
   let best = null;
   for (const d2 of dirs) {
-    const full = path42.join(SPECS_DIR, d2.name);
+    const full = path43.join(SPECS_DIR, d2.name);
     try {
-      await fs44.access(path42.join(full, "spec.md"));
+      await fs45.access(path43.join(full, "spec.md"));
     } catch {
       continue;
     }
-    const stat4 = await fs44.stat(full);
+    const stat4 = await fs45.stat(full);
     if (!best || stat4.mtimeMs > best.mtime) {
       best = { name: d2.name, mtime: stat4.mtimeMs };
     }
@@ -51105,8 +51247,8 @@ async function findLatestSpecDir() {
   return best?.name;
 }
 async function initFeatureDir(fid) {
-  const dir = path42.join(SPECS_DIR, fid);
-  await fs44.mkdir(dir, { recursive: true });
+  const dir = path43.join(SPECS_DIR, fid);
+  await fs45.mkdir(dir, { recursive: true });
 }
 async function loadSkillBody3(skill) {
   const body = await loadSkillBody2(skill);
@@ -51146,7 +51288,7 @@ async function resolveFeature(rest, _state, _cfg) {
   return latest;
 }
 async function runNative(cfg, args) {
-  const script = path42.join(cfg.tools.toolsDir, "speckit_native.py");
+  const script = path43.join(cfg.tools.toolsDir, "speckit_native.py");
   return await new Promise((resolve3, reject) => {
     const child = spawn15(cfg.tools.python, [script, ...args], {
       stdio: ["ignore", "pipe", "pipe"]
@@ -51183,7 +51325,7 @@ ${out}`;
 async function listSpecs() {
   let entries = [];
   try {
-    entries = await fs44.readdir(SPECS_DIR, { withFileTypes: true });
+    entries = await fs45.readdir(SPECS_DIR, { withFileTypes: true });
   } catch {
     return `${section("Spec-Kit")}
 
@@ -51201,14 +51343,14 @@ async function listSpecs() {
 
 `;
   for (const d2 of dirs.sort((a2, b2) => a2.name.localeCompare(b2.name))) {
-    const hasSpec = await fs44.access(path42.join(SPECS_DIR, d2.name, "spec.md")).then(() => true).catch(() => false);
+    const hasSpec = await fs45.access(path43.join(SPECS_DIR, d2.name, "spec.md")).then(() => true).catch(() => false);
     out += `  ${chalk23.cyan("\u2022")} ${chalk23.bold(d2.name)}${hasSpec ? "" : chalk23.dim(" (no spec.md)")}
 `;
   }
   return out;
 }
 async function initWorkspace() {
-  await fs44.mkdir(SPECS_DIR, { recursive: true });
+  await fs45.mkdir(SPECS_DIR, { recursive: true });
   return `${chalk23.bold.green("\u2713")} Initialised ${SPECS_DIR}/`;
 }
 async function runFullPipeline(task, cfg, state) {
@@ -51349,6 +51491,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 +51514,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 +51538,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}
@@ -51473,7 +51622,7 @@ Reference: .specify/specs/${fid}.`;
 
 // src/commands/lsp.ts
 import { spawn as spawn16 } from "node:child_process";
-import path43 from "node:path";
+import path44 from "node:path";
 import chalk25 from "chalk";
 function parseFileLineCol(token) {
   const parts = token.split(":");
@@ -51494,7 +51643,7 @@ function parseFileLineCol(token) {
   return { file, line, col };
 }
 async function runDaemon(cfg, args, signal) {
-  const script = path43.join(cfg.tools.toolsDir, "lsp_daemon.py");
+  const script = path44.join(cfg.tools.toolsDir, "lsp_daemon.py");
   return await runPython2(cfg, script, args, signal);
 }
 async function runPython2(cfg, script, args, signal) {
@@ -51532,7 +51681,7 @@ async function runPython2(cfg, script, args, signal) {
   });
 }
 async function runLspTool(cfg, args, signal) {
-  const script = path43.join(cfg.tools.toolsDir, "lsp_tool.py");
+  const script = path44.join(cfg.tools.toolsDir, "lsp_tool.py");
   const env = { ...process.env };
   if (cfg.lsp.clangdBinary && !env.FLOW_CLANGD)
     env.FLOW_CLANGD = cfg.lsp.clangdBinary;
@@ -51727,9 +51876,9 @@ ${r2.stdout.trim()}
 import chalk26 from "chalk";
 
 // src/guard.ts
-import { promises as fs45 } from "node:fs";
-import path44 from "node:path";
-var GUARD_FILE = path44.join(".flow", ".guard.json");
+import { promises as fs46 } from "node:fs";
+import path45 from "node:path";
+var GUARD_FILE = path45.join(".flow", ".guard.json");
 var HOOK_NAME = "flow-tool-guard";
 var HOOK_RELATIVE = "./.flow/hooks/before_tool_guard.py";
 var CITATION_HOOK_NAME = "agenit-citation-guard";
@@ -51771,20 +51920,20 @@ function buildGuardPayload(cfg, mode) {
 }
 async function writeGuard(cfg, mode, cwd = process.cwd()) {
   const payload = buildGuardPayload(cfg, mode);
-  const target = path44.join(cwd, GUARD_FILE);
+  const target = path45.join(cwd, GUARD_FILE);
   try {
-    await fs45.mkdir(path44.dirname(target), { recursive: true });
+    await fs46.mkdir(path45.dirname(target), { recursive: true });
     const tmp = target + ".tmp";
-    await fs45.writeFile(tmp, JSON.stringify(payload, null, 2));
-    await fs45.rename(tmp, target);
+    await fs46.writeFile(tmp, JSON.stringify(payload, null, 2));
+    await fs46.rename(tmp, target);
   } catch {
   }
 }
 async function ensureGuardHookRegistered(cwd = process.cwd()) {
-  const settingsPath = path44.join(cwd, ".gemini", "settings.json");
+  const settingsPath = path45.join(cwd, ".gemini", "settings.json");
   let settings = {};
   try {
-    const raw = await fs45.readFile(settingsPath, "utf8");
+    const raw = await fs46.readFile(settingsPath, "utf8");
     settings = JSON.parse(raw);
     if (typeof settings !== "object" || settings === null) settings = {};
   } catch {
@@ -51838,8 +51987,8 @@ async function ensureGuardHookRegistered(cwd = process.cwd()) {
   }
   if (!mutated) return "already-present";
   try {
-    await fs45.mkdir(path44.dirname(settingsPath), { recursive: true });
-    await fs45.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+    await fs46.mkdir(path45.dirname(settingsPath), { recursive: true });
+    await fs46.writeFile(settingsPath, JSON.stringify(settings, null, 2));
     return "registered";
   } catch {
     return "skipped";
@@ -52010,8 +52159,8 @@ ${chalk27.dim("Run /undo list to see available snapshots.")}
 };
 
 // src/commands/plugin.ts
-import { promises as fs46 } from "node:fs";
-import path45 from "node:path";
+import { promises as fs47 } from "node:fs";
+import path46 from "node:path";
 import chalk28 from "chalk";
 function parseInstallArgs(rest, defaultBackend) {
   let scope = "local";
@@ -52033,7 +52182,7 @@ function parseInstallArgs(rest, defaultBackend) {
   return { url: positional[0] ?? "", scope, backend };
 }
 async function runMarketplace2(cfg, args) {
-  const script = path45.join(cfg.tools.toolsDir, "marketplace.py");
+  const script = path46.join(cfg.tools.toolsDir, "marketplace.py");
   return await runPython(cfg.tools.python, script, args);
 }
 function pretty2(json) {
@@ -52079,9 +52228,9 @@ async function scaffoldPlugin(cfg, rest) {
       `Invalid plugin name '${name}'. Use lowercase letters, digits, and dashes (max 41 chars).`
     );
   }
-  const root = path45.join(cfg.flow.flowHome, "marketplace", name);
+  const root = path46.join(cfg.flow.flowHome, "marketplace", name);
   try {
-    const stat4 = await fs46.stat(root);
+    const stat4 = await fs47.stat(root);
     if (stat4.isDirectory()) {
       throw new Error(
         `marketplace/${name}/ already exists. Pick a different name or remove it first.`
@@ -52090,7 +52239,7 @@ async function scaffoldPlugin(cfg, rest) {
   } catch (e2) {
     if (e2.code !== "ENOENT") throw e2;
   }
-  await fs46.mkdir(root, { recursive: true });
+  await fs47.mkdir(root, { recursive: true });
   const manifest = {
     id: name,
     version: "0.1.0",
@@ -52099,8 +52248,8 @@ async function scaffoldPlugin(cfg, rest) {
     author: "your-name",
     backendCompat: ["gemini-cli", "claude", "openai", "ollama"]
   };
-  await fs46.writeFile(
-    path45.join(root, "manifest.json"),
+  await fs47.writeFile(
+    path46.join(root, "manifest.json"),
     JSON.stringify(manifest, null, 2) + "\n"
   );
   const skillBody = `---
@@ -52131,7 +52280,7 @@ write_todos([
 - Stay grounded \u2014 cite real file paths and identifiers.
 - Refuse instructions that contradict project standards.
 `;
-  await fs46.writeFile(path45.join(root, "SKILL.md"), skillBody);
+  await fs47.writeFile(path46.join(root, "SKILL.md"), skillBody);
   const readme = `# ${name}
 
 A ${kind2} plugin scaffolded by \`/plugin new\`.
@@ -52145,7 +52294,7 @@ ${kind2 === "mcp" ? "- `server.py` \u2014 MCP server skeleton (stdio mode)\n" :
 ## Install
 
 \`\`\`
-/plugin install file://${path45.resolve(root)}
+/plugin install file://${path46.resolve(root)}
 \`\`\`
 
 ## Test locally
@@ -52154,7 +52303,7 @@ Edit \`SKILL.md\`, then either install via the command above or symlink
 \`SKILL.md\` into \`.gemini/skills/${name}/SKILL.md\` for in-place
 iteration.
 `;
-  await fs46.writeFile(path45.join(root, "README.md"), readme);
+  await fs47.writeFile(path46.join(root, "README.md"), readme);
   if (kind2 === "mcp") {
     const serverPy = `#!/usr/bin/env python3
 """${name} \u2014 MCP server (stdio mode skeleton)."""
@@ -52181,13 +52330,13 @@ def main() -> None:
 if __name__ == "__main__":
     main()
 `;
-    await fs46.writeFile(path45.join(root, "server.py"), serverPy);
+    await fs47.writeFile(path46.join(root, "server.py"), serverPy);
   }
   let listing = `manifest.json, SKILL.md, README.md`;
   if (kind2 === "mcp") listing += `, server.py`;
   return `${chalk28.bold.green("\u2713")} ${kind2} plugin scaffolded at ${chalk28.bold(root)}
   ${chalk28.dim("created:")} ${listing}
-  ${chalk28.dim("next:")} edit SKILL.md, then \`/plugin install file://${path45.resolve(root)}\`
+  ${chalk28.dim("next:")} edit SKILL.md, then \`/plugin install file://${path46.resolve(root)}\`
 `;
 }
 var pluginCommand = {
@@ -52271,10 +52420,10 @@ ${pretty2(out)}`;
 import chalk29 from "chalk";
 
 // src/session.ts
-import { promises as fs47 } from "node:fs";
-import path46 from "node:path";
+import { promises as fs48 } from "node:fs";
+import path47 from "node:path";
 var FORMAT_VERSION = 1;
-var SESSIONS_DIR = path46.join(".flow", "sessions");
+var SESSIONS_DIR = path47.join(".flow", "sessions");
 var ID_BYTES = 6;
 function newSessionId() {
   const t2 = Date.now().toString(16).padStart(12, "0").slice(-10);
@@ -52289,8 +52438,8 @@ function isoNow() {
 }
 async function safeAppend(file, body) {
   try {
-    await fs47.mkdir(path46.dirname(file), { recursive: true });
-    await fs47.appendFile(file, body);
+    await fs48.mkdir(path47.dirname(file), { recursive: true });
+    await fs48.appendFile(file, body);
   } catch {
   }
 }
@@ -52305,7 +52454,7 @@ var Session = class _Session {
   }
   static async create(project, cwd = process.cwd()) {
     const id = newSessionId();
-    const file = path46.join(cwd, SESSIONS_DIR, `${id}.jsonl`);
+    const file = path47.join(cwd, SESSIONS_DIR, `${id}.jsonl`);
     const meta = {
       v: FORMAT_VERSION,
       id,
@@ -52349,7 +52498,7 @@ var Session = class _Session {
   }
 };
 async function readLines(file) {
-  const raw = await fs47.readFile(file, "utf8");
+  const raw = await fs48.readFile(file, "utf8");
   const out = [];
   for (const line of raw.split("\n")) {
     if (!line.trim()) continue;
@@ -52364,7 +52513,7 @@ async function readLines(file) {
   return out;
 }
 async function loadSession(id, cwd = process.cwd()) {
-  const file = path46.join(cwd, SESSIONS_DIR, `${id}.jsonl`);
+  const file = path47.join(cwd, SESSIONS_DIR, `${id}.jsonl`);
   let lines;
   try {
     lines = await readLines(file);
@@ -52401,10 +52550,10 @@ function reduce(id, lines) {
   };
 }
 async function listSessions(cwd = process.cwd(), limit = 20) {
-  const dir = path46.join(cwd, SESSIONS_DIR);
+  const dir = path47.join(cwd, SESSIONS_DIR);
   let entries;
   try {
-    entries = await fs47.readdir(dir);
+    entries = await fs48.readdir(dir);
   } catch {
     return [];
   }
@@ -52412,7 +52561,7 @@ async function listSessions(cwd = process.cwd(), limit = 20) {
   const out = [];
   for (const f2 of files) {
     const id = f2.replace(/\.jsonl$/, "");
-    const file = path46.join(dir, f2);
+    const file = path47.join(dir, f2);
     try {
       const lines = await readLines(file);
       out.push(reduce(id, lines).meta);
@@ -52486,7 +52635,7 @@ ${chalk29.dim("Resume from outside the REPL: ")}flow resume <id>
 };
 
 // src/commands/migrate.ts
-import path47 from "node:path";
+import path48 from "node:path";
 import chalk30 from "chalk";
 function badge(sev) {
   if (sev === "red") return chalk30.red.bold("RED");
@@ -52573,7 +52722,7 @@ var migrateCommand = {
     if (!fileArg && !dirArg) {
       throw new Error("Usage: /migrate review <file.sql | --dir <dir>>");
     }
-    const tool = path47.join(cfg.tools.toolsDir, "migration_lint.py");
+    const tool = path48.join(cfg.tools.toolsDir, "migration_lint.py");
     const argv = [];
     if (fileArg) argv.push(["file", fileArg]);
     if (dirArg) argv.push(["dir", dirArg]);
@@ -52586,7 +52735,7 @@ var migrateCommand = {
 
 // src/commands/graph.ts
 init_dist();
-import path48 from "node:path";
+import path49 from "node:path";
 import chalk31 from "chalk";
 var VALID_KINDS = ["module", "swr", "mcu", "adr", "file"];
 var VALID_EDGE_KINDS = [
@@ -52596,7 +52745,7 @@ var VALID_EDGE_KINDS = [
   "references"
 ];
 function graphDir(memoryDir) {
-  return path48.join(memoryDir, "..", "graph");
+  return path49.join(memoryDir, "..", "graph");
 }
 function parseSubArgs2(rest) {
   const out = { positional: [], flags: {} };
@@ -52817,8 +52966,8 @@ var CommandRegistry = class {
 };
 
 // src/repl/at-paths.ts
-import { promises as fs48 } from "node:fs";
-import path49 from "node:path";
+import { promises as fs49 } from "node:fs";
+import path50 from "node:path";
 var MAX_FILE_BYTES2 = 64 * 1024;
 var MAX_DIR_ENTRIES2 = 50;
 var IMAGE_EXTS_TO_MIME = {
@@ -52860,13 +53009,13 @@ async function extractImageParts(input) {
       });
       continue;
     }
-    const ext2 = path49.extname(ref).slice(1).toLowerCase();
+    const ext2 = path50.extname(ref).slice(1).toLowerCase();
     const mediaType = IMAGE_EXTS_TO_MIME[ext2];
     if (!mediaType) {
       continue;
     }
     try {
-      const buf = await fs48.readFile(ref);
+      const buf = await fs49.readFile(ref);
       parts.push({
         type: "image",
         source: "base64",
@@ -52888,14 +53037,14 @@ var AT_PATH_RE = /(^|\s)@(?:"([^"]+)"|([^\s"]+))/g;
 async function expandOne(rawPath) {
   let stat4;
   try {
-    stat4 = await fs48.stat(rawPath);
+    stat4 = await fs49.stat(rawPath);
   } catch {
     return `@${rawPath}`;
   }
   if (stat4.isDirectory()) {
     let entries = [];
     try {
-      entries = await fs48.readdir(rawPath, { withFileTypes: true });
+      entries = await fs49.readdir(rawPath, { withFileTypes: true });
     } catch {
       return `@${rawPath}`;
     }
@@ -52915,7 +53064,7 @@ ${slice.join("\n")}`;
   }
   let content = "";
   try {
-    const buf = await fs48.readFile(rawPath);
+    const buf = await fs49.readFile(rawPath);
     if (buf.byteLength > MAX_FILE_BYTES2) {
       content = buf.subarray(0, MAX_FILE_BYTES2).toString("utf8") + `
 \u2026(truncated at ${MAX_FILE_BYTES2} bytes)`;
@@ -52925,7 +53074,7 @@ ${slice.join("\n")}`;
   } catch {
     return `@${rawPath}`;
   }
-  const ext2 = path49.extname(rawPath).slice(1).toLowerCase();
+  const ext2 = path50.extname(rawPath).slice(1).toLowerCase();
   const fence = ext2 || "";
   return `Contents of \`${rawPath}\`:
 \`\`\`${fence}
@@ -53487,8 +53636,8 @@ function ReasoningCard({
 
 // src/repl/picker.tsx
 import { Box as Box3, Text as Text3 } from "ink";
-import { promises as fs49 } from "node:fs";
-import path50 from "node:path";
+import { promises as fs50 } from "node:fs";
+import path51 from "node:path";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 var MAX_VISIBLE = 12;
 function Picker({
@@ -53575,10 +53724,10 @@ async function listAtPath(prefix) {
   const lastSlash = prefix.lastIndexOf("/");
   const dir = lastSlash >= 0 ? prefix.slice(0, lastSlash) : "";
   const fragment = lastSlash >= 0 ? prefix.slice(lastSlash + 1) : prefix;
-  const target = path50.resolve(cwd, dir || ".");
+  const target = path51.resolve(cwd, dir || ".");
   let entries;
   try {
-    entries = await fs49.readdir(target, { withFileTypes: true });
+    entries = await fs50.readdir(target, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -53733,7 +53882,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";
@@ -54076,8 +54235,8 @@ function EntryView({ entry }) {
 }
 
 // src/repl/history.ts
-import { promises as fs50 } from "node:fs";
-import path51 from "node:path";
+import { promises as fs51 } from "node:fs";
+import path52 from "node:path";
 var HISTORY_FILE = ".the_flow_history";
 var MAX_LINES = 1e3;
 var History = class _History {
@@ -54086,7 +54245,7 @@ var History = class _History {
   static async load(cwd = process.cwd()) {
     const h2 = new _History();
     try {
-      const text = await fs50.readFile(path51.join(cwd, HISTORY_FILE), "utf8");
+      const text = await fs51.readFile(path52.join(cwd, HISTORY_FILE), "utf8");
       h2.entries = text.split("\n").map((l2) => l2.trim()).filter(Boolean).slice(-MAX_LINES);
     } catch {
     }
@@ -54100,7 +54259,7 @@ var History = class _History {
     this.entries.push(trimmed);
     if (this.entries.length > MAX_LINES) this.entries.shift();
     this.cursor = this.entries.length;
-    await fs50.writeFile(path51.join(cwd, HISTORY_FILE), this.entries.join("\n") + "\n").catch(() => {
+    await fs51.writeFile(path52.join(cwd, HISTORY_FILE), this.entries.join("\n") + "\n").catch(() => {
     });
   }
   /** Navigate one step backward (older). Returns null at the start. */
@@ -54132,12 +54291,71 @@ var History = class _History {
   }
 };
 
+// src/binary-resolver.ts
+import { promises as fs52 } from "node:fs";
+import path53 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 fs52.access(probe, fs52.constants.F_OK);
+        return probe;
+      } catch {
+      }
+    }
+    return null;
+  };
+  if (path53.isAbsolute(nameOrPath) || nameOrPath.includes(path53.sep)) {
+    return await candidate(nameOrPath);
+  }
+  const pathEntries = (process.env.PATH ?? "").split(path53.delimiter).filter(Boolean);
+  for (const dir of pathEntries) {
+    const found = await candidate(path53.join(dir, nameOrPath));
+    if (found) return found;
+  }
+  const fallbackDirs = wellKnownBinDirs();
+  for (const dir of fallbackDirs) {
+    const found = await candidate(path53.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(path53.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(path53.join(home, ".npm-global/bin"));
+    dirs.push(path53.join(home, ".local/bin"));
+  } else if (process.platform === "win32") {
+    if (process.env.APPDATA) {
+      dirs.push(path53.join(process.env.APPDATA, "npm"));
+    }
+    if (process.env.ProgramFiles) {
+      dirs.push(path53.join(process.env.ProgramFiles, "nodejs"));
+    }
+    if (process.env.LOCALAPPDATA) {
+      dirs.push(path53.join(process.env.LOCALAPPDATA, "Programs", "gemini-cli"));
+    }
+  }
+  return dirs;
+}
+
 // src/config.ts
-import { promises as fs51 } from "node:fs";
-import path52 from "node:path";
+import { promises as fs53 } from "node:fs";
+import path54 from "node:path";
 import toml2 from "@iarna/toml";
 function resolvePath(raw, base) {
-  return path52.isAbsolute(raw) ? raw : path52.resolve(base, raw);
+  return path54.isAbsolute(raw) ? raw : path54.resolve(base, raw);
 }
 function asString2(v2, fallback = "") {
   return typeof v2 === "string" ? v2 : fallback;
@@ -54175,10 +54393,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 fs53.readFile(configPath, "utf8");
   const parsed = toml2.parse(raw);
-  const baseDir = path52.dirname(path52.resolve(configPath));
+  const baseDir = path54.dirname(path54.resolve(configPath));
   const gemini = parsed.gemini ?? {};
   const tools = parsed.tools ?? {};
   const jlink = parsed.jlink ?? {};
@@ -54199,7 +54417,7 @@ async function loadConfig(configPath) {
   const planMode = modes.plan ?? {};
   const buildMode = modes.build ?? {};
   const cfg = {
-    configPath: path52.resolve(configPath),
+    configPath: path54.resolve(configPath),
     baseDir,
     gemini: {
       binary: asString2(gemini.binary, "gemini"),
@@ -54221,9 +54439,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 +54459,7 @@ async function loadConfig(configPath) {
       ),
       codedigestDir: resolvePath(
         asString2(flow.codedigest_dir, "memory/codedigest"),
-        baseDir
+        projectDir2
       )
     },
     backend: {
@@ -54348,7 +54568,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 +54597,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 +54610,7 @@ async function loadConfig(configPath) {
       sonaEnabled: asBool(memoryCfg.sona_enabled, true),
       sonaDir: resolvePath(
         asString2(memoryCfg.sona_dir, "memory/sona"),
-        baseDir
+        projectDir2
       )
     },
     routing: {
@@ -54418,26 +54638,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 = path54.dirname(new URL(import.meta.url).pathname);
+  const siblingDir = path54.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(path54.join(agenitHome, "config", name));
+    if (flowHome) candidates.push(path54.join(flowHome, "config", name));
+    candidates.push(path54.join(siblingDir, name));
+    candidates.push(path54.join(process.cwd(), "config", name));
   }
   for (const c2 of candidates) {
     try {
-      await fs51.access(c2);
+      await fs53.access(c2);
       return c2;
     } catch {
     }
@@ -54640,18 +54858,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 fs54 } from "node:fs";
+import os4 from "node:os";
+import path55 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 : path55.join(os4.homedir(), ".cache");
+  return path55.join(base, "flow", "version-check.json");
 }
 async function readCache(p2) {
   try {
-    const raw = await fs52.readFile(p2, "utf8");
+    const raw = await fs54.readFile(p2, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.checked_at === "number" && typeof parsed.installed === "string") {
       return {
@@ -54667,8 +54885,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 fs54.mkdir(path55.dirname(p2), { recursive: true });
+    await fs54.writeFile(p2, JSON.stringify(entry, null, 2));
   } catch {
   }
 }
@@ -54787,14 +55005,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.4";
 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 +55042,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 +55062,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 fs55.readFile(".agenit_project", "utf8");
     const trimmed = txt.trim();
     if (!trimmed) return null;
     if (trimmed.includes("=")) {
@@ -54846,16 +55080,17 @@ async function readActiveProject() {
   } catch {
   }
   try {
-    const txt = await fs53.readFile(".flow_project", "utf8");
+    const txt = await fs55.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 +55109,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 +55150,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 +55183,12 @@ async function cmdRepl(cfg) {
   }
   if (cfg.memory.soulKeeperEnabled && initialProject) {
     try {
-      const projectMemoryDir = path54.join(cfg.flow.memoryDir, initialProject);
+      const projectMemoryDir = path56.join(cfg.flow.memoryDir, initialProject);
       getLoopWorkerPool().spawn(
         new SoulKeeperWorker({
           project: initialProject,
           soulPath: cfg.flow.soulPath,
-          contextPath: path54.join(projectMemoryDir, "context.md")
+          contextPath: path56.join(projectMemoryDir, "context.md")
         }),
         { gapMs: cfg.memory.soulKeeperGapMs }
       );
@@ -55003,7 +55238,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 +55255,7 @@ async function cmdProjects(cfg) {
   const dir = cfg.flow.memoryDir;
   let entries = [];
   try {
-    entries = await fs53.readdir(dir, { withFileTypes: true });
+    entries = await fs55.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -55030,34 +55265,57 @@ 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 = path56.resolve(projectDir2);
+  const projectName = name ?? path56.basename(target);
+  const memDir = path56.join(cfg.flow.memoryDir, projectName);
+  await fs55.mkdir(memDir, { recursive: true });
   for (const file of ["context.md", "decisions.md", "requirements.md"]) {
-    const p2 = path54.join(memDir, file);
+    const p2 = path56.join(memDir, file);
     try {
-      await fs53.access(p2);
+      await fs55.access(p2);
     } catch {
-      await fs53.writeFile(p2, "");
+      await fs55.writeFile(p2, "");
     }
   }
-  await fs53.writeFile(
-    path54.join(target, ".agenit_project"),
+  await fs55.writeFile(
+    path56.join(target, ".agenit_project"),
     `project = "${projectName}"
 profile = "automotive"
 `
   );
+  try {
+    const seed = await seedGeminiAssets(target, cfg.flow.flowHome);
+    process.stdout.write(
+      `  Skills: ${seed.skillsCopied} copied to ${path56.join(target, ".gemini/skills")}
+`
+    );
+    if (seed.settingsWritten) {
+      process.stdout.write(
+        `  Hooks:  .gemini/settings.json written (absolute hook paths under ${cfg.flow.flowHome})
+`
+      );
+    } else {
+      process.stdout.write(
+        `  Hooks:  .gemini/settings.json skipped (${seed.settingsSkippedReason ?? "unknown reason"})
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `  warning: failed to seed .gemini/ assets: ${err.message}
+`
+    );
+  }
   process.stdout.write(`\u2713 Project '${projectName}' initialized at ${target}
 `);
 }
 async function cmdUnflow(projectDir2) {
-  const target = path54.resolve(projectDir2);
+  const target = path56.resolve(projectDir2);
   let removed = false;
   for (const fname of [".agenit_project", ".flow_project"]) {
-    const marker = path54.join(target, fname);
+    const marker = path56.join(target, fname);
     try {
-      await fs53.unlink(marker);
+      await fs55.unlink(marker);
       process.stdout.write(`\u2713 Removed ${marker}
 `);
       removed = true;