trellis 2.1.9 → 3.0.3

package/dist/cli/index.js

@@ -2,14 +2,23 @@
 // @bun
 import {
   TrellisVcsEngine,
-  init_engine
-} from "../index-czecrvvn.js";
+  hasProfile,
+  inferProjectContext,
+  init_engine,
+  loadProfile,
+  promptForProfile,
+  saveProfile,
+  seedContext,
+  updateProfile,
+  writeAgentScaffold,
+  writeIdeScaffold
+} from "../index-q31hfjja.js";
 import {
   OntologyRegistry,
   builtinOntologies,
   validateStore
-} from "../index-04sq3h27.js";
-import"../index-3ejh8k6v.js";
+} from "../index-w7ng765c.js";
+import"../index-0q7wbasy.js";
 import {
   VectorStore,
   buildRAGContext,
@@ -38,8 +47,8 @@ import {
 import {
   SqliteKernelBackend,
   TrellisKernel
-} from "../index-7t92ej34.js";
-import"../index-5bhe57y9.js";
+} from "../index-0zk3fx2s.js";
+import"../index-yhwjgfvj.js";
 import {
   QueryEngine
 } from "../index-yp88he8n.js";
@@ -102,7 +111,7 @@ var require_argument = __commonJS((exports) => {
           this._name = name;
           break;
       }
-      if (this._name.endsWith("...")) {
+      if (this._name.length > 3 && this._name.slice(-3) === "...") {
         this.variadic = true;
         this._name = this._name.slice(0, -3);
       }
@@ -110,12 +119,11 @@ var require_argument = __commonJS((exports) => {
     name() {
       return this._name;
     }
-    _collectValue(value, previous) {
+    _concatValue(value, previous) {
       if (previous === this.defaultValue || !Array.isArray(previous)) {
         return [value];
       }
-      previous.push(value);
-      return previous;
+      return previous.concat(value);
     }
     default(value, description) {
       this.defaultValue = value;
@@ -133,7 +141,7 @@ var require_argument = __commonJS((exports) => {
           throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
         }
         if (this.variadic) {
-          return this._collectValue(arg, previous);
+          return this._concatValue(arg, previous);
         }
         return arg;
       };
@@ -298,11 +306,7 @@ var require_help = __commonJS((exports) => {
         extraInfo.push(`env: ${option.envVar}`);
       }
       if (extraInfo.length > 0) {
-        const extraDescription = `(${extraInfo.join(", ")})`;
-        if (option.description) {
-          return `${option.description} ${extraDescription}`;
-        }
-        return extraDescription;
+        return `${option.description} (${extraInfo.join(", ")})`;
       }
       return option.description;
     }
@@ -323,27 +327,6 @@ var require_help = __commonJS((exports) => {
       }
       return argument.description;
     }
-    formatItemList(heading, items, helper) {
-      if (items.length === 0)
-        return [];
-      return [helper.styleTitle(heading), ...items, ""];
-    }
-    groupItems(unsortedItems, visibleItems, getGroup) {
-      const result = new Map;
-      unsortedItems.forEach((item) => {
-        const group = getGroup(item);
-        if (!result.has(group))
-          result.set(group, []);
-      });
-      visibleItems.forEach((item) => {
-        const group = getGroup(item);
-        if (!result.has(group)) {
-          result.set(group, []);
-        }
-        result.get(group).push(item);
-      });
-      return result;
-    }
     formatHelp(cmd, helper) {
       const termWidth = helper.padWidth(cmd, helper);
       const helpWidth = helper.helpWidth ?? 80;
@@ -364,27 +347,45 @@ var require_help = __commonJS((exports) => {
       const argumentList = helper.visibleArguments(cmd).map((argument) => {
         return callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument)));
       });
-      output = output.concat(this.formatItemList("Arguments:", argumentList, helper));
-      const optionGroups = this.groupItems(cmd.options, helper.visibleOptions(cmd), (option) => option.helpGroupHeading ?? "Options:");
-      optionGroups.forEach((options, group) => {
-        const optionList = options.map((option) => {
-          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
-        });
-        output = output.concat(this.formatItemList(group, optionList, helper));
+      if (argumentList.length > 0) {
+        output = output.concat([
+          helper.styleTitle("Arguments:"),
+          ...argumentList,
+          ""
+        ]);
+      }
+      const optionList = helper.visibleOptions(cmd).map((option) => {
+        return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
       });
+      if (optionList.length > 0) {
+        output = output.concat([
+          helper.styleTitle("Options:"),
+          ...optionList,
+          ""
+        ]);
+      }
       if (helper.showGlobalOptions) {
         const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
           return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
         });
-        output = output.concat(this.formatItemList("Global Options:", globalOptionList, helper));
+        if (globalOptionList.length > 0) {
+          output = output.concat([
+            helper.styleTitle("Global Options:"),
+            ...globalOptionList,
+            ""
+          ]);
+        }
       }
-      const commandGroups = this.groupItems(cmd.commands, helper.visibleCommands(cmd), (sub) => sub.helpGroup() || "Commands:");
-      commandGroups.forEach((commands, group) => {
-        const commandList = commands.map((sub) => {
-          return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(sub)), helper.styleSubcommandDescription(helper.subcommandDescription(sub)));
-        });
-        output = output.concat(this.formatItemList(group, commandList, helper));
+      const commandList = helper.visibleCommands(cmd).map((cmd2) => {
+        return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(cmd2)), helper.styleSubcommandDescription(helper.subcommandDescription(cmd2)));
       });
+      if (commandList.length > 0) {
+        output = output.concat([
+          helper.styleTitle("Commands:"),
+          ...commandList,
+          ""
+        ]);
+      }
       return output.join(`
 `);
     }
@@ -541,7 +542,6 @@ var require_option = __commonJS((exports) => {
       this.argChoices = undefined;
       this.conflictsWith = [];
       this.implied = undefined;
-      this.helpGroupHeading = undefined;
     }
     default(value, description) {
       this.defaultValue = value;
@@ -580,12 +580,11 @@ var require_option = __commonJS((exports) => {
       this.hidden = !!hide;
       return this;
     }
-    _collectValue(value, previous) {
+    _concatValue(value, previous) {
       if (previous === this.defaultValue || !Array.isArray(previous)) {
         return [value];
       }
-      previous.push(value);
-      return previous;
+      return previous.concat(value);
     }
     choices(values) {
       this.argChoices = values.slice();
@@ -594,7 +593,7 @@ var require_option = __commonJS((exports) => {
           throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
         }
         if (this.variadic) {
-          return this._collectValue(arg, previous);
+          return this._concatValue(arg, previous);
         }
         return arg;
       };
@@ -612,10 +611,6 @@ var require_option = __commonJS((exports) => {
       }
       return camelcase(this.name());
     }
-    helpGroup(heading) {
-      this.helpGroupHeading = heading;
-      return this;
-    }
     is(arg) {
       return this.short === arg || this.long === arg;
     }
@@ -833,9 +828,6 @@ var require_command = __commonJS((exports) => {
       this._addImplicitHelpCommand = undefined;
       this._helpCommand = undefined;
       this._helpConfiguration = {};
-      this._helpGroupHeading = undefined;
-      this._defaultCommandGroup = undefined;
-      this._defaultOptionGroup = undefined;
     }
     copyInheritedSettings(sourceCommand) {
       this._outputConfiguration = sourceCommand._outputConfiguration;
@@ -900,10 +892,7 @@ var require_command = __commonJS((exports) => {
     configureOutput(configuration) {
       if (configuration === undefined)
         return this._outputConfiguration;
-      this._outputConfiguration = {
-        ...this._outputConfiguration,
-        ...configuration
-      };
+      Object.assign(this._outputConfiguration, configuration);
       return this;
     }
     showHelpAfterError(displayHelp = true) {
@@ -934,12 +923,12 @@ var require_command = __commonJS((exports) => {
     createArgument(name, description) {
       return new Argument(name, description);
     }
-    argument(name, description, parseArg, defaultValue) {
+    argument(name, description, fn, defaultValue) {
       const argument = this.createArgument(name, description);
-      if (typeof parseArg === "function") {
-        argument.default(defaultValue).argParser(parseArg);
+      if (typeof fn === "function") {
+        argument.default(defaultValue).argParser(fn);
       } else {
-        argument.default(parseArg);
+        argument.default(fn);
       }
       this.addArgument(argument);
       return this;
@@ -952,7 +941,7 @@ var require_command = __commonJS((exports) => {
     }
     addArgument(argument) {
       const previousArgument = this.registeredArguments.slice(-1)[0];
-      if (previousArgument?.variadic) {
+      if (previousArgument && previousArgument.variadic) {
         throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
       }
       if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
@@ -964,13 +953,10 @@ var require_command = __commonJS((exports) => {
     helpCommand(enableOrNameAndArgs, description) {
       if (typeof enableOrNameAndArgs === "boolean") {
         this._addImplicitHelpCommand = enableOrNameAndArgs;
-        if (enableOrNameAndArgs && this._defaultCommandGroup) {
-          this._initCommandGroup(this._getHelpCommand());
-        }
         return this;
       }
-      const nameAndArgs = enableOrNameAndArgs ?? "help [command]";
-      const [, helpName, helpArgs] = nameAndArgs.match(/([^ ]+) *(.*)/);
+      enableOrNameAndArgs = enableOrNameAndArgs ?? "help [command]";
+      const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);
       const helpDescription = description ?? "display help for command";
       const helpCommand = this.createCommand(helpName);
       helpCommand.helpOption(false);
@@ -980,8 +966,6 @@ var require_command = __commonJS((exports) => {
         helpCommand.description(helpDescription);
       this._addImplicitHelpCommand = true;
       this._helpCommand = helpCommand;
-      if (enableOrNameAndArgs || description)
-        this._initCommandGroup(helpCommand);
       return this;
     }
     addHelpCommand(helpCommand, deprecatedDescription) {
@@ -991,7 +975,6 @@ var require_command = __commonJS((exports) => {
       }
       this._addImplicitHelpCommand = true;
       this._helpCommand = helpCommand;
-      this._initCommandGroup(helpCommand);
       return this;
     }
     _getHelpCommand() {
@@ -1071,7 +1054,6 @@ Expecting one of '${allowedValues.join("', '")}'`);
         throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
 -  already used by option '${matchingOption.flags}'`);
       }
-      this._initOptionGroup(option);
       this.options.push(option);
     }
     _registerCommand(command) {
@@ -1084,7 +1066,6 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const newCmd = knownBy(command).join("|");
         throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
       }
-      this._initCommandGroup(command);
       this.commands.push(command);
     }
     addOption(option) {
@@ -1107,7 +1088,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (val !== null && option.parseArg) {
           val = this._callParseArg(option, val, oldValue, invalidValueMessage);
         } else if (val !== null && option.variadic) {
-          val = option._collectValue(val, oldValue);
+          val = option._concatValue(val, oldValue);
         }
         if (val == null) {
           if (option.negate) {
@@ -1482,7 +1463,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this.processedArgs = processedArgs;
     }
     _chainOrCall(promise, fn) {
-      if (promise?.then && typeof promise.then === "function") {
+      if (promise && promise.then && typeof promise.then === "function") {
         return promise.then(() => fn());
       }
       return fn();
@@ -1559,7 +1540,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
         return promiseChain;
       }
-      if (this.parent?.listenerCount(commandEvent)) {
+      if (this.parent && this.parent.listenerCount(commandEvent)) {
         checkForUnknownOptions();
         this._processArguments();
         this.parent.emit(commandEvent, operands, unknown);
@@ -1621,31 +1602,24 @@ Expecting one of '${allowedValues.join("', '")}'`);
         cmd._checkForConflictingLocalOptions();
       });
     }
-    parseOptions(args) {
+    parseOptions(argv) {
       const operands = [];
       const unknown = [];
       let dest = operands;
+      const args = argv.slice();
       function maybeOption(arg) {
         return arg.length > 1 && arg[0] === "-";
       }
-      const negativeNumberArg = (arg) => {
-        if (!/^-(\d+|\d*\.\d+)(e[+-]?\d+)?$/.test(arg))
-          return false;
-        return !this._getCommandAndAncestors().some((cmd) => cmd.options.map((opt) => opt.short).some((short) => /^-\d$/.test(short)));
-      };
       let activeVariadicOption = null;
-      let activeGroup = null;
-      let i = 0;
-      while (i < args.length || activeGroup) {
-        const arg = activeGroup ?? args[i++];
-        activeGroup = null;
+      while (args.length) {
+        const arg = args.shift();
         if (arg === "--") {
           if (dest === unknown)
             dest.push(arg);
-          dest.push(...args.slice(i));
+          dest.push(...args);
           break;
         }
-        if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) {
+        if (activeVariadicOption && !maybeOption(arg)) {
           this.emit(`option:${activeVariadicOption.name()}`, arg);
           continue;
         }
@@ -1654,14 +1628,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
           const option = this._findOption(arg);
           if (option) {
             if (option.required) {
-              const value = args[i++];
+              const value = args.shift();
               if (value === undefined)
                 this.optionMissingArgument(option);
               this.emit(`option:${option.name()}`, value);
             } else if (option.optional) {
               let value = null;
-              if (i < args.length && (!maybeOption(args[i]) || negativeNumberArg(args[i]))) {
-                value = args[i++];
+              if (args.length > 0 && !maybeOption(args[0])) {
+                value = args.shift();
               }
               this.emit(`option:${option.name()}`, value);
             } else {
@@ -1678,7 +1652,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
               this.emit(`option:${option.name()}`, arg.slice(2));
             } else {
               this.emit(`option:${option.name()}`);
-              activeGroup = `-${arg.slice(2)}`;
+              args.unshift(`-${arg.slice(2)}`);
             }
             continue;
           }
@@ -1691,24 +1665,31 @@ Expecting one of '${allowedValues.join("', '")}'`);
             continue;
           }
         }
-        if (dest === operands && maybeOption(arg) && !(this.commands.length === 0 && negativeNumberArg(arg))) {
+        if (maybeOption(arg)) {
           dest = unknown;
         }
         if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
           if (this._findCommand(arg)) {
             operands.push(arg);
-            unknown.push(...args.slice(i));
+            if (args.length > 0)
+              unknown.push(...args);
             break;
           } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
-            operands.push(arg, ...args.slice(i));
+            operands.push(arg);
+            if (args.length > 0)
+              operands.push(...args);
             break;
           } else if (this._defaultCommandName) {
-            unknown.push(arg, ...args.slice(i));
+            unknown.push(arg);
+            if (args.length > 0)
+              unknown.push(...args);
             break;
           }
         }
         if (this._passThroughOptions) {
-          dest.push(arg, ...args.slice(i));
+          dest.push(arg);
+          if (args.length > 0)
+            dest.push(...args);
           break;
         }
         dest.push(arg);
@@ -1919,32 +1900,6 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this._name = str;
       return this;
     }
-    helpGroup(heading) {
-      if (heading === undefined)
-        return this._helpGroupHeading ?? "";
-      this._helpGroupHeading = heading;
-      return this;
-    }
-    commandsGroup(heading) {
-      if (heading === undefined)
-        return this._defaultCommandGroup ?? "";
-      this._defaultCommandGroup = heading;
-      return this;
-    }
-    optionsGroup(heading) {
-      if (heading === undefined)
-        return this._defaultOptionGroup ?? "";
-      this._defaultOptionGroup = heading;
-      return this;
-    }
-    _initOptionGroup(option) {
-      if (this._defaultOptionGroup && !option.helpGroupHeading)
-        option.helpGroup(this._defaultOptionGroup);
-    }
-    _initCommandGroup(cmd) {
-      if (this._defaultCommandGroup && !cmd.helpGroup())
-        cmd.helpGroup(this._defaultCommandGroup);
-    }
     nameFromFilename(filename) {
       this._name = path.basename(filename, path.extname(filename));
       return this;
@@ -2021,19 +1976,15 @@ Expecting one of '${allowedValues.join("', '")}'`);
     helpOption(flags, description) {
       if (typeof flags === "boolean") {
         if (flags) {
-          if (this._helpOption === null)
-            this._helpOption = undefined;
-          if (this._defaultOptionGroup) {
-            this._initOptionGroup(this._getHelpOption());
-          }
+          this._helpOption = this._helpOption ?? undefined;
         } else {
           this._helpOption = null;
         }
         return this;
       }
-      this._helpOption = this.createOption(flags ?? "-h, --help", description ?? "display help for command");
-      if (flags || description)
-        this._initOptionGroup(this._helpOption);
+      flags = flags ?? "-h, --help";
+      description = description ?? "display help for command";
+      this._helpOption = this.createOption(flags, description);
       return this;
     }
     _getHelpOption() {
@@ -2044,7 +1995,6 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     addHelpOption(option) {
       this._helpOption = option;
-      this._initOptionGroup(option);
       return this;
     }
     help(contextOptions) {
@@ -2145,6 +2095,166 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// node_modules/cli-width/index.js
+var require_cli_width = __commonJS((exports, module) => {
+  module.exports = cliWidth;
+  function normalizeOpts(options) {
+    const defaultOpts = {
+      defaultWidth: 0,
+      output: process.stdout,
+      tty: __require("tty")
+    };
+    if (!options) {
+      return defaultOpts;
+    }
+    Object.keys(defaultOpts).forEach(function(key) {
+      if (!options[key]) {
+        options[key] = defaultOpts[key];
+      }
+    });
+    return options;
+  }
+  function cliWidth(options) {
+    const opts = normalizeOpts(options);
+    if (opts.output.getWindowSize) {
+      return opts.output.getWindowSize()[0] || opts.defaultWidth;
+    }
+    if (opts.tty.getWindowSize) {
+      return opts.tty.getWindowSize()[1] || opts.defaultWidth;
+    }
+    if (opts.output.columns) {
+      return opts.output.columns;
+    }
+    if (process.env.CLI_WIDTH) {
+      const width = parseInt(process.env.CLI_WIDTH, 10);
+      if (!isNaN(width) && width !== 0) {
+        return width;
+      }
+    }
+    return opts.defaultWidth;
+  }
+});
+
+// node_modules/mute-stream/lib/index.js
+var require_lib = __commonJS((exports, module) => {
+  var Stream = __require("stream");
+
+  class MuteStream extends Stream {
+    #isTTY = null;
+    constructor(opts = {}) {
+      super(opts);
+      this.writable = this.readable = true;
+      this.muted = false;
+      this.on("pipe", this._onpipe);
+      this.replace = opts.replace;
+      this._prompt = opts.prompt || null;
+      this._hadControl = false;
+    }
+    #destSrc(key, def) {
+      if (this._dest) {
+        return this._dest[key];
+      }
+      if (this._src) {
+        return this._src[key];
+      }
+      return def;
+    }
+    #proxy(method, ...args) {
+      if (typeof this._dest?.[method] === "function") {
+        this._dest[method](...args);
+      }
+      if (typeof this._src?.[method] === "function") {
+        this._src[method](...args);
+      }
+    }
+    get isTTY() {
+      if (this.#isTTY !== null) {
+        return this.#isTTY;
+      }
+      return this.#destSrc("isTTY", false);
+    }
+    set isTTY(val) {
+      this.#isTTY = val;
+    }
+    get rows() {
+      return this.#destSrc("rows");
+    }
+    get columns() {
+      return this.#destSrc("columns");
+    }
+    mute() {
+      this.muted = true;
+    }
+    unmute() {
+      this.muted = false;
+    }
+    _onpipe(src) {
+      this._src = src;
+    }
+    pipe(dest, options) {
+      this._dest = dest;
+      return super.pipe(dest, options);
+    }
+    pause() {
+      if (this._src) {
+        return this._src.pause();
+      }
+    }
+    resume() {
+      if (this._src) {
+        return this._src.resume();
+      }
+    }
+    write(c) {
+      if (this.muted) {
+        if (!this.replace) {
+          return true;
+        }
+        if (c.match(/^\u001b/)) {
+          if (c.indexOf(this._prompt) === 0) {
+            c = c.slice(this._prompt.length);
+            c = c.replace(/./g, this.replace);
+            c = this._prompt + c;
+          }
+          this._hadControl = true;
+          return this.emit("data", c);
+        } else {
+          if (this._prompt && this._hadControl && c.indexOf(this._prompt) === 0) {
+            this._hadControl = false;
+            this.emit("data", this._prompt);
+            c = c.slice(this._prompt.length);
+          }
+          c = c.toString().replace(/./g, this.replace);
+        }
+      }
+      this.emit("data", c);
+    }
+    end(c) {
+      if (this.muted) {
+        if (c && this.replace) {
+          c = c.toString().replace(/./g, this.replace);
+        } else {
+          c = null;
+        }
+      }
+      if (c) {
+        this.emit("data", c);
+      }
+      this.emit("end");
+    }
+    destroy(...args) {
+      return this.#proxy("destroy", ...args);
+    }
+    destroySoon(...args) {
+      return this.#proxy("destroySoon", ...args);
+    }
+    close(...args) {
+      return this.#proxy("close", ...args);
+    }
+  }
+  module.exports = MuteStream;
+});
+
 // src/sync/reconciler.ts
 var exports_reconciler = {};
 __export(exports_reconciler, {
@@ -2438,6 +2548,142 @@ function buildGraph(engine) {
   } catch {}
   return { nodes, edges };
 }
+function buildTimeline(engine) {
+  const ops = engine.getOps();
+  const branches = engine.listBranches();
+  const milestones = engine.listMilestones();
+  const checkpoints = engine.listCheckpoints();
+  const opSummaries = ops.map((op, index) => ({
+    index,
+    hash: op.hash?.slice(0, 24) ?? "",
+    kind: op.kind,
+    timestamp: op.timestamp,
+    agentId: op.agentId,
+    filePath: op.vcs?.filePath,
+    branchName: op.vcs?.branchName,
+    message: op.vcs?.message
+  }));
+  const milestoneMarkers = milestones.map((m) => {
+    const toIdx = ops.findIndex((o) => o.hash === m.toOpHash);
+    return {
+      id: m.id,
+      message: m.message,
+      createdAt: m.createdAt,
+      atOpIndex: toIdx >= 0 ? toIdx : ops.length - 1,
+      affectedFiles: m.affectedFiles?.length ?? 0
+    };
+  });
+  const checkpointMarkers = checkpoints.map((c) => {
+    const atIdx = ops.findIndex((o) => o.hash === c.atOpHash);
+    return {
+      id: c.id,
+      trigger: c.trigger,
+      createdAt: c.createdAt,
+      atOpIndex: atIdx >= 0 ? atIdx : ops.length - 1
+    };
+  });
+  return {
+    ops: opSummaries,
+    branches: branches.map((b) => ({
+      name: b.name,
+      isCurrent: b.isCurrent,
+      createdAt: b.createdAt
+    })),
+    milestones: milestoneMarkers,
+    checkpoints: checkpointMarkers,
+    totalOps: ops.length
+  };
+}
+function buildStoreOverview(engine) {
+  const store = engine.getStore();
+  const stats = store.getStats();
+  const catalog = store.getCatalog();
+  const typeFacts = store.getFactsByAttribute("type");
+  const entityTypes = {};
+  const entityList = [];
+  for (const fact of typeFacts) {
+    const typeName = String(fact.v);
+    entityTypes[typeName] = (entityTypes[typeName] ?? 0) + 1;
+    const entityFacts = store.getFactsByEntity(fact.e);
+    entityList.push({
+      id: fact.e,
+      type: typeName,
+      factCount: entityFacts.length
+    });
+  }
+  return {
+    stats: {
+      totalFacts: stats.totalFacts,
+      totalLinks: stats.totalLinks,
+      uniqueEntities: stats.uniqueEntities,
+      uniqueAttributes: stats.uniqueAttributes
+    },
+    catalog: catalog.map((c) => ({
+      attribute: c.attribute,
+      type: c.type,
+      cardinality: c.cardinality,
+      distinctCount: c.distinctCount,
+      examples: c.examples.slice(0, 3)
+    })),
+    entityTypes,
+    entities: entityList.slice(0, 500)
+  };
+}
+function buildEntityDetail(engine, entityId) {
+  const store = engine.getStore();
+  const facts = store.getFactsByEntity(entityId);
+  if (facts.length === 0)
+    return null;
+  const typeFact = facts.find((f) => f.a === "type");
+  const links = store.getLinksByEntity(entityId);
+  return {
+    id: entityId,
+    type: typeFact?.v ?? "unknown",
+    facts: facts.map((f) => ({ a: f.a, v: f.v })),
+    links: links.map((l) => ({
+      a: l.a,
+      source: l.e1,
+      target: l.e2,
+      direction: l.e1 === entityId ? "outgoing" : "incoming"
+    }))
+  };
+}
+function buildSystemInfo(engine) {
+  const status = engine.status();
+  const store = engine.getStore();
+  const stats = store.getStats();
+  const embeddingsAvailable = existsSync5(join5(engine.getRootPath(), ".trellis", "embeddings.db"));
+  const blobStoreAvailable = engine.getBlobStore() !== null;
+  return {
+    engine: {
+      rootPath: engine.getRootPath(),
+      branch: status.branch,
+      totalOps: status.totalOps,
+      trackedFiles: status.trackedFiles,
+      lastOpAt: status.lastOp?.timestamp ?? null
+    },
+    store: {
+      totalFacts: stats.totalFacts,
+      totalLinks: stats.totalLinks,
+      uniqueEntities: stats.uniqueEntities,
+      uniqueAttributes: stats.uniqueAttributes
+    },
+    features: {
+      embeddings: embeddingsAvailable,
+      blobStore: blobStoreAvailable
+    },
+    parsers: [
+      "typescript",
+      "javascript",
+      "python",
+      "go",
+      "rust",
+      "ruby",
+      "java",
+      "csharp"
+    ]
+  };
+}
 function getNodeDetail(engine, nodeId) {
   const [type, ...rest] = nodeId.split(":");
   const id = rest.join(":");
@@ -2486,7 +2732,27 @@ function getNodeDetail(engine, nodeId) {
 async function startUIServer(opts) {
   const engine = new TrellisVcsEngine({ rootPath: opts.rootPath });
   engine.open();
-  const clientHtml = readFileSync3(join5(dirname4(new URL(import.meta.url).pathname), "client.html"), "utf-8");
+  function findClientHtml() {
+    const here = dirname4(process.argv[1]);
+    const candidates = [
+      join5(here, "client.html"),
+      join5(here, "..", "ui", "client.html"),
+      join5(here, "ui", "client.html")
+    ];
+    let dir = here;
+    for (let i = 0;i < 5; i++) {
+      candidates.push(join5(dir, "dist", "ui", "client.html"));
+      candidates.push(join5(dir, "ui", "client.html"));
+      dir = dirname4(dir);
+    }
+    for (const p of candidates) {
+      if (existsSync5(p))
+        return p;
+    }
+    throw new Error(`Could not find client.html. Searched from: ${here}
+Try reinstalling the package or running \`bun run build\`.`);
+  }
+  const clientHtml = readFileSync3(findClientHtml(), "utf-8");
   let embeddingManager = null;
   function getEmbeddingManager() {
     if (!embeddingManager) {
@@ -2518,6 +2784,26 @@ async function startUIServer(opts) {
         const graph = buildGraph(engine);
         return Response.json(graph, { headers });
       }
+      if (path === "/api/timeline") {
+        const timeline = buildTimeline(engine);
+        return Response.json(timeline, { headers });
+      }
+      if (path === "/api/store") {
+        const overview = buildStoreOverview(engine);
+        return Response.json(overview, { headers });
+      }
+      if (path.startsWith("/api/store/entity/")) {
+        const entityId = decodeURIComponent(path.slice("/api/store/entity/".length));
+        const detail = buildEntityDetail(engine, entityId);
+        if (!detail) {
+          return Response.json({ error: "Entity not found" }, { status: 404, headers });
+        }
+        return Response.json(detail, { headers });
+      }
+      if (path === "/api/system") {
+        const info = buildSystemInfo(engine);
+        return Response.json(info, { headers });
+      }
       if (path === "/api/search") {
         const query = url.searchParams.get("q");
         if (!query) {
@@ -2600,7 +2886,7 @@ var {
   Help
 } = import__.default;
 
-// node_modules/chalk/source/vendor/ansi-styles/index.js
+// ../trellis-client/node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
 var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
@@ -2777,7 +3063,7 @@ function assembleStyles() {
 var ansiStyles = assembleStyles();
 var ansi_styles_default = ansiStyles;
 
-// node_modules/chalk/source/vendor/supports-color/index.js
+// ../trellis-client/node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
 import process2 from "process";
 import os from "os";
 import tty from "tty";
@@ -2909,7 +3195,7 @@ var supportsColor = {
 };
 var supports_color_default = supportsColor;
 
-// node_modules/chalk/source/utilities.js
+// ../trellis-client/node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
 function stringReplaceAll(string, substring, replacer) {
   let index = string.indexOf(substring);
   if (index === -1) {
@@ -2942,7 +3228,7 @@ function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
   return returnValue;
 }
 
-// node_modules/chalk/source/index.js
+// ../trellis-client/node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
 var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
 var GENERATOR = Symbol("GENERATOR");
 var STYLER = Symbol("STYLER");
@@ -3077,21 +3363,1799 @@ var applyStyle = (self, string) => {
       styler = styler.parent;
     }
   }
-  const lfIndex = string.indexOf(`
-`);
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  const lfIndex = string.indexOf(`
+`);
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// src/cli/index.ts
+import { resolve, join as join6 } from "path";
+
+// node_modules/@inquirer/core/dist/lib/key.js
+var isUpKey = (key, keybindings = []) => key.name === "up" || keybindings.includes("vim") && key.name === "k" || keybindings.includes("emacs") && key.ctrl && key.name === "p";
+var isDownKey = (key, keybindings = []) => key.name === "down" || keybindings.includes("vim") && key.name === "j" || keybindings.includes("emacs") && key.ctrl && key.name === "n";
+var isSpaceKey = (key) => key.name === "space";
+var isBackspaceKey = (key) => key.name === "backspace";
+var isNumberKey = (key) => "1234567890".includes(key.name);
+var isEnterKey = (key) => key.name === "enter" || key.name === "return";
+// node_modules/@inquirer/core/dist/lib/errors.js
+class AbortPromptError extends Error {
+  name = "AbortPromptError";
+  message = "Prompt was aborted";
+  constructor(options) {
+    super();
+    this.cause = options?.cause;
+  }
+}
+
+class CancelPromptError extends Error {
+  name = "CancelPromptError";
+  message = "Prompt was canceled";
+}
+
+class ExitPromptError extends Error {
+  name = "ExitPromptError";
+}
+
+class HookError extends Error {
+  name = "HookError";
+}
+
+class ValidationError extends Error {
+  name = "ValidationError";
+}
+// node_modules/@inquirer/core/dist/lib/use-state.js
+import { AsyncResource as AsyncResource2 } from "async_hooks";
+
+// node_modules/@inquirer/core/dist/lib/hook-engine.js
+import { AsyncLocalStorage, AsyncResource } from "async_hooks";
+var hookStorage = new AsyncLocalStorage;
+function createStore(rl) {
+  const store = {
+    rl,
+    hooks: [],
+    hooksCleanup: [],
+    hooksEffect: [],
+    index: 0,
+    handleChange() {}
+  };
+  return store;
+}
+function withHooks(rl, cb) {
+  const store = createStore(rl);
+  return hookStorage.run(store, () => {
+    function cycle(render) {
+      store.handleChange = () => {
+        store.index = 0;
+        render();
+      };
+      store.handleChange();
+    }
+    return cb(cycle);
+  });
+}
+function getStore() {
+  const store = hookStorage.getStore();
+  if (!store) {
+    throw new HookError("[Inquirer] Hook functions can only be called from within a prompt");
+  }
+  return store;
+}
+function readline() {
+  return getStore().rl;
+}
+function withUpdates(fn) {
+  const wrapped = (...args) => {
+    const store = getStore();
+    let shouldUpdate = false;
+    const oldHandleChange = store.handleChange;
+    store.handleChange = () => {
+      shouldUpdate = true;
+    };
+    const returnValue = fn(...args);
+    if (shouldUpdate) {
+      oldHandleChange();
+    }
+    store.handleChange = oldHandleChange;
+    return returnValue;
+  };
+  return AsyncResource.bind(wrapped);
+}
+function withPointer(cb) {
+  const store = getStore();
+  const { index } = store;
+  const pointer = {
+    get() {
+      return store.hooks[index];
+    },
+    set(value) {
+      store.hooks[index] = value;
+    },
+    initialized: index in store.hooks
+  };
+  const returnValue = cb(pointer);
+  store.index++;
+  return returnValue;
+}
+function handleChange() {
+  getStore().handleChange();
+}
+var effectScheduler = {
+  queue(cb) {
+    const store = getStore();
+    const { index } = store;
+    store.hooksEffect.push(() => {
+      store.hooksCleanup[index]?.();
+      const cleanFn = cb(readline());
+      if (cleanFn != null && typeof cleanFn !== "function") {
+        throw new ValidationError("useEffect return value must be a cleanup function or nothing.");
+      }
+      store.hooksCleanup[index] = cleanFn;
+    });
+  },
+  run() {
+    const store = getStore();
+    withUpdates(() => {
+      store.hooksEffect.forEach((effect) => {
+        effect();
+      });
+      store.hooksEffect.length = 0;
+    })();
+  },
+  clearAll() {
+    const store = getStore();
+    store.hooksCleanup.forEach((cleanFn) => {
+      cleanFn?.();
+    });
+    store.hooksEffect.length = 0;
+    store.hooksCleanup.length = 0;
+  }
+};
+
+// node_modules/@inquirer/core/dist/lib/use-state.js
+function useState(defaultValue) {
+  return withPointer((pointer) => {
+    const setState = AsyncResource2.bind(function setState2(newValue) {
+      if (pointer.get() !== newValue) {
+        pointer.set(newValue);
+        handleChange();
+      }
+    });
+    if (pointer.initialized) {
+      return [pointer.get(), setState];
+    }
+    const value = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+    pointer.set(value);
+    return [value, setState];
+  });
+}
+
+// node_modules/@inquirer/core/dist/lib/use-effect.js
+function useEffect(cb, depArray) {
+  withPointer((pointer) => {
+    const oldDeps = pointer.get();
+    const hasChanged = !Array.isArray(oldDeps) || depArray.some((dep, i) => !Object.is(dep, oldDeps[i]));
+    if (hasChanged) {
+      effectScheduler.queue(cb);
+    }
+    pointer.set(depArray);
+  });
+}
+
+// node_modules/@inquirer/core/dist/lib/theme.js
+import { styleText } from "util";
+
+// node_modules/@inquirer/figures/dist/index.js
+import process3 from "process";
+function isUnicodeSupported() {
+  if (process3.platform !== "win32") {
+    return process3.env["TERM"] !== "linux";
+  }
+  return Boolean(process3.env["WT_SESSION"]) || Boolean(process3.env["TERMINUS_SUBLIME"]) || process3.env["ConEmuTask"] === "{cmd::Cmder}" || process3.env["TERM_PROGRAM"] === "Terminus-Sublime" || process3.env["TERM_PROGRAM"] === "vscode" || process3.env["TERM"] === "xterm-256color" || process3.env["TERM"] === "alacritty" || process3.env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
+}
+var common = {
+  circleQuestionMark: "(?)",
+  questionMarkPrefix: "(?)",
+  square: "\u2588",
+  squareDarkShade: "\u2593",
+  squareMediumShade: "\u2592",
+  squareLightShade: "\u2591",
+  squareTop: "\u2580",
+  squareBottom: "\u2584",
+  squareLeft: "\u258C",
+  squareRight: "\u2590",
+  squareCenter: "\u25A0",
+  bullet: "\u25CF",
+  dot: "\u2024",
+  ellipsis: "\u2026",
+  pointerSmall: "\u203A",
+  triangleUp: "\u25B2",
+  triangleUpSmall: "\u25B4",
+  triangleDown: "\u25BC",
+  triangleDownSmall: "\u25BE",
+  triangleLeftSmall: "\u25C2",
+  triangleRightSmall: "\u25B8",
+  home: "\u2302",
+  heart: "\u2665",
+  musicNote: "\u266A",
+  musicNoteBeamed: "\u266B",
+  arrowUp: "\u2191",
+  arrowDown: "\u2193",
+  arrowLeft: "\u2190",
+  arrowRight: "\u2192",
+  arrowLeftRight: "\u2194",
+  arrowUpDown: "\u2195",
+  almostEqual: "\u2248",
+  notEqual: "\u2260",
+  lessOrEqual: "\u2264",
+  greaterOrEqual: "\u2265",
+  identical: "\u2261",
+  infinity: "\u221E",
+  subscriptZero: "\u2080",
+  subscriptOne: "\u2081",
+  subscriptTwo: "\u2082",
+  subscriptThree: "\u2083",
+  subscriptFour: "\u2084",
+  subscriptFive: "\u2085",
+  subscriptSix: "\u2086",
+  subscriptSeven: "\u2087",
+  subscriptEight: "\u2088",
+  subscriptNine: "\u2089",
+  oneHalf: "\xBD",
+  oneThird: "\u2153",
+  oneQuarter: "\xBC",
+  oneFifth: "\u2155",
+  oneSixth: "\u2159",
+  oneEighth: "\u215B",
+  twoThirds: "\u2154",
+  twoFifths: "\u2156",
+  threeQuarters: "\xBE",
+  threeFifths: "\u2157",
+  threeEighths: "\u215C",
+  fourFifths: "\u2158",
+  fiveSixths: "\u215A",
+  fiveEighths: "\u215D",
+  sevenEighths: "\u215E",
+  line: "\u2500",
+  lineBold: "\u2501",
+  lineDouble: "\u2550",
+  lineDashed0: "\u2504",
+  lineDashed1: "\u2505",
+  lineDashed2: "\u2508",
+  lineDashed3: "\u2509",
+  lineDashed4: "\u254C",
+  lineDashed5: "\u254D",
+  lineDashed6: "\u2574",
+  lineDashed7: "\u2576",
+  lineDashed8: "\u2578",
+  lineDashed9: "\u257A",
+  lineDashed10: "\u257C",
+  lineDashed11: "\u257E",
+  lineDashed12: "\u2212",
+  lineDashed13: "\u2013",
+  lineDashed14: "\u2010",
+  lineDashed15: "\u2043",
+  lineVertical: "\u2502",
+  lineVerticalBold: "\u2503",
+  lineVerticalDouble: "\u2551",
+  lineVerticalDashed0: "\u2506",
+  lineVerticalDashed1: "\u2507",
+  lineVerticalDashed2: "\u250A",
+  lineVerticalDashed3: "\u250B",
+  lineVerticalDashed4: "\u254E",
+  lineVerticalDashed5: "\u254F",
+  lineVerticalDashed6: "\u2575",
+  lineVerticalDashed7: "\u2577",
+  lineVerticalDashed8: "\u2579",
+  lineVerticalDashed9: "\u257B",
+  lineVerticalDashed10: "\u257D",
+  lineVerticalDashed11: "\u257F",
+  lineDownLeft: "\u2510",
+  lineDownLeftArc: "\u256E",
+  lineDownBoldLeftBold: "\u2513",
+  lineDownBoldLeft: "\u2512",
+  lineDownLeftBold: "\u2511",
+  lineDownDoubleLeftDouble: "\u2557",
+  lineDownDoubleLeft: "\u2556",
+  lineDownLeftDouble: "\u2555",
+  lineDownRight: "\u250C",
+  lineDownRightArc: "\u256D",
+  lineDownBoldRightBold: "\u250F",
+  lineDownBoldRight: "\u250E",
+  lineDownRightBold: "\u250D",
+  lineDownDoubleRightDouble: "\u2554",
+  lineDownDoubleRight: "\u2553",
+  lineDownRightDouble: "\u2552",
+  lineUpLeft: "\u2518",
+  lineUpLeftArc: "\u256F",
+  lineUpBoldLeftBold: "\u251B",
+  lineUpBoldLeft: "\u251A",
+  lineUpLeftBold: "\u2519",
+  lineUpDoubleLeftDouble: "\u255D",
+  lineUpDoubleLeft: "\u255C",
+  lineUpLeftDouble: "\u255B",
+  lineUpRight: "\u2514",
+  lineUpRightArc: "\u2570",
+  lineUpBoldRightBold: "\u2517",
+  lineUpBoldRight: "\u2516",
+  lineUpRightBold: "\u2515",
+  lineUpDoubleRightDouble: "\u255A",
+  lineUpDoubleRight: "\u2559",
+  lineUpRightDouble: "\u2558",
+  lineUpDownLeft: "\u2524",
+  lineUpBoldDownBoldLeftBold: "\u252B",
+  lineUpBoldDownBoldLeft: "\u2528",
+  lineUpDownLeftBold: "\u2525",
+  lineUpBoldDownLeftBold: "\u2529",
+  lineUpDownBoldLeftBold: "\u252A",
+  lineUpDownBoldLeft: "\u2527",
+  lineUpBoldDownLeft: "\u2526",
+  lineUpDoubleDownDoubleLeftDouble: "\u2563",
+  lineUpDoubleDownDoubleLeft: "\u2562",
+  lineUpDownLeftDouble: "\u2561",
+  lineUpDownRight: "\u251C",
+  lineUpBoldDownBoldRightBold: "\u2523",
+  lineUpBoldDownBoldRight: "\u2520",
+  lineUpDownRightBold: "\u251D",
+  lineUpBoldDownRightBold: "\u2521",
+  lineUpDownBoldRightBold: "\u2522",
+  lineUpDownBoldRight: "\u251F",
+  lineUpBoldDownRight: "\u251E",
+  lineUpDoubleDownDoubleRightDouble: "\u2560",
+  lineUpDoubleDownDoubleRight: "\u255F",
+  lineUpDownRightDouble: "\u255E",
+  lineDownLeftRight: "\u252C",
+  lineDownBoldLeftBoldRightBold: "\u2533",
+  lineDownLeftBoldRightBold: "\u252F",
+  lineDownBoldLeftRight: "\u2530",
+  lineDownBoldLeftBoldRight: "\u2531",
+  lineDownBoldLeftRightBold: "\u2532",
+  lineDownLeftRightBold: "\u252E",
+  lineDownLeftBoldRight: "\u252D",
+  lineDownDoubleLeftDoubleRightDouble: "\u2566",
+  lineDownDoubleLeftRight: "\u2565",
+  lineDownLeftDoubleRightDouble: "\u2564",
+  lineUpLeftRight: "\u2534",
+  lineUpBoldLeftBoldRightBold: "\u253B",
+  lineUpLeftBoldRightBold: "\u2537",
+  lineUpBoldLeftRight: "\u2538",
+  lineUpBoldLeftBoldRight: "\u2539",
+  lineUpBoldLeftRightBold: "\u253A",
+  lineUpLeftRightBold: "\u2536",
+  lineUpLeftBoldRight: "\u2535",
+  lineUpDoubleLeftDoubleRightDouble: "\u2569",
+  lineUpDoubleLeftRight: "\u2568",
+  lineUpLeftDoubleRightDouble: "\u2567",
+  lineUpDownLeftRight: "\u253C",
+  lineUpBoldDownBoldLeftBoldRightBold: "\u254B",
+  lineUpDownBoldLeftBoldRightBold: "\u2548",
+  lineUpBoldDownLeftBoldRightBold: "\u2547",
+  lineUpBoldDownBoldLeftRightBold: "\u254A",
+  lineUpBoldDownBoldLeftBoldRight: "\u2549",
+  lineUpBoldDownLeftRight: "\u2540",
+  lineUpDownBoldLeftRight: "\u2541",
+  lineUpDownLeftBoldRight: "\u253D",
+  lineUpDownLeftRightBold: "\u253E",
+  lineUpBoldDownBoldLeftRight: "\u2542",
+  lineUpDownLeftBoldRightBold: "\u253F",
+  lineUpBoldDownLeftBoldRight: "\u2543",
+  lineUpBoldDownLeftRightBold: "\u2544",
+  lineUpDownBoldLeftBoldRight: "\u2545",
+  lineUpDownBoldLeftRightBold: "\u2546",
+  lineUpDoubleDownDoubleLeftDoubleRightDouble: "\u256C",
+  lineUpDoubleDownDoubleLeftRight: "\u256B",
+  lineUpDownLeftDoubleRightDouble: "\u256A",
+  lineCross: "\u2573",
+  lineBackslash: "\u2572",
+  lineSlash: "\u2571"
+};
+var specialMainSymbols = {
+  tick: "\u2714",
+  info: "\u2139",
+  warning: "\u26A0",
+  cross: "\u2718",
+  squareSmall: "\u25FB",
+  squareSmallFilled: "\u25FC",
+  circle: "\u25EF",
+  circleFilled: "\u25C9",
+  circleDotted: "\u25CC",
+  circleDouble: "\u25CE",
+  circleCircle: "\u24DE",
+  circleCross: "\u24E7",
+  circlePipe: "\u24BE",
+  radioOn: "\u25C9",
+  radioOff: "\u25EF",
+  checkboxOn: "\u2612",
+  checkboxOff: "\u2610",
+  checkboxCircleOn: "\u24E7",
+  checkboxCircleOff: "\u24BE",
+  pointer: "\u276F",
+  triangleUpOutline: "\u25B3",
+  triangleLeft: "\u25C0",
+  triangleRight: "\u25B6",
+  lozenge: "\u25C6",
+  lozengeOutline: "\u25C7",
+  hamburger: "\u2630",
+  smiley: "\u32E1",
+  mustache: "\u0DF4",
+  star: "\u2605",
+  play: "\u25B6",
+  nodejs: "\u2B22",
+  oneSeventh: "\u2150",
+  oneNinth: "\u2151",
+  oneTenth: "\u2152"
+};
+var specialFallbackSymbols = {
+  tick: "\u221A",
+  info: "i",
+  warning: "\u203C",
+  cross: "\xD7",
+  squareSmall: "\u25A1",
+  squareSmallFilled: "\u25A0",
+  circle: "( )",
+  circleFilled: "(*)",
+  circleDotted: "( )",
+  circleDouble: "( )",
+  circleCircle: "(\u25CB)",
+  circleCross: "(\xD7)",
+  circlePipe: "(\u2502)",
+  radioOn: "(*)",
+  radioOff: "( )",
+  checkboxOn: "[\xD7]",
+  checkboxOff: "[ ]",
+  checkboxCircleOn: "(\xD7)",
+  checkboxCircleOff: "( )",
+  pointer: ">",
+  triangleUpOutline: "\u2206",
+  triangleLeft: "\u25C4",
+  triangleRight: "\u25BA",
+  lozenge: "\u2666",
+  lozengeOutline: "\u25CA",
+  hamburger: "\u2261",
+  smiley: "\u263A",
+  mustache: "\u250C\u2500\u2510",
+  star: "\u2736",
+  play: "\u25BA",
+  nodejs: "\u2666",
+  oneSeventh: "1/7",
+  oneNinth: "1/9",
+  oneTenth: "1/10"
+};
+var mainSymbols = {
+  ...common,
+  ...specialMainSymbols
+};
+var fallbackSymbols = {
+  ...common,
+  ...specialFallbackSymbols
+};
+var shouldUseMain = isUnicodeSupported();
+var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
+var dist_default = figures;
+var replacements = Object.entries(specialMainSymbols);
+
+// node_modules/@inquirer/core/dist/lib/theme.js
+var defaultTheme = {
+  prefix: {
+    idle: styleText("blue", "?"),
+    done: styleText("green", dist_default.tick)
+  },
+  spinner: {
+    interval: 80,
+    frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"].map((frame) => styleText("yellow", frame))
+  },
+  style: {
+    answer: (text) => styleText("cyan", text),
+    message: (text) => styleText("bold", text),
+    error: (text) => styleText("red", `> ${text}`),
+    defaultAnswer: (text) => styleText("dim", `(${text})`),
+    help: (text) => styleText("dim", text),
+    highlight: (text) => styleText("cyan", text),
+    key: (text) => styleText("cyan", styleText("bold", `<${text}>`))
+  }
+};
+
+// node_modules/@inquirer/core/dist/lib/make-theme.js
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  let proto2 = value;
+  while (Object.getPrototypeOf(proto2) !== null) {
+    proto2 = Object.getPrototypeOf(proto2);
+  }
+  return Object.getPrototypeOf(value) === proto2;
+}
+function deepMerge(...objects) {
+  const output = {};
+  for (const obj of objects) {
+    for (const [key, value] of Object.entries(obj)) {
+      const prevValue = output[key];
+      output[key] = isPlainObject(prevValue) && isPlainObject(value) ? deepMerge(prevValue, value) : value;
+    }
+  }
+  return output;
+}
+function makeTheme(...themes) {
+  const themesToMerge = [
+    defaultTheme,
+    ...themes.filter((theme) => theme != null)
+  ];
+  return deepMerge(...themesToMerge);
+}
+
+// node_modules/@inquirer/core/dist/lib/use-prefix.js
+function usePrefix({ status = "idle", theme }) {
+  const [showLoader, setShowLoader] = useState(false);
+  const [tick, setTick] = useState(0);
+  const { prefix, spinner } = makeTheme(theme);
+  useEffect(() => {
+    if (status === "loading") {
+      let tickInterval;
+      let inc = -1;
+      const delayTimeout = setTimeout(() => {
+        setShowLoader(true);
+        tickInterval = setInterval(() => {
+          inc = inc + 1;
+          setTick(inc % spinner.frames.length);
+        }, spinner.interval);
+      }, 300);
+      return () => {
+        clearTimeout(delayTimeout);
+        clearInterval(tickInterval);
+      };
+    } else {
+      setShowLoader(false);
+    }
+  }, [status]);
+  if (showLoader) {
+    return spinner.frames[tick];
+  }
+  const iconName = status === "loading" ? "idle" : status;
+  return typeof prefix === "string" ? prefix : prefix[iconName] ?? prefix["idle"];
+}
+// node_modules/@inquirer/core/dist/lib/use-memo.js
+function useMemo(fn, dependencies) {
+  return withPointer((pointer) => {
+    const prev = pointer.get();
+    if (!prev || prev.dependencies.length !== dependencies.length || prev.dependencies.some((dep, i) => dep !== dependencies[i])) {
+      const value = fn();
+      pointer.set({ value, dependencies });
+      return value;
+    }
+    return prev.value;
+  });
+}
+// node_modules/@inquirer/core/dist/lib/use-ref.js
+function useRef(val) {
+  return useState({ current: val })[0];
+}
+// node_modules/@inquirer/core/dist/lib/use-keypress.js
+function useKeypress(userHandler) {
+  const signal = useRef(userHandler);
+  signal.current = userHandler;
+  useEffect((rl) => {
+    let ignore = false;
+    const handler = withUpdates((_input, event) => {
+      if (ignore)
+        return;
+      signal.current(event, rl);
+    });
+    rl.input.on("keypress", handler);
+    return () => {
+      ignore = true;
+      rl.input.removeListener("keypress", handler);
+    };
+  }, []);
+}
+// node_modules/@inquirer/core/dist/lib/utils.js
+var import_cli_width = __toESM(require_cli_width(), 1);
+
+// node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer:
+    while (true) {
+      if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+        const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+        lengthExtra = 0;
+        for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+          const codePoint = char.codePointAt(0) || 0;
+          if (isFullWidth(codePoint)) {
+            widthExtra = FULL_WIDTH_WIDTH;
+          } else if (isWideNotCJKTNotEmoji(codePoint)) {
+            widthExtra = WIDE_WIDTH;
+          } else {
+            widthExtra = REGULAR_WIDTH;
+          }
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          lengthExtra += char.length;
+          width += widthExtra;
+        }
+        unmatchedStart = unmatchedEnd = 0;
+      }
+      if (index >= length) {
+        break outer;
+      }
+      for (let i = 0, l = PARSE_BLOCKS.length;i < l; i++) {
+        const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+        BLOCK_RE.lastIndex = index;
+        if (BLOCK_RE.test(input)) {
+          lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+          widthExtra = lengthExtra * BLOCK_WIDTH;
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          width += widthExtra;
+          unmatchedStart = indexPrev;
+          unmatchedEnd = index;
+          index = indexPrev = BLOCK_RE.lastIndex;
+          continue outer;
+        }
+      }
+      index += 1;
+    }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default2 = getStringTruncatedWidth;
+
+// node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default2(input, NO_TRUNCATION2, options).width;
+};
+var dist_default3 = fastStringWidth;
+
+// node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "\x9B";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === undefined ? 0 : dist_default3(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default3(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default3(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0;index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default3(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default3(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default3(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default3(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default3(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join(`
+`);
+  let inSurrogate = false;
+  for (let i = 0;i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== undefined) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? undefined : code;
+      } else if (groups?.uri !== undefined) {
+        escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+      }
+    }
+    if (preString[i + 1] === `
+`) {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === `
+`) {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join(`
+`);
+}
+
+// node_modules/@inquirer/core/dist/lib/utils.js
+function breakLines(content, width) {
+  return content.split(`
+`).flatMap((line) => wrapAnsi(line, width, { trim: false, hard: true }).split(`
+`).map((str) => str.trimEnd())).join(`
+`);
+}
+function readlineWidth() {
+  return import_cli_width.default({ defaultWidth: 80, output: readline().output });
+}
+
+// node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js
+function usePointerPosition({ active, renderedItems, pageSize, loop }) {
+  const state = useRef({
+    lastPointer: active,
+    lastActive: undefined
+  });
+  const { lastPointer, lastActive } = state.current;
+  const middle = Math.floor(pageSize / 2);
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const defaultPointerPosition = renderedItems.slice(0, active).reduce((acc, item) => acc + item.length, 0);
+  let pointer = defaultPointerPosition;
+  if (renderedLength > pageSize) {
+    if (loop) {
+      pointer = lastPointer;
+      if (lastActive != null && lastActive < active && active - lastActive < pageSize) {
+        pointer = Math.min(middle, Math.abs(active - lastActive) === 1 ? Math.min(lastPointer + (renderedItems[lastActive]?.length ?? 0), Math.max(defaultPointerPosition, lastPointer)) : lastPointer + active - lastActive);
+      }
+    } else {
+      const spaceUnderActive = renderedItems.slice(active).reduce((acc, item) => acc + item.length, 0);
+      pointer = spaceUnderActive < pageSize - middle ? pageSize - spaceUnderActive : Math.min(defaultPointerPosition, middle);
+    }
+  }
+  state.current.lastPointer = pointer;
+  state.current.lastActive = active;
+  return pointer;
+}
+function usePagination({ items, active, renderItem, pageSize, loop = true }) {
+  const width = readlineWidth();
+  const bound = (num) => (num % items.length + items.length) % items.length;
+  const renderedItems = items.map((item, index) => {
+    if (item == null)
+      return [];
+    return breakLines(renderItem({ item, index, isActive: index === active }), width).split(`
+`);
+  });
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const renderItemAtIndex = (index) => renderedItems[index] ?? [];
+  const pointer = usePointerPosition({ active, renderedItems, pageSize, loop });
+  const activeItem = renderItemAtIndex(active).slice(0, pageSize);
+  const activeItemPosition = pointer + activeItem.length <= pageSize ? pointer : pageSize - activeItem.length;
+  const pageBuffer = Array.from({ length: pageSize });
+  pageBuffer.splice(activeItemPosition, activeItem.length, ...activeItem);
+  const itemVisited = new Set([active]);
+  let bufferPointer = activeItemPosition + activeItem.length;
+  let itemPointer = bound(active + 1);
+  while (bufferPointer < pageSize && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer > active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(0, pageSize - bufferPointer);
+    pageBuffer.splice(bufferPointer, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer += linesToAdd.length;
+    itemPointer = bound(itemPointer + 1);
+  }
+  bufferPointer = activeItemPosition - 1;
+  itemPointer = bound(active - 1);
+  while (bufferPointer >= 0 && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer < active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(Math.max(0, lines.length - bufferPointer - 1));
+    pageBuffer.splice(bufferPointer - linesToAdd.length + 1, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer -= linesToAdd.length;
+    itemPointer = bound(itemPointer - 1);
+  }
+  return pageBuffer.filter((line) => typeof line === "string").join(`
+`);
+}
+// node_modules/@inquirer/core/dist/lib/create-prompt.js
+var import_mute_stream = __toESM(require_lib(), 1);
+import * as readline2 from "readline";
+import { AsyncResource as AsyncResource3 } from "async_hooks";
+
+// node_modules/signal-exit/dist/mjs/signals.js
+var signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") {
+  signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+}
+if (process.platform === "linux") {
+  signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+}
+
+// node_modules/signal-exit/dist/mjs/index.js
+var processOk = (process4) => !!process4 && typeof process4 === "object" && typeof process4.removeListener === "function" && typeof process4.emit === "function" && typeof process4.reallyExit === "function" && typeof process4.listeners === "function" && typeof process4.kill === "function" && typeof process4.pid === "number" && typeof process4.on === "function";
+var kExitEmitter = Symbol.for("signal-exit emitter");
+var global = globalThis;
+var ObjectDefineProperty = Object.defineProperty.bind(Object);
+
+class Emitter {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global[kExitEmitter]) {
+      return global[kExitEmitter];
+    }
+    ObjectDefineProperty(global, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i = list.indexOf(fn);
+    if (i === -1) {
+      return;
+    }
+    if (i === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i, 1);
+    }
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
+}
+
+class SignalExitBase {
+}
+var signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+};
+
+class SignalExitFallback extends SignalExitBase {
+  onExit() {
+    return () => {};
+  }
+  load() {}
+  unload() {}
+}
+
+class SignalExit extends SignalExitBase {
+  #hupSig = process4.platform === "win32" ? "SIGINT" : "SIGHUP";
+  #emitter = new Emitter;
+  #process;
+  #originalProcessEmit;
+  #originalProcessReallyExit;
+  #sigListeners = {};
+  #loaded = false;
+  constructor(process4) {
+    super();
+    this.#process = process4;
+    this.#sigListeners = {};
+    for (const sig of signals) {
+      this.#sigListeners[sig] = () => {
+        const listeners = this.#process.listeners(sig);
+        let { count } = this.#emitter;
+        const p = process4;
+        if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+          count += p.__signal_exit_emitter__.count;
+        }
+        if (listeners.length === count) {
+          this.unload();
+          const ret = this.#emitter.emit("exit", null, sig);
+          const s = sig === "SIGHUP" ? this.#hupSig : sig;
+          if (!ret)
+            process4.kill(process4.pid, s);
+        }
+      };
+    }
+    this.#originalProcessReallyExit = process4.reallyExit;
+    this.#originalProcessEmit = process4.emit;
+  }
+  onExit(cb, opts) {
+    if (!processOk(this.#process)) {
+      return () => {};
+    }
+    if (this.#loaded === false) {
+      this.load();
+    }
+    const ev = opts?.alwaysLast ? "afterExit" : "exit";
+    this.#emitter.on(ev, cb);
+    return () => {
+      this.#emitter.removeListener(ev, cb);
+      if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+        this.unload();
+      }
+    };
+  }
+  load() {
+    if (this.#loaded) {
+      return;
+    }
+    this.#loaded = true;
+    this.#emitter.count += 1;
+    for (const sig of signals) {
+      try {
+        const fn = this.#sigListeners[sig];
+        if (fn)
+          this.#process.on(sig, fn);
+      } catch (_) {}
+    }
+    this.#process.emit = (ev, ...a) => {
+      return this.#processEmit(ev, ...a);
+    };
+    this.#process.reallyExit = (code) => {
+      return this.#processReallyExit(code);
+    };
+  }
+  unload() {
+    if (!this.#loaded) {
+      return;
+    }
+    this.#loaded = false;
+    signals.forEach((sig) => {
+      const listener = this.#sigListeners[sig];
+      if (!listener) {
+        throw new Error("Listener not defined for signal: " + sig);
+      }
+      try {
+        this.#process.removeListener(sig, listener);
+      } catch (_) {}
+    });
+    this.#process.emit = this.#originalProcessEmit;
+    this.#process.reallyExit = this.#originalProcessReallyExit;
+    this.#emitter.count -= 1;
+  }
+  #processReallyExit(code) {
+    if (!processOk(this.#process)) {
+      return 0;
+    }
+    this.#process.exitCode = code || 0;
+    this.#emitter.emit("exit", this.#process.exitCode, null);
+    return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+  }
+  #processEmit(ev, ...args) {
+    const og = this.#originalProcessEmit;
+    if (ev === "exit" && processOk(this.#process)) {
+      if (typeof args[0] === "number") {
+        this.#process.exitCode = args[0];
+      }
+      const ret = og.call(this.#process, ev, ...args);
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return ret;
+    } else {
+      return og.call(this.#process, ev, ...args);
+    }
+  }
+}
+var process4 = globalThis.process;
+var {
+  onExit,
+  load,
+  unload
+} = signalExitWrap(processOk(process4) ? new SignalExit(process4) : new SignalExitFallback);
+
+// node_modules/@inquirer/core/dist/lib/screen-manager.js
+import { stripVTControlCharacters } from "util";
+
+// node_modules/@inquirer/ansi/dist/index.js
+var ESC2 = "\x1B[";
+var cursorLeft = ESC2 + "G";
+var cursorHide = ESC2 + "?25l";
+var cursorShow = ESC2 + "?25h";
+var cursorUp = (rows = 1) => rows > 0 ? `${ESC2}${rows}A` : "";
+var cursorDown = (rows = 1) => rows > 0 ? `${ESC2}${rows}B` : "";
+var cursorTo = (x, y) => {
+  if (typeof y === "number" && !Number.isNaN(y)) {
+    return `${ESC2}${y + 1};${x + 1}H`;
+  }
+  return `${ESC2}${x + 1}G`;
+};
+var eraseLine = ESC2 + "2K";
+var eraseLines = (lines) => lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + cursorLeft : "";
+
+// node_modules/@inquirer/core/dist/lib/screen-manager.js
+var height = (content) => content.split(`
+`).length;
+var lastLine = (content) => content.split(`
+`).pop() ?? "";
+
+class ScreenManager {
+  height = 0;
+  extraLinesUnderPrompt = 0;
+  cursorPos;
+  rl;
+  constructor(rl) {
+    this.rl = rl;
+    this.cursorPos = rl.getCursorPos();
+  }
+  write(content) {
+    this.rl.output.unmute();
+    this.rl.output.write(content);
+    this.rl.output.mute();
+  }
+  render(content, bottomContent = "") {
+    const promptLine = lastLine(content);
+    const rawPromptLine = stripVTControlCharacters(promptLine);
+    let prompt = rawPromptLine;
+    if (this.rl.line.length > 0) {
+      prompt = prompt.slice(0, -this.rl.line.length);
+    }
+    this.rl.setPrompt(prompt);
+    this.cursorPos = this.rl.getCursorPos();
+    const width = readlineWidth();
+    content = breakLines(content, width);
+    bottomContent = breakLines(bottomContent, width);
+    if (rawPromptLine.length % width === 0) {
+      content += `
+`;
+    }
+    let output = content + (bottomContent ? `
+` + bottomContent : "");
+    const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
+    const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
+    if (bottomContentHeight > 0)
+      output += cursorUp(bottomContentHeight);
+    output += cursorTo(this.cursorPos.cols);
+    this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
+    this.extraLinesUnderPrompt = bottomContentHeight;
+    this.height = height(output);
+  }
+  checkCursorPos() {
+    const cursorPos = this.rl.getCursorPos();
+    if (cursorPos.cols !== this.cursorPos.cols) {
+      this.write(cursorTo(cursorPos.cols));
+      this.cursorPos = cursorPos;
+    }
+  }
+  done({ clearContent }) {
+    this.rl.setPrompt("");
+    let output = cursorDown(this.extraLinesUnderPrompt);
+    output += clearContent ? eraseLines(this.height) : `
+`;
+    output += cursorShow;
+    this.write(output);
+    this.rl.close();
+  }
+}
+
+// node_modules/@inquirer/core/dist/lib/promise-polyfill.js
+class PromisePolyfill extends Promise {
+  static withResolver() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve, reject };
+  }
+}
+
+// node_modules/@inquirer/core/dist/lib/create-prompt.js
+var nativeSetImmediate = globalThis.setImmediate;
+function getCallSites() {
+  const _prepareStackTrace = Error.prepareStackTrace;
+  let result = [];
+  try {
+    Error.prepareStackTrace = (_, callSites) => {
+      const callSitesWithoutCurrent = callSites.slice(1);
+      result = callSitesWithoutCurrent;
+      return callSitesWithoutCurrent;
+    };
+    new Error().stack;
+  } catch {
+    return result;
+  }
+  Error.prepareStackTrace = _prepareStackTrace;
+  return result;
+}
+function createPrompt(view) {
+  const callSites = getCallSites();
+  const prompt = (config, context = {}) => {
+    const { input = process.stdin, signal } = context;
+    const cleanups = new Set;
+    const output = new import_mute_stream.default;
+    output.pipe(context.output ?? process.stdout);
+    output.mute();
+    const rl = readline2.createInterface({
+      terminal: true,
+      input,
+      output
+    });
+    const screen = new ScreenManager(rl);
+    const { promise, resolve, reject } = PromisePolyfill.withResolver();
+    const cancel = () => reject(new CancelPromptError);
+    if (signal) {
+      const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
+      if (signal.aborted) {
+        abort();
+        return Object.assign(promise, { cancel });
+      }
+      signal.addEventListener("abort", abort);
+      cleanups.add(() => signal.removeEventListener("abort", abort));
+    }
+    cleanups.add(onExit((code, signal2) => {
+      reject(new ExitPromptError(`User force closed the prompt with ${code} ${signal2}`));
+    }));
+    const sigint = () => reject(new ExitPromptError(`User force closed the prompt with SIGINT`));
+    rl.on("SIGINT", sigint);
+    cleanups.add(() => rl.removeListener("SIGINT", sigint));
+    return withHooks(rl, (cycle) => {
+      const hooksCleanup = AsyncResource3.bind(() => effectScheduler.clearAll());
+      rl.on("close", hooksCleanup);
+      cleanups.add(() => rl.removeListener("close", hooksCleanup));
+      const startCycle = () => {
+        const checkCursorPos = () => screen.checkCursorPos();
+        rl.input.on("keypress", checkCursorPos);
+        cleanups.add(() => rl.input.removeListener("keypress", checkCursorPos));
+        cycle(() => {
+          try {
+            const nextView = view(config, (value) => {
+              setImmediate(() => resolve(value));
+            });
+            if (nextView === undefined) {
+              const callerFilename = callSites[1]?.getFileName();
+              throw new Error(`Prompt functions must return a string.
+    at ${callerFilename}`);
+            }
+            const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
+            screen.render(content, bottomContent);
+            effectScheduler.run();
+          } catch (error) {
+            reject(error);
+          }
+        });
+      };
+      if ("readableFlowing" in input) {
+        nativeSetImmediate(startCycle);
+      } else {
+        startCycle();
+      }
+      return Object.assign(promise.then((answer) => {
+        effectScheduler.clearAll();
+        return answer;
+      }, (error) => {
+        effectScheduler.clearAll();
+        throw error;
+      }).finally(() => {
+        cleanups.forEach((cleanup) => cleanup());
+        screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
+        output.end();
+      }).then(() => promise), { cancel });
+    });
+  };
+  return prompt;
+}
+// node_modules/@inquirer/core/dist/lib/Separator.js
+import { styleText as styleText2 } from "util";
+class Separator {
+  separator = styleText2("dim", Array.from({ length: 15 }).join(dist_default.line));
+  type = "separator";
+  constructor(separator) {
+    if (separator) {
+      this.separator = separator;
+    }
+  }
+  static isSeparator(choice) {
+    return Boolean(choice && typeof choice === "object" && "type" in choice && choice.type === "separator");
   }
-  return openAll + string + closeAll;
+}
+// node_modules/@inquirer/checkbox/dist/index.js
+import { styleText as styleText3 } from "util";
+var checkboxTheme = {
+  icon: {
+    checked: styleText3("green", dist_default.circleFilled),
+    unchecked: dist_default.circle,
+    cursor: dist_default.pointer,
+    disabledChecked: styleText3("green", dist_default.circleDouble),
+    disabledUnchecked: "-"
+  },
+  style: {
+    disabled: (text) => styleText3("dim", text),
+    renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.short).join(", "),
+    description: (text) => styleText3("cyan", text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${styleText3("bold", key)} ${styleText3("dim", action)}`).join(styleText3("dim", " \u2022 "))
+  },
+  i18n: { disabledError: "This option is disabled and cannot be toggled." },
+  keybindings: []
 };
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
-
+function isSelectable(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+function isNavigable(item) {
+  return !Separator.isSeparator(item);
+}
+function isChecked(item) {
+  return !Separator.isSeparator(item) && item.checked;
+}
+function toggle(item) {
+  return isSelectable(item) ? { ...item, checked: !item.checked } : item;
+}
+function check(checked) {
+  return function(item) {
+    return isSelectable(item) ? { ...item, checked } : item;
+  };
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice))
+      return choice;
+    if (typeof choice === "string") {
+      return {
+        value: choice,
+        name: choice,
+        short: choice,
+        checkedName: choice,
+        disabled: false,
+        checked: false
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    const normalizedChoice = {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      checkedName: choice.checkedName ?? name,
+      disabled: choice.disabled ?? false,
+      checked: choice.checked ?? false
+    };
+    if (choice.description) {
+      normalizedChoice.description = choice.description;
+    }
+    return normalizedChoice;
+  });
+}
+var dist_default4 = createPrompt((config, done) => {
+  const { pageSize = 7, loop = true, required, validate = () => true } = config;
+  const shortcuts = { all: "a", invert: "i", ...config.shortcuts };
+  const theme = makeTheme(checkboxTheme, config.theme);
+  const { keybindings } = theme;
+  const [status, setStatus] = useState("idle");
+  const prefix = usePrefix({ status, theme });
+  const [items, setItems] = useState(normalizeChoices(config.choices));
+  const bounds = useMemo(() => {
+    const first = items.findIndex(isNavigable);
+    const last = items.findLastIndex(isNavigable);
+    if (first === -1) {
+      throw new ValidationError("[checkbox prompt] No selectable choices. All choices are disabled.");
+    }
+    return { first, last };
+  }, [items]);
+  const [active, setActive] = useState(bounds.first);
+  const [errorMsg, setError] = useState();
+  useKeypress(async (key) => {
+    if (isEnterKey(key)) {
+      const selection = items.filter(isChecked);
+      const isValid = await validate([...selection]);
+      if (required && !selection.length) {
+        setError("At least one choice must be selected");
+      } else if (isValid === true) {
+        setStatus("done");
+        done(selection.map((choice) => choice.value));
+      } else {
+        setError(isValid || "You must select a valid value");
+      }
+    } else if (isUpKey(key, keybindings) || isDownKey(key, keybindings)) {
+      if (errorMsg) {
+        setError(undefined);
+      }
+      if (loop || isUpKey(key, keybindings) && active !== bounds.first || isDownKey(key, keybindings) && active !== bounds.last) {
+        const offset = isUpKey(key, keybindings) ? -1 : 1;
+        let next = active;
+        do {
+          next = (next + offset + items.length) % items.length;
+        } while (!isNavigable(items[next]));
+        setActive(next);
+      }
+    } else if (isSpaceKey(key)) {
+      const activeItem = items[active];
+      if (activeItem && !Separator.isSeparator(activeItem)) {
+        if (activeItem.disabled) {
+          setError(theme.i18n.disabledError);
+        } else {
+          setError(undefined);
+          setItems(items.map((choice, i) => i === active ? toggle(choice) : choice));
+        }
+      }
+    } else if (key.name === shortcuts.all) {
+      const selectAll = items.some((choice) => isSelectable(choice) && !choice.checked);
+      setItems(items.map(check(selectAll)));
+    } else if (key.name === shortcuts.invert) {
+      setItems(items.map(toggle));
+    } else if (isNumberKey(key)) {
+      const selectedIndex = Number(key.name) - 1;
+      let selectableIndex = -1;
+      const position = items.findIndex((item) => {
+        if (Separator.isSeparator(item))
+          return false;
+        selectableIndex++;
+        return selectableIndex === selectedIndex;
+      });
+      const selectedItem = items[position];
+      if (selectedItem && isSelectable(selectedItem)) {
+        setActive(position);
+        setItems(items.map((choice, i) => i === position ? toggle(choice) : choice));
+      }
+    }
+  });
+  const message = theme.style.message(config.message, status);
+  let description;
+  const page = usePagination({
+    items,
+    active,
+    renderItem({ item, isActive }) {
+      if (Separator.isSeparator(item)) {
+        return ` ${item.separator}`;
+      }
+      const cursor = isActive ? theme.icon.cursor : " ";
+      if (item.disabled) {
+        const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+        const checkbox2 = item.checked ? theme.icon.disabledChecked : theme.icon.disabledUnchecked;
+        return theme.style.disabled(`${cursor}${checkbox2} ${item.name} ${disabledLabel}`);
+      }
+      if (isActive) {
+        description = item.description;
+      }
+      const checkbox = item.checked ? theme.icon.checked : theme.icon.unchecked;
+      const name = item.checked ? item.checkedName : item.name;
+      const color = isActive ? theme.style.highlight : (x) => x;
+      return color(`${cursor}${checkbox} ${name}`);
+    },
+    pageSize,
+    loop
+  });
+  if (status === "done") {
+    const selection = items.filter(isChecked);
+    const answer = theme.style.answer(theme.style.renderSelectedChoices(selection, items));
+    return [prefix, message, answer].filter(Boolean).join(" ");
+  }
+  const keys = [
+    ["\u2191\u2193", "navigate"],
+    ["space", "select"]
+  ];
+  if (shortcuts.all)
+    keys.push([shortcuts.all, "all"]);
+  if (shortcuts.invert)
+    keys.push([shortcuts.invert, "invert"]);
+  keys.push(["\u23CE", "submit"]);
+  const helpLine = theme.style.keysHelpTip(keys);
+  const lines = [
+    [prefix, message].filter(Boolean).join(" "),
+    page,
+    " ",
+    description ? theme.style.description(description) : "",
+    errorMsg ? theme.style.error(errorMsg) : "",
+    helpLine
+  ].filter(Boolean).join(`
+`).trimEnd();
+  return `${lines}${cursorHide}`;
+});
+// node_modules/@inquirer/select/dist/index.js
+import { styleText as styleText4 } from "util";
+var selectTheme = {
+  icon: { cursor: dist_default.pointer },
+  style: {
+    disabled: (text) => styleText4("dim", text),
+    description: (text) => styleText4("cyan", text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${styleText4("bold", key)} ${styleText4("dim", action)}`).join(styleText4("dim", " \u2022 "))
+  },
+  i18n: { disabledError: "This option is disabled and cannot be selected." },
+  indexMode: "hidden",
+  keybindings: []
+};
+function isSelectable2(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+function isNavigable2(item) {
+  return !Separator.isSeparator(item);
+}
+function normalizeChoices2(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice))
+      return choice;
+    if (typeof choice !== "object" || choice === null || !("value" in choice)) {
+      const name2 = String(choice);
+      return {
+        value: choice,
+        name: name2,
+        short: name2,
+        disabled: false
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    const normalizedChoice = {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      disabled: choice.disabled ?? false
+    };
+    if (choice.description) {
+      normalizedChoice.description = choice.description;
+    }
+    return normalizedChoice;
+  });
+}
+var dist_default5 = createPrompt((config, done) => {
+  const { loop = true, pageSize = 7 } = config;
+  const theme = makeTheme(selectTheme, config.theme);
+  const { keybindings } = theme;
+  const [status, setStatus] = useState("idle");
+  const prefix = usePrefix({ status, theme });
+  const searchTimeoutRef = useRef();
+  const searchEnabled = !keybindings.includes("vim");
+  const items = useMemo(() => normalizeChoices2(config.choices), [config.choices]);
+  const bounds = useMemo(() => {
+    const first = items.findIndex(isNavigable2);
+    const last = items.findLastIndex(isNavigable2);
+    if (first === -1) {
+      throw new ValidationError("[select prompt] No selectable choices. All choices are disabled.");
+    }
+    return { first, last };
+  }, [items]);
+  const defaultItemIndex = useMemo(() => {
+    if (!("default" in config))
+      return -1;
+    return items.findIndex((item) => isSelectable2(item) && item.value === config.default);
+  }, [config.default, items]);
+  const [active, setActive] = useState(defaultItemIndex === -1 ? bounds.first : defaultItemIndex);
+  const selectedChoice = items[active];
+  const [errorMsg, setError] = useState();
+  useKeypress((key, rl) => {
+    clearTimeout(searchTimeoutRef.current);
+    if (errorMsg) {
+      setError(undefined);
+    }
+    if (isEnterKey(key)) {
+      if (selectedChoice.disabled) {
+        setError(theme.i18n.disabledError);
+      } else {
+        setStatus("done");
+        done(selectedChoice.value);
+      }
+    } else if (isUpKey(key, keybindings) || isDownKey(key, keybindings)) {
+      rl.clearLine(0);
+      if (loop || isUpKey(key, keybindings) && active !== bounds.first || isDownKey(key, keybindings) && active !== bounds.last) {
+        const offset = isUpKey(key, keybindings) ? -1 : 1;
+        let next = active;
+        do {
+          next = (next + offset + items.length) % items.length;
+        } while (!isNavigable2(items[next]));
+        setActive(next);
+      }
+    } else if (isNumberKey(key) && !Number.isNaN(Number(rl.line))) {
+      const selectedIndex = Number(rl.line) - 1;
+      let selectableIndex = -1;
+      const position = items.findIndex((item2) => {
+        if (Separator.isSeparator(item2))
+          return false;
+        selectableIndex++;
+        return selectableIndex === selectedIndex;
+      });
+      const item = items[position];
+      if (item != null && isSelectable2(item)) {
+        setActive(position);
+      }
+      searchTimeoutRef.current = setTimeout(() => {
+        rl.clearLine(0);
+      }, 700);
+    } else if (isBackspaceKey(key)) {
+      rl.clearLine(0);
+    } else if (searchEnabled) {
+      const searchTerm = rl.line.toLowerCase();
+      const matchIndex = items.findIndex((item) => {
+        if (Separator.isSeparator(item) || !isSelectable2(item))
+          return false;
+        return item.name.toLowerCase().startsWith(searchTerm);
+      });
+      if (matchIndex !== -1) {
+        setActive(matchIndex);
+      }
+      searchTimeoutRef.current = setTimeout(() => {
+        rl.clearLine(0);
+      }, 700);
+    }
+  });
+  useEffect(() => () => {
+    clearTimeout(searchTimeoutRef.current);
+  }, []);
+  const message = theme.style.message(config.message, status);
+  const helpLine = theme.style.keysHelpTip([
+    ["\u2191\u2193", "navigate"],
+    ["\u23CE", "select"]
+  ]);
+  let separatorCount = 0;
+  const page = usePagination({
+    items,
+    active,
+    renderItem({ item, isActive, index }) {
+      if (Separator.isSeparator(item)) {
+        separatorCount++;
+        return ` ${item.separator}`;
+      }
+      const cursor = isActive ? theme.icon.cursor : " ";
+      const indexLabel = theme.indexMode === "number" ? `${index + 1 - separatorCount}. ` : "";
+      if (item.disabled) {
+        const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+        const disabledCursor = isActive ? theme.icon.cursor : "-";
+        return theme.style.disabled(`${disabledCursor} ${indexLabel}${item.name} ${disabledLabel}`);
+      }
+      const color = isActive ? theme.style.highlight : (x) => x;
+      return color(`${cursor} ${indexLabel}${item.name}`);
+    },
+    pageSize,
+    loop
+  });
+  if (status === "done") {
+    return [prefix, message, theme.style.answer(selectedChoice.short)].filter(Boolean).join(" ");
+  }
+  const { description } = selectedChoice;
+  const lines = [
+    [prefix, message].filter(Boolean).join(" "),
+    page,
+    " ",
+    description ? theme.style.description(description) : "",
+    errorMsg ? theme.style.error(errorMsg) : "",
+    helpLine
+  ].filter(Boolean).join(`
+`).trimEnd();
+  return `${lines}${cursorHide}`;
+});
 // src/cli/index.ts
 init_engine();
-import { resolve, join as join6 } from "path";
 init_auto_embed();
 init_store();
 init_model();
@@ -3652,12 +5716,155 @@ function requireRepo(rootPath) {
     process.exit(1);
   }
 }
-program2.command("init").description("Initialize a new TrellisVCS repository in the current directory").option("-p, --path <path>", "Path to initialize", ".").action(async (opts) => {
+program2.command("init").description("Initialize a new TrellisVCS repository in the current directory").option("-p, --path <path>", "Path to initialize", ".").option("--ides <ides...>", "IDEs to scaffold for (cursor, windsurf, claude, copilot, codex, gemini)").option("--framework <framework>", "Project framework (react, vue, svelte, next, nuxt, remotion, expo, bun, node, cli, library, animation, games, none)", "none").option("--footprint <footprint>", "Workspace footprint (minimal, standard, full)", "standard").option("--no-interactive", "Skip interactive prompts").action(async (opts) => {
   const rootPath = resolve(opts.path);
+  const isInteractive = process.stdout.isTTY && !process.argv.includes("--no-interactive");
   if (TrellisVcsEngine.isRepo(rootPath)) {
-    console.log(source_default.yellow("Already a TrellisVCS repository."));
+    console.log(source_default.yellow("Already a Trellis workspace."));
     return;
   }
+  if (!hasProfile()) {
+    const trellisDir = join6(rootPath, ".trellis");
+    const identity = hasIdentity(trellisDir) ? loadIdentity(trellisDir) : null;
+    if (isInteractive) {
+      console.log(source_default.cyan(`
+  Welcome to Trellis! Let's get you set up.`));
+      const newProfile = await promptForProfile({
+        name: identity?.displayName
+      });
+      saveProfile(newProfile);
+      console.log(source_default.green(`  \u2713 Profile saved to ~/.trellis/profile.json
+`));
+    } else {
+      updateProfile({ name: identity?.displayName || "Unknown" });
+    }
+  }
+  const preInfer = await inferProjectContext(rootPath);
+  const detectedFramework = preInfer.framework;
+  let selectedIdes = opts.ides || [];
+  let footprint = opts.footprint || "standard";
+  let framework = opts.framework || detectedFramework || "none";
+  let plugins = opts.plugins || [];
+  if (!isInteractive && framework === "none" && detectedFramework) {
+    framework = detectedFramework;
+  }
+  if (!isInteractive && selectedIdes.length === 0) {
+    selectedIdes = ["cursor"];
+  }
+  if (isInteractive) {
+    console.log(source_default.cyan(`
+  Configuring workspace...`));
+    const frameworkChoices = [
+      { name: "React", value: "react" },
+      { name: "Vue", value: "vue" },
+      { name: "Svelte", value: "svelte" },
+      { name: "Next.js", value: "next" },
+      { name: "Nuxt", value: "nuxt" },
+      { name: "Remotion", value: "remotion" },
+      { name: "Expo / React Native", value: "expo" },
+      { name: "Bun runtime", value: "bun" },
+      { name: "Node.js server", value: "node" },
+      { name: "CLI tool", value: "cli" },
+      { name: "Library / Package", value: "library" },
+      { name: "Animation studio", value: "animation" },
+      { name: "Games", value: "games" },
+      { name: "None / Vanilla", value: "none" }
+    ];
+    framework = await dist_default5({
+      message: detectedFramework ? `What type of project are you building? (detected: ${detectedFramework})` : "What type of project are you building?",
+      choices: frameworkChoices,
+      default: opts.framework || detectedFramework || "none"
+    });
+    const ideChoices = [
+      {
+        name: "Cursor",
+        value: "cursor",
+        checked: selectedIdes.includes("cursor") || selectedIdes.length === 0
+      },
+      {
+        name: "Windsurf",
+        value: "windsurf",
+        checked: selectedIdes.includes("windsurf")
+      },
+      {
+        name: "Claude Desktop",
+        value: "claude",
+        checked: selectedIdes.includes("claude")
+      },
+      {
+        name: "VS Code Copilot",
+        value: "copilot",
+        checked: selectedIdes.includes("copilot")
+      },
+      {
+        name: "Google Gemini (Code Assist)",
+        value: "gemini",
+        checked: selectedIdes.includes("gemini")
+      },
+      {
+        name: "OpenAI Codex",
+        value: "codex",
+        checked: selectedIdes.includes("codex")
+      }
+    ];
+    selectedIdes = await dist_default4({
+      message: "Which IDEs/agents do you want to scaffold for?",
+      choices: ideChoices
+    });
+    footprint = await dist_default5({
+      message: "How minimal do you want your workspace?",
+      choices: [
+        { name: "Minimal (just agent rules)", value: "minimal" },
+        { name: "Standard (includes skills + workflows)", value: "standard" },
+        { name: "Full (kitchen sink)", value: "full" }
+      ],
+      default: footprint
+    });
+    plugins = await dist_default4({
+      message: "Select features:",
+      choices: [
+        {
+          name: "Sub-projects (monorepo, workspaces)",
+          value: "sub-projects",
+          checked: plugins.includes("sub-projects")
+        },
+        { name: "P2P Sync", value: "p2p", checked: plugins.includes("p2p") },
+        {
+          name: "MCP Server",
+          value: "mcp",
+          checked: plugins.includes("mcp")
+        },
+        {
+          name: "UI Components",
+          value: "ui-components",
+          checked: plugins.includes("ui-components")
+        },
+        {
+          name: "Media Pipelines",
+          value: "media-pipelines",
+          checked: plugins.includes("media-pipelines")
+        },
+        {
+          name: "Brand System",
+          value: "brand-system",
+          checked: plugins.includes("brand-system")
+        },
+        {
+          name: "Agent Memory",
+          value: "agent-memory",
+          checked: plugins.includes("agent-memory")
+        },
+        {
+          name: "Workflows",
+          value: "workflows",
+          checked: plugins.includes("workflows") || footprint !== "minimal"
+        }
+      ]
+    });
+    if (plugins.includes("sub-projects") && !plugins.includes("workflows")) {
+      plugins.push("workflows");
+    }
+  }
   const engine = new TrellisVcsEngine({ rootPath });
   let renderedProgress = false;
   const result = await engine.initRepo({
@@ -3667,7 +5874,7 @@ program2.command("init").description("Initialize a new TrellisVCS repository in
         process.stdout.write("\r\x1B[2K");
         return;
       }
-      const label = progress.phase === "discovering" ? "Discovering\u2026" : progress.phase === "hashing" ? "Hashing\u2026" : "Scanning\u2026";
+      const label = progress.phase === "discovering" ? "Discovering\u2026" : progress.phase === "hashing" ? "Hashing\u2026" : progress.phase === "scaffolding" ? "Scaffolding\u2026" : "Scanning\u2026";
       process.stdout.write(`\r\x1B[2K  ${source_default.dim(label)} ${progress.message}`);
     }
   });
@@ -3675,12 +5882,40 @@ program2.command("init").description("Initialize a new TrellisVCS repository in
     process.stdout.write(`
 `);
   }
+  if (selectedIdes && selectedIdes.length > 0) {
+    for (const selectedIde of selectedIdes) {
+      console.log(source_default.dim(`  Scaffolding ${selectedIde} dotfolder...`));
+      writeIdeScaffold(rootPath, {
+        ide: selectedIde,
+        footprint,
+        framework,
+        plugins,
+        rootPath,
+        context: result.context,
+        profile: loadProfile()
+      });
+    }
+  }
   console.log(source_default.green("\u2713 Initialized Trellis repository"));
-  console.log(`  ${source_default.dim("Path:")}     ${rootPath}`);
-  console.log(`  ${source_default.dim("Ops:")}      ${result.opsCreated} initial operations scanned`);
-  console.log(`  ${source_default.dim("Config:")}   .trellis/config.json`);
-  console.log(`  ${source_default.dim("Op log:")}   .trellis/ops.json`);
-  console.log(`  ${source_default.dim("Graph DB:")} .trellis/graph.db`);
+  console.log(`  ${source_default.dim("Path:")}           ${rootPath}`);
+  console.log(`  ${source_default.dim("Ops:")}            ${result.opsCreated} initial operations scanned`);
+  console.log(`  ${source_default.dim("Config:")}         .trellis/config.json`);
+  console.log(`  ${source_default.dim("Op log:")}         .trellis/ops.json`);
+  console.log(`  ${source_default.dim("Graph DB:")}       .trellis/graph.db`);
+  console.log(`  ${source_default.dim("Agent context:")}  .trellis/agents/AGENTS.md`);
+  if (selectedIdes.length > 0) {
+    const ideFolders = selectedIdes.map((id) => {
+      const ide = id;
+      return ide === "cursor" ? ".cursor" : ide === "windsurf" ? ".windsurf" : ide === "claude" ? ".claude" : ide === "codex" ? ".codex" : ide === "gemini" ? ".gemini" : ".github/copilot";
+    });
+    console.log(`  ${source_default.dim("IDE rules:")}        ${ideFolders.join(", ")}`);
+  }
+  if (result.context.domain) {
+    console.log(`  ${source_default.dim("Domain:")}         ${source_default.cyan(result.context.domain)} ${source_default.dim("(inferred)")}`);
+  }
+  if (result.context.ecosystem && result.context.ecosystem !== "unknown") {
+    console.log(`  ${source_default.dim("Ecosystem:")}      ${result.context.ecosystem}`);
+  }
   console.log();
   console.log(source_default.bold("Next steps:"));
   console.log();
@@ -3690,9 +5925,30 @@ program2.command("init").description("Initialize a new TrellisVCS repository in
   console.log(`  ${source_default.cyan("trellis milestone")}  Create narrative checkpoints`);
   console.log(`  ${source_default.cyan("trellis garden")}     Discover abandoned work`);
   console.log(`  ${source_default.cyan("trellis issue")}      Create and track issues`);
+  if (result.context.confidence !== "high") {
+    console.log(`  ${source_default.cyan("trellis season")}     Enrich project context for agents`);
+  }
   console.log();
   console.log(source_default.dim("The causal stream is now active. Every file change will be tracked."));
 });
+program2.command("seed").description("Refresh agent context files with current project state").option("-p, --path <path>", "Repository path", ".").option("--ide <ide>", "IDE to update (cursor, windsurf, claude, copilot)", "none").option("-f, --force", "Force rewrite even if files do not exist", false).action(async (opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const ide = opts.ide || "none";
+  const force = opts.force || false;
+  console.log(source_default.dim("Seeding agent context..."));
+  const result = await seedContext({ rootPath, ide, force });
+  if (result.success) {
+    console.log(source_default.green("\u2713 Context seeded"));
+    console.log(`  ${source_default.dim("Files updated:")} ${result.filesUpdated.length}`);
+    for (const f of result.filesUpdated) {
+      console.log(`    ${source_default.dim("-")} ${f}`);
+    }
+    console.log(`  ${source_default.dim("Timestamp:")} ${result.timestamp}`);
+  } else {
+    console.log(source_default.red("\u2717 Failed to seed context"));
+  }
+});
 program2.command("repair").description("Attempt to repair a corrupted .trellis/ops.json file").option("-p, --path <path>", "Repository path", ".").action((opts) => {
   const rootPath = resolve(opts.path);
   requireRepo(rootPath);
@@ -5060,9 +7316,9 @@ program2.command("ui").description("Launch the interactive graph explorer in you
     console.log(source_default.dim(`  Press Ctrl+C to stop
 `));
     if (opts.open !== false) {
-      const { exec } = __require("child_process");
+      const { exec: exec2 } = __require("child_process");
       const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-      exec(`${cmd} ${url}`);
+      exec2(`${cmd} ${url}`);
     }
     process.on("SIGINT", () => {
       server.stop();
@@ -5436,8 +7692,8 @@ program2.command("repl").description("Interactive EQL-S query shell").option("-p
   console.log(source_default.dim('Type EQL-S queries or "find ?e where attr = value" shorthand.'));
   console.log(source_default.dim(`Type .exit to quit, .help for help.
 `));
-  const readline = await import("readline");
-  const rl = readline.createInterface({
+  const readline3 = await import("readline");
+  const rl = readline3.createInterface({
     input: process.stdin,
     output: process.stdout,
     prompt: source_default.green("eql> ")
@@ -5760,8 +8016,8 @@ db.command("init").description("Initialize a new Trellis DB in the current direc
 });
 db.command("serve").description("Start the Trellis DB HTTP + WebSocket server").option("-p, --port <port>", "Override port from config").option("--config-dir <dir>", "Directory containing .trellis-db.json", ".").action(async (opts) => {
   const { readConfig } = await import("../config-8hczw0rs.js");
-  const { TenantPool } = await import("../tenancy-tjr7kk2v.js");
-  const { startServer } = await import("../server-3vkpnpbz.js");
+  const { TenantPool } = await import("../tenancy-7d1g4ayp.js");
+  const { startServer } = await import("../server-mrctdwzr.js");
   const config = readConfig(opts.configDir);
   if (!config) {
     console.error(source_default.red("No .trellis-db.json found. Run `trellis db init` first."));
@@ -5782,7 +8038,7 @@ db.command("serve").description("Start the Trellis DB HTTP + WebSocket server").
   }
 });
 db.command("create <type> [json]").description("Create an entity (json can be a JSON string or @file.json)").option("--config-dir <dir>", "Config directory", ".").option("--tenant <id>", "Tenant ID").action(async (type, jsonArg, opts) => {
-  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const { TrellisDb } = await import("../sdk-snn5gad3.js");
   const db2 = TrellisDb.fromConfig(opts.configDir);
   let attributes = {};
   if (jsonArg) {
@@ -5795,7 +8051,7 @@ db.command("create <type> [json]").description("Create an entity (json can be a
   db2.close();
 });
 db.command("read <id>").description("Read an entity by ID").option("--config-dir <dir>", "Config directory", ".").action(async (id, opts) => {
-  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const { TrellisDb } = await import("../sdk-snn5gad3.js");
   const db2 = TrellisDb.fromConfig(opts.configDir);
   const entity = await db2.read(id);
   if (!entity) {
@@ -5806,7 +8062,7 @@ db.command("read <id>").description("Read an entity by ID").option("--config-dir
   db2.close();
 });
 db.command("update <id> <json>").description("Update entity attributes (JSON string or @file.json)").option("--config-dir <dir>", "Config directory", ".").action(async (id, jsonArg, opts) => {
-  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const { TrellisDb } = await import("../sdk-snn5gad3.js");
   const db2 = TrellisDb.fromConfig(opts.configDir);
   const { readFileSync: readFileSync4 } = await import("fs");
   const raw = jsonArg.startsWith("@") ? readFileSync4(jsonArg.slice(1), "utf8") : jsonArg;
@@ -5815,14 +8071,14 @@ db.command("update <id> <json>").description("Update entity attributes (JSON str
   db2.close();
 });
 db.command("delete <id>").description("Delete an entity by ID").option("--config-dir <dir>", "Config directory", ".").action(async (id, opts) => {
-  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const { TrellisDb } = await import("../sdk-snn5gad3.js");
   const db2 = TrellisDb.fromConfig(opts.configDir);
   await db2.delete(id);
   console.log(source_default.green(`\u2713 Deleted: ${source_default.bold(id)}`));
   db2.close();
 });
 db.command("list").description("List entities").option("--type <type>", "Filter by entity type").option("--limit <n>", "Max results", "50").option("--offset <n>", "Offset", "0").option("--config-dir <dir>", "Config directory", ".").action(async (opts) => {
-  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const { TrellisDb } = await import("../sdk-snn5gad3.js");
   const db2 = TrellisDb.fromConfig(opts.configDir);
   const result = await db2.list(opts.type, {
     limit: parseInt(opts.limit),
@@ -5832,7 +8088,7 @@ db.command("list").description("List entities").option("--type <type>", "Filter
   db2.close();
 });
 db.command("query <eql>").description("Run an EQL-S query").option("--config-dir <dir>", "Config directory", ".").action(async (eql, opts) => {
-  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const { TrellisDb } = await import("../sdk-snn5gad3.js");
   const db2 = TrellisDb.fromConfig(opts.configDir);
   const result = await db2.query(eql);
   console.log(JSON.stringify(result.bindings, null, 2));
@@ -5842,7 +8098,7 @@ db.command("query <eql>").description("Run an EQL-S query").option("--config-dir
 db.command("upload <file>").description("Upload a file to the blob store").option("--config-dir <dir>", "Config directory", ".").option("--type <mime>", "MIME type (auto-detected if omitted)").action(async (filePath, opts) => {
   const { readFileSync: readFileSync4 } = await import("fs");
   const { extname } = await import("path");
-  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const { TrellisDb } = await import("../sdk-snn5gad3.js");
   const mimeMap = {
     ".png": "image/png",
     ".jpg": "image/jpeg",
@@ -5863,8 +8119,8 @@ db.command("upload <file>").description("Upload a file to the blob store").optio
 });
 db.command("import <file>").description("Import data from CSV, JSON, NDJSON, or Parquet").requiredOption("--type <type>", "Entity type to assign to each record").option("--id-field <field>", "Field to use as entity ID").option("--limit <n>", "Max rows to import").option("--config-dir <dir>", "Config directory", ".").option("--tenant <id>", "Tenant ID").action(async (filePath, opts) => {
   const { readConfig } = await import("../config-8hczw0rs.js");
-  const { TenantPool } = await import("../tenancy-tjr7kk2v.js");
-  const { importFile } = await import("../import-fyg5sgq4.js");
+  const { TenantPool } = await import("../tenancy-7d1g4ayp.js");
+  const { importFile } = await import("../import-s2b8e0ft.js");
   const config = readConfig(opts.configDir);
   if (!config?.dbPath) {
     console.error(source_default.red("No .trellis-db.json found. Run `trellis db init` first."));
@@ -5889,7 +8145,7 @@ db.command("import <file>").description("Import data from CSV, JSON, NDJSON, or
   pool.closeAll();
 });
 db.command("deploy").description("Deploy Trellis DB to a Sprites cloud environment").requiredOption("--name <name>", "Sprite name (becomes <name>.sprites.app)").option("--key <key>", "API key for the deployed server (auto-generated if omitted)").option("--jwt-secret <secret>", "JWT secret (auto-generated if omitted)").option("--port <port>", "Port to run on inside Sprite", "3000").option("--config-dir <dir>", "Config directory", ".").action(async (opts) => {
-  const { deploy } = await import("../deploy-99j5dc9c.js");
+  const { deploy } = await import("../deploy-999q207z.js");
   const { readConfig } = await import("../config-8hczw0rs.js");
   const config = readConfig(opts.configDir);
   console.log(source_default.bold(`Deploying to Sprites: ${opts.name}...`));
@@ -5916,4 +8172,514 @@ db.command("deploy").description("Deploy Trellis DB to a Sprites cloud environme
     process.exit(1);
   }
 });
+var vmProgram = new Command("vm");
+vmProgram.description("Manage Sprites VMs").option("-s, --sprite <name>", "Sprite name to operate on");
+async function getSpriteName(spriteOption) {
+  if (spriteOption)
+    return spriteOption;
+  const { getActiveSprite } = await import("../vm-config-6xhsj6b3.js");
+  const active = getActiveSprite();
+  if (active)
+    return active;
+  throw new Error("No sprite specified. Use --sprite <name> or set an active sprite with `trellis vm use <name>`");
+}
+vmProgram.command("create <name>").description("Create a new Sprite and deploy Trellis DB").option("-k, --api-key <key>", "API key (auto-generated if omitted)").option("-p, --port <port>", "Port (default: 3000)", "3000").action(async (name, cmdOpts) => {
+  const { runSpriteCmd, assertSpriteCli } = await import("../sprites-vc4qbrp1.js");
+  const { trackSprite } = await import("../vm-config-6xhsj6b3.js");
+  const { deploy } = await import("../deploy-999q207z.js");
+  try {
+    await assertSpriteCli();
+    console.log(`Creating Sprite: ${name}...`);
+    await runSpriteCmd(["exec", "--sprite", name, "echo", "Sprite created"]);
+    console.log(`Deploying Trellis DB to ${name}...`);
+    const result = await deploy({
+      name,
+      apiKey: cmdOpts.apiKey,
+      port: parseInt(cmdOpts.port),
+      onProgress: (msg) => console.log(source_default.dim(`  ${msg}`))
+    });
+    trackSprite(name, {
+      url: result.url,
+      hasTrellis: true,
+      apiKey: result.apiKey
+    });
+    console.log("");
+    console.log(source_default.green(`\u2713 Sprite ${name} created and Trellis DB deployed`));
+    console.log(source_default.dim(`  URL:    ${result.url}`));
+    console.log(source_default.dim(`  Key:    ${result.apiKey}`));
+    console.log("");
+  } catch (err) {
+    console.error(source_default.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+vmProgram.command("list").description("List all tracked Sprites").action(async () => {
+  const { loadVmConfig } = await import("../vm-config-6xhsj6b3.js");
+  const config = loadVmConfig();
+  const sprites = config.sprites;
+  if (Object.keys(sprites).length === 0) {
+    console.log("No Sprites tracked. Use `trellis vm create <name>` to create one.");
+    return;
+  }
+  console.log("Tracked Sprites:");
+  for (const [name, sprite] of Object.entries(sprites)) {
+    const activeMarker = config.activeSprite === name ? source_default.green("*") : " ";
+    const trellisStatus = sprite.hasTrellis ? source_default.green("\u2713 Trellis") : source_default.dim("\u25CB No Trellis");
+    console.log(`${activeMarker} ${name} ${trellisStatus}`);
+    console.log(`    URL: ${sprite.url}`);
+    if (sprite.lastCheckpoint) {
+      console.log(`    Last Checkpoint: ${sprite.lastCheckpoint}`);
+    }
+    console.log();
+  }
+});
+vmProgram.command("use <name>").description("Set the active Sprite").action(async (name) => {
+  const { runSpriteCmd, assertSpriteCli } = await import("../sprites-vc4qbrp1.js");
+  const { setActiveSprite } = await import("../vm-config-6xhsj6b3.js");
+  try {
+    await assertSpriteCli();
+    try {
+      await runSpriteCmd(["list"]);
+    } catch {
+      throw new Error(`Sprite ${name} does not exist`);
+    }
+    setActiveSprite(name);
+    console.log(source_default.green(`\u2713 Active Sprite set to: ${name}`));
+  } catch (err) {
+    console.error(source_default.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+vmProgram.command("destroy <name>").description("Destroy a Sprite").action(async (name) => {
+  const { runSpriteCmd, assertSpriteCli } = await import("../sprites-vc4qbrp1.js");
+  const { untrackSprite } = await import("../vm-config-6xhsj6b3.js");
+  try {
+    await assertSpriteCli();
+    const { createInterface: createInterface2 } = await import("readline");
+    const rl = createInterface2({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve2) => {
+      rl.question(`Destroy Sprite "${name}"? Cannot be undone. (y/N) `, (a) => {
+        rl.close();
+        resolve2(a.trim().toLowerCase());
+      });
+    });
+    if (answer !== "y" && answer !== "yes") {
+      console.log("Cancelled.");
+      return;
+    }
+    await runSpriteCmd(["destroy", "-s", name, "-y"]);
+    untrackSprite(name);
+    console.log(source_default.green(`\u2713 Sprite ${name} destroyed`));
+  } catch (err) {
+    console.error(source_default.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+vmProgram.command("exec <command...>").description("Execute a command on the active Sprite").action(async (command) => {
+  const { runSpriteInteractive, assertSpriteCli } = await import("../sprites-vc4qbrp1.js");
+  try {
+    const spriteName = await getSpriteName(vmProgram.opts().sprite);
+    console.log(`Executing on ${spriteName}: ${command.join(" ")}`);
+    await runSpriteInteractive(["exec", "--sprite", spriteName, ...command]);
+  } catch (err) {
+    console.error(source_default.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+vmProgram.command("console").description("Open an interactive console on the active Sprite").action(async () => {
+  const { runSpriteInteractive, assertSpriteCli } = await import("../sprites-vc4qbrp1.js");
+  try {
+    const spriteName = await getSpriteName(vmProgram.opts().sprite);
+    console.log(`Opening console on ${spriteName}...`);
+    await runSpriteInteractive(["console", "--sprite", spriteName]);
+  } catch (err) {
+    console.error(source_default.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+vmProgram.command("sessions").description("Manage Sprite sessions").argument("<action>", "Action: list, attach, or kill").argument("[sessionId]", "Session ID (required for attach/kill)").action(async (action, sessionId) => {
+  const { runSpriteCmd, runSpriteInteractive, assertSpriteCli } = await import("../sprites-vc4qbrp1.js");
+  try {
+    const spriteName = await getSpriteName(vmProgram.opts().sprite);
+    switch (action) {
+      case "list":
+        await runSpriteCmd(["sessions", "list", "--sprite", spriteName]);
+        break;
+      case "attach":
+        if (!sessionId)
+          throw new Error("Session ID required for attach");
+        await runSpriteInteractive([
+          "sessions",
+          "attach",
+          "--sprite",
+          spriteName,
+          sessionId
+        ]);
+        break;
+      case "kill":
+        if (!sessionId)
+          throw new Error("Session ID required for kill");
+        await runSpriteCmd([
+          "sessions",
+          "kill",
+          "--sprite",
+          spriteName,
+          sessionId
+        ]);
+        console.log(source_default.green(`\u2713 Killed session ${sessionId}`));
+        break;
+      default:
+        throw new Error(`Invalid action: ${action}`);
+    }
+  } catch (err) {
+    console.error(source_default.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+vmProgram.command("url").description("Get or update the URL for the active Sprite").option("--public", "Get public URL (default)").option("--private", "Get private URL").option("--update-auth", "Update authentication").action(async (cmdOpts) => {
+  const { runSpriteCmd, assertSpriteCli } = await import("../sprites-vc4qbrp1.js");
+  try {
+    const spriteName = await getSpriteName(vmProgram.opts().sprite);
+    if (cmdOpts.updateAuth) {
+      await runSpriteCmd(["url", "update", "--auth", "--sprite", spriteName]);
+      console.log(source_default.green(`\u2713 Updated authentication for ${spriteName}`));
+    } else {
+      const urlType = cmdOpts.private ? "private" : "public";
+      const url = await runSpriteCmd([
+        "url",
+        urlType,
+        "--sprite",
+        spriteName
+      ]);
+      console.log(url.trim());
+    }
+  } catch (err) {
+    console.error(source_default.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+vmProgram.command("proxy <ports...>").description("Proxy local ports to the active Sprite").action(async (ports) => {
+  const { runSpriteInteractive, assertSpriteCli } = await import("../sprites-vc4qbrp1.js");
+  try {
+    const spriteName = await getSpriteName(vmProgram.opts().sprite);
+    console.log(`Proxying ports ${ports.join(", ")} to ${spriteName}...`);
+    await runSpriteInteractive(["proxy", "--sprite", spriteName, ...ports]);
+  } catch (err) {
+    console.error(source_default.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+vmProgram.command("checkpoint").description("Manage Sprite checkpoints").argument("<action>", "Action: create, list, or restore").option("-m, --milestone <msg>", "Message for linked milestone (create only)").option("-c, --checkpoint <id>", "Checkpoint ID (restore only)").action(async (action, cmdOpts) => {
+  const { runSpriteCmd, assertSpriteCli } = await import("../sprites-vc4qbrp1.js");
+  const { loadVmConfig, trackSprite } = await import("../vm-config-6xhsj6b3.js");
+  try {
+    const spriteName = await getSpriteName(vmProgram.opts().sprite);
+    switch (action) {
+      case "create":
+        console.log(`Creating checkpoint for ${spriteName}...`);
+        const output = await runSpriteCmd([
+          "checkpoint",
+          "create",
+          "--sprite",
+          spriteName
+        ]);
+        const match = output.match(/checkpoint-(\S+)\s+created/);
+        const checkpointId = match ? match[1] : null;
+        let milestoneId;
+        if (cmdOpts.milestone) {
+          milestoneId = `milestone-${Date.now()}`;
+          console.log(`Would create milestone: ${cmdOpts.milestone}`);
+        }
+        const config = loadVmConfig();
+        const spriteConfig = config.sprites[spriteName];
+        trackSprite(spriteName, {
+          ...spriteConfig,
+          lastCheckpoint: checkpointId ?? undefined,
+          linkedMilestone: milestoneId
+        });
+        console.log(source_default.green(`\u2713 Checkpoint: ${checkpointId || "unknown"}`));
+        break;
+      case "list":
+        await runSpriteCmd(["checkpoint", "list", "--sprite", spriteName]);
+        break;
+      case "restore":
+        if (!cmdOpts.checkpoint)
+          throw new Error("Checkpoint ID required: --checkpoint <id>");
+        await runSpriteCmd([
+          "checkpoint",
+          "restore",
+          "--sprite",
+          spriteName,
+          cmdOpts.checkpoint
+        ]);
+        console.log(source_default.green(`\u2713 Restored: ${cmdOpts.checkpoint}`));
+        break;
+      default:
+        throw new Error(`Invalid action: ${action}`);
+    }
+  } catch (err) {
+    console.error(source_default.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+vmProgram.command("cp <src> <dest>").description("Copy files (use :prefix for remote paths)").action(async (src, dest) => {
+  const { runSpriteCmd, runSpriteCopy, assertSpriteCli } = await import("../sprites-vc4qbrp1.js");
+  try {
+    const spriteName = await getSpriteName(vmProgram.opts().sprite);
+    const isToSprite = !src.startsWith(":") && dest.startsWith(":");
+    const isFromSprite = src.startsWith(":") && !dest.startsWith(":");
+    if (isToSprite) {
+      await runSpriteCopy(src, spriteName, dest.slice(1));
+      console.log(source_default.green(`\u2713 Copied ${src} to ${spriteName}:${dest.slice(1)}`));
+    } else if (isFromSprite) {
+      await runSpriteCopy(src.slice(1), spriteName, dest);
+      console.log(source_default.green(`\u2713 Copied ${spriteName}:${src.slice(1)} to ${dest}`));
+    } else {
+      await runSpriteCmd(["cp", src, dest]);
+      console.log(source_default.green(`\u2713 Copied ${src} to ${dest}`));
+    }
+  } catch (err) {
+    console.error(source_default.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+vmProgram.command("status").description("Show detailed status of the active Sprite").action(async () => {
+  const { runSpriteCmd, assertSpriteCli } = await import("../sprites-vc4qbrp1.js");
+  const { loadVmConfig } = await import("../vm-config-6xhsj6b3.js");
+  try {
+    const spriteName = await getSpriteName(vmProgram.opts().sprite);
+    const config = loadVmConfig();
+    const spriteConfig = config.sprites[spriteName];
+    if (!spriteConfig) {
+      console.log(source_default.red(`Sprite ${spriteName} not in config`));
+      return;
+    }
+    console.log(`Status for: ${source_default.cyan(spriteName)}`);
+    console.log(`  Active: ${config.activeSprite === spriteName ? source_default.green("yes") : source_default.dim("no")}`);
+    console.log(`  URL: ${spriteConfig.url}`);
+    console.log(`  Trellis: ${spriteConfig.hasTrellis ? source_default.green("yes") : source_default.dim("no")}`);
+    if (spriteConfig.hasTrellis) {
+      console.log(`  API Key: ${spriteConfig.apiKey ?? source_default.dim("not available")}`);
+    }
+    if (spriteConfig.lastCheckpoint) {
+      console.log(`  Checkpoint: ${spriteConfig.lastCheckpoint}`);
+    }
+  } catch (err) {
+    console.error(source_default.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+vmProgram.command("code [name]").description("Create Sprite, deploy Trellis, open in browser").action(async (nameOpt) => {
+  const { runSpriteCmd, assertSpriteCli } = await import("../sprites-vc4qbrp1.js");
+  const { loadVmConfig, trackSprite, getActiveSprite } = await import("../vm-config-6xhsj6b3.js");
+  const { deploy } = await import("../deploy-999q207z.js");
+  const openUrl = (url) => {
+    if (process.platform === "darwin") {
+      Bun.spawn(["open", url], { stdio: "ignore" });
+    } else if (process.platform === "linux") {
+      Bun.spawn(["xdg-open", url], { stdio: "ignore" });
+    } else {
+      console.log(url);
+    }
+  };
+  try {
+    await assertSpriteCli();
+    const spriteName = nameOpt || getActiveSprite();
+    if (!spriteName) {
+      throw new Error("No sprite name and no active sprite. Use `trellis vm use <name>` first.");
+    }
+    try {
+      await runSpriteCmd(["list"]);
+    } catch {
+      console.log(`Creating ${spriteName}...`);
+      await runSpriteCmd(["exec", "--sprite", spriteName, "echo", "created"]);
+    }
+    const config = loadVmConfig();
+    const spriteConfig = config.sprites[spriteName];
+    if (!spriteConfig?.hasTrellis) {
+      console.log(`Deploying Trellis to ${spriteName}...`);
+      const result = await deploy({
+        name: spriteName,
+        onProgress: (msg) => console.log(source_default.dim(`  ${msg}`))
+      });
+      trackSprite(spriteName, {
+        url: result.url,
+        hasTrellis: true,
+        apiKey: result.apiKey
+      });
+      console.log(source_default.green(`\u2713 Deployed`));
+    }
+    const url = spriteConfig?.url || `https://${spriteName}.sprites.app`;
+    console.log(`Opening ${url}...`);
+    openUrl(url);
+  } catch (err) {
+    console.error(source_default.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+program2.addCommand(vmProgram);
+program2.command("season").description("Enrich project context for agents \u2014 interactive Q&A").option("-p, --path <path>", "Repository path", ".").option("--reset", "Re-run even if previously configured").action(async (opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const { createInterface: createInterface2 } = await import("readline");
+  const rl = createInterface2({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const ask = (q) => new Promise((r) => rl.question(q, (a) => r(a.trim())));
+  const context = await inferProjectContext(rootPath);
+  console.log(source_default.bold(`
+  Trellis Season \u2014 let's enrich your project context
+`));
+  console.log(source_default.dim(`  Current domain: ${context.domain ?? "(none)"}`));
+  console.log(source_default.dim(`  Current ecosystem: ${context.ecosystem ?? "(none)"}
+`));
+  const domain = await ask(`  What domain does this project serve? [${context.domain ?? ""}]: `);
+  const description = await ask(`  One-sentence description: [${context.description ?? ""}]: `);
+  const toolsRaw = await ask("  Key tools or frameworks (comma-separated): ");
+  const ontologiesRaw = await ask("  Domain ontologies to register (comma-separated, or skip): ");
+  rl.close();
+  const updatedContext = {
+    ...context,
+    domain: domain || context.domain,
+    description: description || context.description
+  };
+  const profile = loadProfile();
+  writeAgentScaffold(rootPath, { profile, context: updatedContext });
+  const agentContextPath = join6(rootPath, ".trellis", "agents", "agent-context.json");
+  try {
+    const { readFileSync: readFileSync4, writeFileSync: writeFileSync3 } = await import("fs");
+    const existing = JSON.parse(readFileSync4(agentContextPath, "utf-8"));
+    existing.domain = updatedContext.domain;
+    if (toolsRaw) {
+      existing.tools = toolsRaw.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+    if (ontologiesRaw) {
+      existing.ontologies = ontologiesRaw.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+    existing.generatedAt = new Date().toISOString();
+    existing.confidence = "high";
+    writeFileSync3(agentContextPath, JSON.stringify(existing, null, 2));
+  } catch {}
+  console.log();
+  console.log(source_default.green("\u2713 Project context updated"));
+  console.log(`  ${source_default.dim("AGENTS.md:")}         .trellis/agents/AGENTS.md`);
+  console.log(`  ${source_default.dim("Agent config:")}      .trellis/agents/agent-context.json`);
+  if (updatedContext.domain) {
+    console.log(`  ${source_default.dim("Domain:")}            ${source_default.cyan(updatedContext.domain)}`);
+  }
+  console.log();
+});
+program2.command("code").alias("ide").description('Launch OpenCode in "Harness" mode, bridged to this Trellis repository').option("-p, --path <path>", "Repository path", ".").option("-m, --model <model>", "OpenCode model to use").option("-w, --web", "Launch MCP server in HTTP mode for web client access").option("--mcp-port <port>", "MCP HTTP server port (default: 3333)", "3333").action(async (opts) => {
+  const { resolve: resolve2, dirname: dirname6, join: join7 } = await import("path");
+  const { existsSync: existsSync6 } = await import("fs");
+  const { spawn } = await import("child_process");
+  const rootPath = resolve2(opts.path);
+  if (!TrellisVcsEngine.isRepo(rootPath)) {
+    console.log(source_default.dim("Not a Trellis workspace \u2014 initializing\u2026"));
+    const engine = new TrellisVcsEngine({ rootPath });
+    await engine.initRepo();
+    console.log(source_default.green("\u2713 Initialized Trellis repository"));
+  }
+  function findOpencode() {
+    const here = dirname6(process.argv[1]);
+    const candidates = [
+      join7(here, "..", "node_modules", ".bin", "opencode"),
+      join7(here, "..", "..", "node_modules", ".bin", "opencode")
+    ];
+    let dir = here;
+    for (let i = 0;i < 5; i++) {
+      const p = join7(dir, "node_modules", ".bin", "opencode");
+      if (existsSync6(p))
+        return p;
+      dir = dirname6(dir);
+    }
+    for (const p of candidates) {
+      if (existsSync6(p))
+        return p;
+    }
+    return null;
+  }
+  function findMcpServer() {
+    const here = dirname6(process.argv[1]);
+    const candidates = [
+      join7(here, "..", "..", "src", "mcp", "index.ts"),
+      join7(here, "..", "src", "mcp", "index.ts"),
+      join7(here, "..", "..", "..", "src", "mcp", "index.ts"),
+      join7(here, "..", "mcp", "index.js"),
+      join7(here, "..", "mcp", "index.ts"),
+      join7(here, "mcp", "index.ts")
+    ];
+    for (const p of candidates) {
+      if (existsSync6(p))
+        return p;
+    }
+    return null;
+  }
+  const opencode = findOpencode();
+  if (!opencode) {
+    console.error(source_default.red("OpenCode not found. Try running `bun install` or `npm install -g opencode-ai`."));
+    process.exit(1);
+  }
+  const mcp = findMcpServer();
+  if (!mcp) {
+    console.error(source_default.red("Trellis MCP server not found."));
+    process.exit(1);
+  }
+  const mcpPort = parseInt(opts.mcpPort, 10) || 3333;
+  const mcpUrl = `http://localhost:${mcpPort}`;
+  console.log(source_default.green(`\u26A1 Spinning up Trellis Agentic Harness...`));
+  console.log(source_default.dim(`   Root:    ${rootPath}`));
+  console.log(source_default.dim(`   MCP:     ${mcp}`));
+  console.log(source_default.dim(`   Agent:   OpenCode`));
+  if (opts.web) {
+    console.log(source_default.dim(`   Web:     ${mcpUrl}`));
+  }
+  console.log("");
+  const args = [rootPath];
+  if (opts.model) {
+    args.push("--model", opts.model);
+  }
+  const mcpServers = {
+    mcpServers: {
+      "trellis-vcs": {
+        command: "bun",
+        args: opts.web ? [
+          "run",
+          mcp,
+          "--quiet",
+          "--path",
+          rootPath,
+          "--http",
+          "--port",
+          String(mcpPort)
+        ] : ["run", mcp, "--quiet", "--path", rootPath]
+      }
+    }
+  };
+  const child = spawn(opencode, args, {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      OPENCODE_MCP_CONFIG: JSON.stringify(mcpServers),
+      OPENCODE_THEME: "everforest",
+      OPENCODE_ACCENT_COLOR: "#a7c080",
+      OPENCODE_HEADER_TEXT: "\uD83C\uDF3F trellis harness",
+      OPENCODE_BRAND_LOGO: "trellis"
+    }
+  });
+  child.on("exit", (code) => {
+    if (code === 0) {
+      console.log(source_default.green(`
+\u2713 Agentic session complete.`));
+    } else {
+      console.log(source_default.yellow(`
+\u26A0 Agent session exited with code ${code}`));
+    }
+    process.exit(code ?? 0);
+  });
+});
 program2.parse();