@meitouai/mem-note-cli 0.0.1 → 0.0.3

package/bin/{mem-note.cjs → mem-note.mjs}

@@ -1,11 +1,20 @@
-"use strict";
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -94,7 +103,7 @@ var require_argument = __commonJS({
             this._name = name;
             break;
         }
-        if (this._name.length > 3 && this._name.slice(-3) === "...") {
+        if (this._name.endsWith("...")) {
           this.variadic = true;
           this._name = this._name.slice(0, -3);
         }
@@ -110,11 +119,12 @@ var require_argument = __commonJS({
       /**
        * @package
        */
-      _concatValue(value, previous) {
+      _collectValue(value, previous) {
         if (previous === this.defaultValue || !Array.isArray(previous)) {
           return [value];
         }
-        return previous.concat(value);
+        previous.push(value);
+        return previous;
       }
       /**
        * Set the default value, and optionally supply the description to be displayed in the help.
@@ -153,7 +163,7 @@ var require_argument = __commonJS({
             );
           }
           if (this.variadic) {
-            return this._concatValue(arg, previous);
+            return this._collectValue(arg, previous);
           }
           return arg;
         };
@@ -467,7 +477,11 @@ var require_help = __commonJS({
           extraInfo.push(`env: ${option.envVar}`);
         }
         if (extraInfo.length > 0) {
-          return `${option.description} (${extraInfo.join(", ")})`;
+          const extraDescription = `(${extraInfo.join(", ")})`;
+          if (option.description) {
+            return `${option.description} ${extraDescription}`;
+          }
+          return extraDescription;
         }
         return option.description;
       }
@@ -499,6 +513,43 @@ var require_help = __commonJS({
         }
         return argument.description;
       }
+      /**
+       * Format a list of items, given a heading and an array of formatted items.
+       *
+       * @param {string} heading
+       * @param {string[]} items
+       * @param {Help} helper
+       * @returns string[]
+       */
+      formatItemList(heading, items, helper) {
+        if (items.length === 0)
+          return [];
+        return [helper.styleTitle(heading), ...items, ""];
+      }
+      /**
+       * Group items by their help group heading.
+       *
+       * @param {Command[] | Option[]} unsortedItems
+       * @param {Command[] | Option[]} visibleItems
+       * @param {Function} getGroup
+       * @returns {Map<string, Command[] | Option[]>}
+       */
+      groupItems(unsortedItems, visibleItems, getGroup) {
+        const result = /* @__PURE__ */ 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;
+      }
       /**
        * Generate the built-in help text.
        *
@@ -532,26 +583,23 @@ var require_help = __commonJS({
             helper.styleArgumentDescription(helper.argumentDescription(argument))
           );
         });
-        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))
-          );
+        output = output.concat(
+          this.formatItemList("Arguments:", argumentList, helper)
+        );
+        const optionGroups = this.groupItems(
+          cmd.options,
+          helper.visibleOptions(cmd),
+          (option) => option.helpGroupHeading ?? "Options:"
+        );
+        optionGroups.forEach((options2, group) => {
+          const optionList = options2.map((option) => {
+            return callFormatItem(
+              helper.styleOptionTerm(helper.optionTerm(option)),
+              helper.styleOptionDescription(helper.optionDescription(option))
+            );
+          });
+          output = output.concat(this.formatItemList(group, optionList, helper));
         });
-        if (optionList.length > 0) {
-          output = output.concat([
-            helper.styleTitle("Options:"),
-            ...optionList,
-            ""
-          ]);
-        }
         if (helper.showGlobalOptions) {
           const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
             return callFormatItem(
@@ -559,27 +607,24 @@ var require_help = __commonJS({
               helper.styleOptionDescription(helper.optionDescription(option))
             );
           });
-          if (globalOptionList.length > 0) {
-            output = output.concat([
-              helper.styleTitle("Global Options:"),
-              ...globalOptionList,
-              ""
-            ]);
-          }
-        }
-        const commandList = helper.visibleCommands(cmd).map((cmd2) => {
-          return callFormatItem(
-            helper.styleSubcommandTerm(helper.subcommandTerm(cmd2)),
-            helper.styleSubcommandDescription(helper.subcommandDescription(cmd2))
+          output = output.concat(
+            this.formatItemList("Global Options:", globalOptionList, helper)
           );
-        });
-        if (commandList.length > 0) {
-          output = output.concat([
-            helper.styleTitle("Commands:"),
-            ...commandList,
-            ""
-          ]);
         }
+        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));
+        });
         return output.join("\n");
       }
       /**
@@ -796,6 +841,7 @@ var require_option = __commonJS({
         this.argChoices = void 0;
         this.conflictsWith = [];
         this.implied = void 0;
+        this.helpGroupHeading = void 0;
       }
       /**
        * Set the default value, and optionally supply the description to be displayed in the help.
@@ -906,11 +952,12 @@ var require_option = __commonJS({
       /**
        * @package
        */
-      _concatValue(value, previous) {
+      _collectValue(value, previous) {
         if (previous === this.defaultValue || !Array.isArray(previous)) {
           return [value];
         }
-        return previous.concat(value);
+        previous.push(value);
+        return previous;
       }
       /**
        * Only allow option value to be one of choices.
@@ -927,7 +974,7 @@ var require_option = __commonJS({
             );
           }
           if (this.variadic) {
-            return this._concatValue(arg, previous);
+            return this._collectValue(arg, previous);
           }
           return arg;
         };
@@ -956,6 +1003,16 @@ var require_option = __commonJS({
         }
         return camelcase(this.name());
       }
+      /**
+       * Set the help group heading.
+       *
+       * @param {string} heading
+       * @return {Option}
+       */
+      helpGroup(heading) {
+        this.helpGroupHeading = heading;
+        return this;
+      }
       /**
        * Check if `arg` matches the short or long flag.
        *
@@ -1151,11 +1208,11 @@ var require_suggestSimilar = __commonJS({
 // apps/mem-note-cli/node_modules/commander/lib/command.js
 var require_command = __commonJS({
   "apps/mem-note-cli/node_modules/commander/lib/command.js"(exports2) {
-    var EventEmitter = require("node:events").EventEmitter;
-    var childProcess = require("node:child_process");
-    var path = require("node:path");
-    var fs = require("node:fs");
-    var process2 = require("node:process");
+    var EventEmitter = __require("node:events").EventEmitter;
+    var childProcess = __require("node:child_process");
+    var path = __require("node:path");
+    var fs = __require("node:fs");
+    var process2 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
     var { Help: Help2, stripColor } = require_help();
@@ -1216,6 +1273,9 @@ var require_command = __commonJS({
         this._addImplicitHelpCommand = void 0;
         this._helpCommand = void 0;
         this._helpConfiguration = {};
+        this._helpGroupHeading = void 0;
+        this._defaultCommandGroup = void 0;
+        this._defaultOptionGroup = void 0;
       }
       /**
        * Copy settings that are useful to have in common across root command and subcommands.
@@ -1360,7 +1420,10 @@ var require_command = __commonJS({
       configureOutput(configuration) {
         if (configuration === void 0)
           return this._outputConfiguration;
-        Object.assign(this._outputConfiguration, configuration);
+        this._outputConfiguration = {
+          ...this._outputConfiguration,
+          ...configuration
+        };
         return this;
       }
       /**
@@ -1434,16 +1497,16 @@ var require_command = __commonJS({
        *
        * @param {string} name
        * @param {string} [description]
-       * @param {(Function|*)} [fn] - custom argument processing function
+       * @param {(Function|*)} [parseArg] - custom argument processing function or default value
        * @param {*} [defaultValue]
        * @return {Command} `this` command for chaining
        */
-      argument(name, description, fn, defaultValue) {
+      argument(name, description, parseArg, defaultValue) {
         const argument = this.createArgument(name, description);
-        if (typeof fn === "function") {
-          argument.default(defaultValue).argParser(fn);
+        if (typeof parseArg === "function") {
+          argument.default(defaultValue).argParser(parseArg);
         } else {
-          argument.default(fn);
+          argument.default(parseArg);
         }
         this.addArgument(argument);
         return this;
@@ -1473,7 +1536,7 @@ var require_command = __commonJS({
        */
       addArgument(argument) {
         const previousArgument = this.registeredArguments.slice(-1)[0];
-        if (previousArgument && previousArgument.variadic) {
+        if (previousArgument?.variadic) {
           throw new Error(
             `only the last argument can be variadic '${previousArgument.name()}'`
           );
@@ -1502,10 +1565,13 @@ var require_command = __commonJS({
       helpCommand(enableOrNameAndArgs, description) {
         if (typeof enableOrNameAndArgs === "boolean") {
           this._addImplicitHelpCommand = enableOrNameAndArgs;
+          if (enableOrNameAndArgs && this._defaultCommandGroup) {
+            this._initCommandGroup(this._getHelpCommand());
+          }
           return this;
         }
-        enableOrNameAndArgs = enableOrNameAndArgs ?? "help [command]";
-        const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);
+        const nameAndArgs = enableOrNameAndArgs ?? "help [command]";
+        const [, helpName, helpArgs] = nameAndArgs.match(/([^ ]+) *(.*)/);
         const helpDescription = description ?? "display help for command";
         const helpCommand = this.createCommand(helpName);
         helpCommand.helpOption(false);
@@ -1515,6 +1581,8 @@ var require_command = __commonJS({
           helpCommand.description(helpDescription);
         this._addImplicitHelpCommand = true;
         this._helpCommand = helpCommand;
+        if (enableOrNameAndArgs || description)
+          this._initCommandGroup(helpCommand);
         return this;
       }
       /**
@@ -1531,6 +1599,7 @@ var require_command = __commonJS({
         }
         this._addImplicitHelpCommand = true;
         this._helpCommand = helpCommand;
+        this._initCommandGroup(helpCommand);
         return this;
       }
       /**
@@ -1679,6 +1748,7 @@ 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);
       }
       /**
@@ -1702,6 +1772,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             `cannot add command '${newCmd}' as already have command '${existingCmd}'`
           );
         }
+        this._initCommandGroup(command);
         this.commands.push(command);
       }
       /**
@@ -1734,7 +1805,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._concatValue(val, oldValue);
+            val = option._collectValue(val, oldValue);
           }
           if (val == null) {
             if (option.negate) {
@@ -2391,7 +2462,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @private
        */
       _chainOrCall(promise, fn) {
-        if (promise && promise.then && typeof promise.then === "function") {
+        if (promise?.then && typeof promise.then === "function") {
           return promise.then(() => fn());
         }
         return fn();
@@ -2496,7 +2567,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
           return promiseChain;
         }
-        if (this.parent && this.parent.listenerCount(commandEvent)) {
+        if (this.parent?.listenerCount(commandEvent)) {
           checkForUnknownOptions();
           this._processArguments();
           this.parent.emit(commandEvent, operands, unknown);
@@ -2608,27 +2679,36 @@ Expecting one of '${allowedValues.join("', '")}'`);
        *     sub --unknown uuu op => [sub], [--unknown uuu op]
        *     sub -- --unknown uuu op => [sub --unknown uuu op], []
        *
-       * @param {string[]} argv
+       * @param {string[]} args
        * @return {{operands: string[], unknown: string[]}}
        */
-      parseOptions(argv) {
+      parseOptions(args) {
         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;
-        while (args.length) {
-          const arg = args.shift();
+        let activeGroup = null;
+        let i = 0;
+        while (i < args.length || activeGroup) {
+          const arg = activeGroup ?? args[i++];
+          activeGroup = null;
           if (arg === "--") {
             if (dest === unknown)
               dest.push(arg);
-            dest.push(...args);
+            dest.push(...args.slice(i));
             break;
           }
-          if (activeVariadicOption && !maybeOption(arg)) {
+          if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) {
             this.emit(`option:${activeVariadicOption.name()}`, arg);
             continue;
           }
@@ -2637,14 +2717,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
             const option = this._findOption(arg);
             if (option) {
               if (option.required) {
-                const value = args.shift();
+                const value = args[i++];
                 if (value === void 0)
                   this.optionMissingArgument(option);
                 this.emit(`option:${option.name()}`, value);
               } else if (option.optional) {
                 let value = null;
-                if (args.length > 0 && !maybeOption(args[0])) {
-                  value = args.shift();
+                if (i < args.length && (!maybeOption(args[i]) || negativeNumberArg(args[i]))) {
+                  value = args[i++];
                 }
                 this.emit(`option:${option.name()}`, value);
               } else {
@@ -2661,7 +2741,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
                 this.emit(`option:${option.name()}`, arg.slice(2));
               } else {
                 this.emit(`option:${option.name()}`);
-                args.unshift(`-${arg.slice(2)}`);
+                activeGroup = `-${arg.slice(2)}`;
               }
               continue;
             }
@@ -2674,31 +2754,24 @@ Expecting one of '${allowedValues.join("', '")}'`);
               continue;
             }
           }
-          if (maybeOption(arg)) {
+          if (dest === operands && maybeOption(arg) && !(this.commands.length === 0 && negativeNumberArg(arg))) {
             dest = unknown;
           }
           if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
             if (this._findCommand(arg)) {
               operands.push(arg);
-              if (args.length > 0)
-                unknown.push(...args);
+              unknown.push(...args.slice(i));
               break;
             } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
-              operands.push(arg);
-              if (args.length > 0)
-                operands.push(...args);
+              operands.push(arg, ...args.slice(i));
               break;
             } else if (this._defaultCommandName) {
-              unknown.push(arg);
-              if (args.length > 0)
-                unknown.push(...args);
+              unknown.push(arg, ...args.slice(i));
               break;
             }
           }
           if (this._passThroughOptions) {
-            dest.push(arg);
-            if (args.length > 0)
-              dest.push(...args);
+            dest.push(arg, ...args.slice(i));
             break;
           }
           dest.push(arg);
@@ -3059,6 +3132,72 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._name = str2;
         return this;
       }
+      /**
+       * Set/get the help group heading for this subcommand in parent command's help.
+       *
+       * @param {string} [heading]
+       * @return {Command | string}
+       */
+      helpGroup(heading) {
+        if (heading === void 0)
+          return this._helpGroupHeading ?? "";
+        this._helpGroupHeading = heading;
+        return this;
+      }
+      /**
+       * Set/get the default help group heading for subcommands added to this command.
+       * (This does not override a group set directly on the subcommand using .helpGroup().)
+       *
+       * @example
+       * program.commandsGroup('Development Commands:);
+       * program.command('watch')...
+       * program.command('lint')...
+       * ...
+       *
+       * @param {string} [heading]
+       * @returns {Command | string}
+       */
+      commandsGroup(heading) {
+        if (heading === void 0)
+          return this._defaultCommandGroup ?? "";
+        this._defaultCommandGroup = heading;
+        return this;
+      }
+      /**
+       * Set/get the default help group heading for options added to this command.
+       * (This does not override a group set directly on the option using .helpGroup().)
+       *
+       * @example
+       * program
+       *   .optionsGroup('Development Options:')
+       *   .option('-d, --debug', 'output extra debugging')
+       *   .option('-p, --profile', 'output profiling information')
+       *
+       * @param {string} [heading]
+       * @returns {Command | string}
+       */
+      optionsGroup(heading) {
+        if (heading === void 0)
+          return this._defaultOptionGroup ?? "";
+        this._defaultOptionGroup = heading;
+        return this;
+      }
+      /**
+       * @param {Option} option
+       * @private
+       */
+      _initOptionGroup(option) {
+        if (this._defaultOptionGroup && !option.helpGroupHeading)
+          option.helpGroup(this._defaultOptionGroup);
+      }
+      /**
+       * @param {Command} cmd
+       * @private
+       */
+      _initCommandGroup(cmd) {
+        if (this._defaultCommandGroup && !cmd.helpGroup())
+          cmd.helpGroup(this._defaultCommandGroup);
+      }
       /**
        * Set the name of the command from script filename, such as process.argv[1],
        * or require.main.filename, or __filename.
@@ -3196,15 +3335,22 @@ Expecting one of '${allowedValues.join("', '")}'`);
       helpOption(flags, description) {
         if (typeof flags === "boolean") {
           if (flags) {
-            this._helpOption = this._helpOption ?? void 0;
+            if (this._helpOption === null)
+              this._helpOption = void 0;
+            if (this._defaultOptionGroup) {
+              this._initOptionGroup(this._getHelpOption());
+            }
           } else {
             this._helpOption = null;
           }
           return this;
         }
-        flags = flags ?? "-h, --help";
-        description = description ?? "display help for command";
-        this._helpOption = this.createOption(flags, description);
+        this._helpOption = this.createOption(
+          flags ?? "-h, --help",
+          description ?? "display help for command"
+        );
+        if (flags || description)
+          this._initOptionGroup(this._helpOption);
         return this;
       }
       /**
@@ -3229,6 +3375,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       addHelpOption(option) {
         this._helpOption = option;
+        this._initOptionGroup(option);
         return this;
       }
       /**
@@ -4429,7 +4576,7 @@ var require_binary = __commonJS({
     "use strict";
     var NodeBuffer;
     try {
-      _require = require;
+      _require = __require;
       NodeBuffer = _require("buffer").Buffer;
     } catch (__) {
     }
@@ -4743,7 +4890,7 @@ var require_function = __commonJS({
     "use strict";
     var esprima;
     try {
-      _require = require;
+      _require = __require;
       esprima = _require("esprima");
     } catch (_) {
       if (typeof window !== "undefined")
@@ -6820,7 +6967,7 @@ var require_parse = __commonJS({
 var require_gray_matter = __commonJS({
   "node_modules/gray-matter/index.js"(exports2, module2) {
     "use strict";
-    var fs = require("fs");
+    var fs = __require("fs");
     var sections = require_section_matter();
     var defaults = require_defaults();
     var stringify = require_stringify();
@@ -6933,11 +7080,17 @@ var require_gray_matter = __commonJS({
   }
 });
 
-// apps/mem-note-cli/dist/main.js
-var import_node_os = require("node:os");
-var import_node_path6 = require("node:path");
-var import_node_url = require("node:url");
-var import_promises6 = require("node:fs/promises");
+// apps/mem-note-cli/dist/main.mjs
+import { homedir } from "node:os";
+import { basename as basename3, dirname as dirname3, join as join22, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  access as access2,
+  copyFile,
+  readFile as readFile4,
+  readdir as readdir3,
+  writeFile as writeFile22
+} from "node:fs/promises";
 
 // apps/mem-note-cli/node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
@@ -6957,8 +7110,8 @@ var {
 } = import_index.default;
 
 // packages/mem-note/dist/storage/data-dir.js
-var import_promises = require("node:fs/promises");
-var import_node_path = require("node:path");
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
 var DataDir = class {
   root;
   constructor(root) {
@@ -6981,43 +7134,43 @@ var DataDir = class {
       this.insightsDir(),
       this.reportsDir()
     ];
-    await Promise.all(dirs.map((d) => (0, import_promises.mkdir)(d, { recursive: true })));
+    await Promise.all(dirs.map((d) => mkdir(d, { recursive: true })));
   }
   /** `<root>/notes/` — permanent, groomed notes. */
   notesDir() {
-    return (0, import_node_path.join)(this.root, "notes");
+    return join(this.root, "notes");
   }
   /** `<root>/notes/_archived/` — archived notes (excluded from normal Glob scans). */
   archivedDir() {
-    return (0, import_node_path.join)(this.root, "notes", "_archived");
+    return join(this.root, "notes", "_archived");
   }
   /** `<root>/inbox/` — raw input pending groom. */
   inboxDir() {
-    return (0, import_node_path.join)(this.root, "inbox");
+    return join(this.root, "inbox");
   }
   /** `<root>/inbox/.processed/` — soft-deleted inbox entries. */
   processedInboxDir() {
-    return (0, import_node_path.join)(this.root, "inbox", ".processed");
+    return join(this.root, "inbox", ".processed");
   }
   /** `<root>/insights/` — groom-produced insights. */
   insightsDir() {
-    return (0, import_node_path.join)(this.root, "insights");
+    return join(this.root, "insights");
   }
   /** `<root>/.context/` — compiled context for SessionStart / PreCompact hooks. */
   contextDir() {
-    return (0, import_node_path.join)(this.root, ".context");
+    return join(this.root, ".context");
   }
   /** `<root>/.context/index.md` — the single context file injected by hooks. */
   contextIndexPath() {
-    return (0, import_node_path.join)(this.contextDir(), "index.md");
+    return join(this.contextDir(), "index.md");
   }
   /** `<root>/.reports/` — append-only audit log directory. */
   reportsDir() {
-    return (0, import_node_path.join)(this.root, ".reports");
+    return join(this.root, ".reports");
   }
   /** `<root>/CONVENTIONS.md` — written by `mem-note init`, read by Claude in skills. */
   conventionsPath() {
-    return (0, import_node_path.join)(this.root, "CONVENTIONS.md");
+    return join(this.root, "CONVENTIONS.md");
   }
   /** The absolute root path. */
   get rootDir() {
@@ -7026,9 +7179,9 @@ var DataDir = class {
 };
 
 // packages/mem-note/dist/storage/inbox-storage.js
-var import_promises2 = require("node:fs/promises");
-var import_node_path2 = require("node:path");
 var import_gray_matter = __toESM(require_gray_matter(), 1);
+import { access, mkdir as mkdir2, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
 var InboxStorage = class {
   dataDir;
   constructor(dataDir) {
@@ -7047,8 +7200,8 @@ var InboxStorage = class {
   async writeEntry(input) {
     const inboxDir = this.dataDir.inboxDir();
     const processedDir = this.dataDir.processedInboxDir();
-    await (0, import_promises2.mkdir)(inboxDir, { recursive: true });
-    await (0, import_promises2.mkdir)(processedDir, { recursive: true });
+    await mkdir2(inboxDir, { recursive: true });
+    await mkdir2(processedDir, { recursive: true });
     if (input.source) {
       const existing = await findBySource([inboxDir, processedDir], input.source);
       if (existing) {
@@ -7072,7 +7225,7 @@ var InboxStorage = class {
     if (input.source)
       frontmatter["source"] = input.source;
     const raw = import_gray_matter.default.stringify(input.content, frontmatter);
-    await (0, import_promises2.writeFile)(fullPath, raw, "utf-8");
+    await writeFile(fullPath, raw, "utf-8");
     return {
       path: fullPath,
       relativePath: this.toRelative(fullPath),
@@ -7086,14 +7239,14 @@ var InboxStorage = class {
   async processEntry(input) {
     const inboxDir = this.dataDir.inboxDir();
     const processedDir = this.dataDir.processedInboxDir();
-    const sourcePath = (0, import_node_path2.join)(inboxDir, input.filename);
-    const destPath = (0, import_node_path2.join)(processedDir, input.filename);
-    const raw = await (0, import_promises2.readFile)(sourcePath, "utf-8");
+    const sourcePath = join2(inboxDir, input.filename);
+    const destPath = join2(processedDir, input.filename);
+    const raw = await readFile(sourcePath, "utf-8");
     const parsed = (0, import_gray_matter.default)(raw);
     const status = input.status ?? "processed";
     const at = formatTimestamp(input.processedAt ?? /* @__PURE__ */ new Date());
     const reason = normalizeProcessedReason(status, input.reason);
-    await (0, import_promises2.mkdir)(processedDir, { recursive: true });
+    await mkdir2(processedDir, { recursive: true });
     const nextRaw = import_gray_matter.default.stringify(parsed.content, {
       ...parsed.data,
       processed: {
@@ -7102,8 +7255,8 @@ var InboxStorage = class {
         ...reason ? { reason } : {}
       }
     });
-    await (0, import_promises2.writeFile)(destPath, nextRaw, "utf-8");
-    await (0, import_promises2.unlink)(sourcePath);
+    await writeFile(destPath, nextRaw, "utf-8");
+    await unlink(sourcePath);
     return {
       path: destPath,
       relativePath: this.toRelative(destPath),
@@ -7132,9 +7285,9 @@ function normalizeProcessedReason(status, reason) {
 async function pickUniqueFilename(inboxDir, timestamp, slug) {
   for (let i = 0; i < 1e3; i++) {
     const filename = i === 0 ? `${timestamp}_${slug}.md` : `${timestamp}_${slug}-${i}.md`;
-    const fullPath = (0, import_node_path2.join)(inboxDir, filename);
+    const fullPath = join2(inboxDir, filename);
     try {
-      await (0, import_promises2.access)(fullPath);
+      await access(fullPath);
     } catch {
       return { filename, fullPath };
     }
@@ -7154,16 +7307,16 @@ async function findBySource(dirs, sourceKey) {
   for (const dir of dirs) {
     let entries;
     try {
-      entries = await (0, import_promises2.readdir)(dir, { withFileTypes: true });
+      entries = await readdir(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md"))
         continue;
-      const fullPath = (0, import_node_path2.join)(dir, entry.name);
+      const fullPath = join2(dir, entry.name);
       try {
-        const raw = await (0, import_promises2.readFile)(fullPath, "utf-8");
+        const raw = await readFile(fullPath, "utf-8");
         const parsed = (0, import_gray_matter.default)(raw);
         const data = parsed.data;
         if (data["source"] === sourceKey) {
@@ -7177,9 +7330,9 @@ async function findBySource(dirs, sourceKey) {
 }
 
 // packages/mem-note/dist/doctor/doctor-engine.js
-var import_promises3 = require("node:fs/promises");
-var import_node_path3 = require("node:path");
 var import_gray_matter2 = __toESM(require_gray_matter(), 1);
+import { readFile as readFile2, readdir as readdir2 } from "node:fs/promises";
+import { basename, dirname, join as join3, relative } from "node:path";
 var REQUIRED_NOTE_FIELDS = [
   "type",
   "title",
@@ -7203,8 +7356,8 @@ var DoctorEngine = class {
     const indexFiles = [];
     const archivedNotes = [];
     for (const fullPath of allNoteFiles) {
-      const rel = (0, import_node_path3.relative)(notesRoot, fullPath);
-      if ((0, import_node_path3.basename)(fullPath) === "NOTES.md") {
+      const rel = relative(notesRoot, fullPath);
+      if (basename(fullPath) === "NOTES.md") {
         indexFiles.push(fullPath);
       } else if (rel.startsWith("_archived")) {
         archivedNotes.push(fullPath);
@@ -7228,12 +7381,12 @@ var DoctorEngine = class {
     indexFilesChecked = indexFiles.length;
     findings.push(...indexFindings);
     for (const archivedPath of archivedNotes) {
-      const name = (0, import_node_path3.basename)(archivedPath);
+      const name = basename(archivedPath);
       if (!ARCHIVED_NAME_RE.test(name)) {
         findings.push({
           severity: "warning",
           category: "archived-naming",
-          path: (0, import_node_path3.relative)(this.dataDir.rootDir, archivedPath),
+          path: relative(this.dataDir.rootDir, archivedPath),
           message: `Archived file "${name}" does not match YYYY-MM-DD_<slug>.md`
         });
       }
@@ -7255,13 +7408,13 @@ var DoctorEngine = class {
 async function walkMarkdown(dir) {
   let entries;
   try {
-    entries = await (0, import_promises3.readdir)(dir, { withFileTypes: true });
+    entries = await readdir2(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const results = [];
   for (const entry of entries) {
-    const fullPath = (0, import_node_path3.join)(dir, entry.name);
+    const fullPath = join3(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...await walkMarkdown(fullPath));
     } else if (entry.name.endsWith(".md")) {
@@ -7272,10 +7425,10 @@ async function walkMarkdown(dir) {
 }
 async function checkNoteFrontmatter(notePath, notesRoot) {
   const findings = [];
-  const relPath = `notes/${(0, import_node_path3.relative)(notesRoot, notePath)}`.replace(/\\/g, "/");
+  const relPath = `notes/${relative(notesRoot, notePath)}`.replace(/\\/g, "/");
   let raw;
   try {
-    raw = await (0, import_promises3.readFile)(notePath, "utf-8");
+    raw = await readFile2(notePath, "utf-8");
   } catch (err) {
     findings.push({
       severity: "error",
@@ -7333,7 +7486,7 @@ async function checkNotesIndexes(indexFiles, regularNotes, notesRoot) {
   const findings = [];
   const notesByDir = /* @__PURE__ */ new Map();
   for (const notePath of regularNotes) {
-    const dir = (0, import_node_path3.dirname)(notePath);
+    const dir = dirname(notePath);
     const notesInDir = notesByDir.get(dir);
     if (notesInDir) {
       notesInDir.push(notePath);
@@ -7342,11 +7495,11 @@ async function checkNotesIndexes(indexFiles, regularNotes, notesRoot) {
     notesByDir.set(dir, [notePath]);
   }
   for (const [dir, notes] of notesByDir.entries()) {
-    const expectedIndex = (0, import_node_path3.join)(dir, "NOTES.md");
-    const relDir = `notes/${(0, import_node_path3.relative)(notesRoot, dir) || "."}`.replace(/\\/g, "/");
+    const expectedIndex = join3(dir, "NOTES.md");
+    const relDir = `notes/${relative(notesRoot, dir) || "."}`.replace(/\\/g, "/");
     let indexRaw = null;
     try {
-      indexRaw = await (0, import_promises3.readFile)(expectedIndex, "utf-8");
+      indexRaw = await readFile2(expectedIndex, "utf-8");
     } catch {
       findings.push({
         severity: "warning",
@@ -7366,7 +7519,7 @@ async function checkNotesIndexes(indexFiles, regularNotes, notesRoot) {
       }
       linkedFiles.add(href);
     }
-    const actualFilenames = new Set(notes.map((p) => (0, import_node_path3.basename)(p)));
+    const actualFilenames = new Set(notes.map((p) => basename(p)));
     for (const filename of actualFilenames) {
       if (!linkedFiles.has(filename)) {
         findings.push({
@@ -7394,7 +7547,7 @@ async function checkContextIndex(dataDir) {
   const indexPath = dataDir.contextIndexPath();
   let raw;
   try {
-    raw = await (0, import_promises3.readFile)(indexPath, "utf-8");
+    raw = await readFile2(indexPath, "utf-8");
   } catch {
     return [
       {
@@ -7419,14 +7572,14 @@ async function checkContextIndex(dataDir) {
 }
 
 // packages/mem-note/dist/archive/archive.js
-var import_promises4 = require("node:fs/promises");
-var import_node_path4 = require("node:path");
 var import_gray_matter3 = __toESM(require_gray_matter(), 1);
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2, join as join4 } from "node:path";
 async function archiveNote(dataDir, notePath) {
   const absFrom = resolveNotePath(dataDir, notePath);
-  const sourceDir = (0, import_node_path4.dirname)(absFrom);
-  const originalName = (0, import_node_path4.basename)(absFrom);
-  const raw = await (0, import_promises4.readFile)(absFrom, "utf-8");
+  const sourceDir = dirname2(absFrom);
+  const originalName = basename2(absFrom);
+  const raw = await readFile3(absFrom, "utf-8");
   const parsed = (0, import_gray_matter3.default)(raw);
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const newFrontmatter = {
@@ -7435,10 +7588,10 @@ async function archiveNote(dataDir, notePath) {
   };
   const updatedRaw = import_gray_matter3.default.stringify(parsed.content, newFrontmatter);
   const archivedDir = dataDir.archivedDir();
-  await (0, import_promises4.mkdir)(archivedDir, { recursive: true });
+  await mkdir3(archivedDir, { recursive: true });
   const archivedName = `${today}_${originalName}`;
-  const absTo = (0, import_node_path4.join)(archivedDir, archivedName);
-  await (0, import_promises4.writeFile)(absTo, updatedRaw, "utf-8");
+  const absTo = join4(archivedDir, archivedName);
+  await writeFile2(absTo, updatedRaw, "utf-8");
   const { unlink: unlink2 } = await import("node:fs/promises");
   await unlink2(absFrom);
   const notesIndexUpdated = await removeFromNotesIndex(sourceDir, originalName);
@@ -7453,14 +7606,14 @@ function resolveNotePath(dataDir, input) {
     return input;
   const root = dataDir.rootDir;
   if (input.startsWith("notes/"))
-    return (0, import_node_path4.join)(root, input);
-  return (0, import_node_path4.join)(dataDir.notesDir(), input);
+    return join4(root, input);
+  return join4(dataDir.notesDir(), input);
 }
 async function removeFromNotesIndex(dir, filename) {
-  const indexPath = (0, import_node_path4.join)(dir, "NOTES.md");
+  const indexPath = join4(dir, "NOTES.md");
   let raw;
   try {
-    raw = await (0, import_promises4.readFile)(indexPath, "utf-8");
+    raw = await readFile3(indexPath, "utf-8");
   } catch {
     return false;
   }
@@ -7476,7 +7629,7 @@ async function removeFromNotesIndex(dir, filename) {
     outLines.push(line);
   }
   if (removed) {
-    await (0, import_promises4.writeFile)(indexPath, outLines.join("\n"), "utf-8");
+    await writeFile2(indexPath, outLines.join("\n"), "utf-8");
   }
   return removed;
 }
@@ -7503,19 +7656,22 @@ function parseMarkdownNote(raw) {
   return { metadata: data, body: content, wikilinks };
 }
 
-// apps/mem-note-cli/dist/git.js
-var import_node_child_process = require("node:child_process");
-var import_promises5 = require("node:fs/promises");
-var import_node_path5 = require("node:path");
+// apps/mem-note-cli/dist/main.mjs
+import { spawn } from "node:child_process";
+import { writeFile as writeFile3, access as access3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
 function run(cmd, args, cwd) {
   return new Promise((resolvePromise) => {
-    const child = (0, import_node_child_process.spawn)(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (d) => stdout += d.toString());
     child.stderr.on("data", (d) => stderr += d.toString());
     child.on("error", () => resolvePromise({ ok: false, stdout, stderr }));
-    child.on("close", (code) => resolvePromise({ ok: code === 0, stdout, stderr }));
+    child.on(
+      "close",
+      (code) => resolvePromise({ ok: code === 0, stdout, stderr })
+    );
   });
 }
 async function isGitAvailable() {
@@ -7524,7 +7680,7 @@ async function isGitAvailable() {
 }
 async function isGitRepo(cwd) {
   try {
-    await (0, import_promises5.access)((0, import_node_path5.join)(cwd, ".git"));
+    await access3(join5(cwd, ".git"));
     return true;
   } catch {
     return false;
@@ -7538,9 +7694,13 @@ var GITIGNORE_CONTENT = `.snapshots/
 `;
 async function gitInitDataDir(cwd) {
   await run("git", ["init", "-q", "-b", "main"], cwd);
-  await (0, import_promises5.writeFile)((0, import_node_path5.join)(cwd, ".gitignore"), GITIGNORE_CONTENT, "utf-8");
+  await writeFile3(join5(cwd, ".gitignore"), GITIGNORE_CONTENT, "utf-8");
   await run("git", ["add", "-A"], cwd);
-  await run("git", ["commit", "-q", "-m", "mem-note init", "--allow-empty"], cwd);
+  await run(
+    "git",
+    ["commit", "-q", "-m", "mem-note init", "--allow-empty"],
+    cwd
+  );
 }
 async function gitCommitIfPossible(cwd, message) {
   if (!await isGitRepo(cwd))
@@ -7568,11 +7728,8 @@ function printInstallGuidance() {
   for (const l of lines)
     console.error(l);
 }
-
-// apps/mem-note-cli/dist/main.js
-var import_meta = {};
 function resolveDataRoot() {
-  return process.env["MEM_NOTE_DATA_DIR"] ?? (0, import_node_path6.join)((0, import_node_os.homedir)(), ".aibox-mem-note");
+  return process.env["MEM_NOTE_DATA_DIR"] ?? join22(homedir(), ".aibox-mem-note");
 }
 async function getDataDir() {
   const dd = new DataDir(resolveDataRoot());
@@ -7582,11 +7739,11 @@ async function getDataDir() {
 function resolveConventionsResource() {
   let here;
   try {
-    here = (0, import_node_path6.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+    here = dirname3(fileURLToPath(import.meta.url));
   } catch {
     here = __dirname;
   }
-  return (0, import_node_path6.resolve)(here, "conventions.md");
+  return resolve(here, "conventions.md");
 }
 async function readStdin() {
   if (process.stdin.isTTY)
@@ -7599,23 +7756,27 @@ async function readStdin() {
 }
 var program2 = new Command();
 program2.name("mem-note").description("AI-enhanced personal knowledge base \u2014 minimal CLI surface").version("0.2.0");
-program2.command("init").description("Create the data directory tree and write CONVENTIONS.md (idempotent \u2014 does not overwrite an existing CONVENTIONS.md)").action(async () => {
+program2.command("init").description(
+  "Create the data directory tree and write CONVENTIONS.md (idempotent \u2014 does not overwrite an existing CONVENTIONS.md)"
+).action(async () => {
   const dd = await getDataDir();
   const conventionsDest = dd.conventionsPath();
   let conventionsExisted = false;
   try {
-    await (0, import_promises6.access)(conventionsDest);
+    await access2(conventionsDest);
     conventionsExisted = true;
   } catch {
   }
   if (!conventionsExisted) {
     const source = resolveConventionsResource();
     try {
-      await (0, import_promises6.copyFile)(source, conventionsDest);
+      await copyFile(source, conventionsDest);
     } catch (err) {
       const fallback = "# mem-note CONVENTIONS\n\nFull conventions document missing from this installation. See apps/mem-note-cli/src/conventions.md in the source repo.\n";
-      await (0, import_promises6.writeFile)(conventionsDest, fallback, "utf-8");
-      console.warn(`[mem-note init] Warning: could not read ${source}: ${String(err)}`);
+      await writeFile22(conventionsDest, fallback, "utf-8");
+      console.warn(
+        `[mem-note init] Warning: could not read ${source}: ${String(err)}`
+      );
     }
   }
   let gitStatus = "skipped-no-git";
@@ -7629,55 +7790,80 @@ program2.command("init").description("Create the data directory tree and write C
   } else {
     printInstallGuidance();
   }
-  console.log(JSON.stringify({
-    ok: true,
-    root: dd.rootDir,
-    conventions: conventionsExisted ? "already-present" : conventionsDest,
-    git: gitStatus
-  }));
+  console.log(
+    JSON.stringify({
+      ok: true,
+      root: dd.rootDir,
+      conventions: conventionsExisted ? "already-present" : conventionsDest,
+      git: gitStatus
+    })
+  );
 });
-program2.command("save").description("Save a new inbox entry. Accepts content as argument or stdin.").argument("[content]", "Content to save (omit to read from stdin)").option("--type <type>", "Preliminary type hint (optional; groom may rewrite)").option("--tags <tags>", "Comma-separated tags (optional)", (val) => val.split(",").map((t) => t.trim()).filter(Boolean)).option("--source <key>", "Deduplication key \u2014 if an entry with this source exists, reuse it").action(async (contentArg, opts) => {
-  const content = (contentArg?.trim() || await readStdin()).trim();
-  if (!content) {
-    console.error("mem-note save: no content provided (argument or stdin)");
-    process.exitCode = 1;
-    return;
-  }
-  const dd = await getDataDir();
-  const inbox = new InboxStorage(dd);
-  const result = await inbox.writeEntry({
-    content,
-    type: opts.type,
-    tags: opts.tags,
-    source: opts.source
-  });
-  if (result.created) {
-    await gitCommitIfPossible(dd.rootDir, `save: ${(0, import_node_path6.basename)(result.relativePath, ".md")}`);
+program2.command("save").description("Save a new inbox entry. Accepts content as argument or stdin.").argument("[content]", "Content to save (omit to read from stdin)").option("--type <type>", "Preliminary type hint (optional; groom may rewrite)").option(
+  "--tags <tags>",
+  "Comma-separated tags (optional)",
+  (val) => val.split(",").map((t) => t.trim()).filter(Boolean)
+).option(
+  "--source <key>",
+  "Deduplication key \u2014 if an entry with this source exists, reuse it"
+).action(
+  async (contentArg, opts) => {
+    const content = (contentArg?.trim() || await readStdin()).trim();
+    if (!content) {
+      console.error("mem-note save: no content provided (argument or stdin)");
+      process.exitCode = 1;
+      return;
+    }
+    const dd = await getDataDir();
+    const inbox = new InboxStorage(dd);
+    const result = await inbox.writeEntry({
+      content,
+      type: opts.type,
+      tags: opts.tags,
+      source: opts.source
+    });
+    if (result.created) {
+      await gitCommitIfPossible(
+        dd.rootDir,
+        `save: ${basename3(result.relativePath, ".md")}`
+      );
+    }
+    console.log(
+      JSON.stringify({
+        ok: true,
+        path: result.relativePath,
+        created: result.created
+      })
+    );
   }
-  console.log(JSON.stringify({
-    ok: true,
-    path: result.relativePath,
-    created: result.created
-  }));
-});
-program2.command("archive <path>").description("Archive a note: add archived date, move to notes/_archived/<date>_<slug>.md, remove link from directory NOTES.md").action(async (notePath) => {
+);
+program2.command("archive <path>").description(
+  "Archive a note: add archived date, move to notes/_archived/<date>_<slug>.md, remove link from directory NOTES.md"
+).action(async (notePath) => {
   const dd = await getDataDir();
   try {
     const result = await archiveNote(dd, notePath);
     const relTo = result.to.slice(dd.rootDir.length + 1);
-    await gitCommitIfPossible(dd.rootDir, `archive: ${(0, import_node_path6.basename)(notePath, ".md")}`);
-    console.log(JSON.stringify({
-      ok: true,
-      from: notePath,
-      to: relTo,
-      notesIndexUpdated: result.notesIndexUpdated
-    }));
+    await gitCommitIfPossible(
+      dd.rootDir,
+      `archive: ${basename3(notePath, ".md")}`
+    );
+    console.log(
+      JSON.stringify({
+        ok: true,
+        from: notePath,
+        to: relTo,
+        notesIndexUpdated: result.notesIndexUpdated
+      })
+    );
   } catch (err) {
     console.error(`mem-note archive: ${String(err)}`);
     process.exitCode = 1;
   }
 });
-program2.command("doctor").description("Check data directory consistency: frontmatter schema, NOTES.md drift, archived naming, .context/index.md").option("-f, --format <format>", "Output format: text | json", "text").action(async (opts) => {
+program2.command("doctor").description(
+  "Check data directory consistency: frontmatter schema, NOTES.md drift, archived naming, .context/index.md"
+).option("-f, --format <format>", "Output format: text | json", "text").action(async (opts) => {
   const dd = await getDataDir();
   const engine = new DoctorEngine(dd);
   const report = await engine.run();
@@ -7692,7 +7878,9 @@ program2.command("doctor").description("Check data directory consistency: frontm
 });
 function printDoctorReportText(findings, counts) {
   if (findings.length === 0) {
-    console.log(`\u2713 mem-note doctor: no issues (${counts.notesChecked} notes, ${counts.indexFilesChecked} NOTES.md)`);
+    console.log(
+      `\u2713 mem-note doctor: no issues (${counts.notesChecked} notes, ${counts.indexFilesChecked} NOTES.md)`
+    );
     return;
   }
   const icon = (s) => s === "error" ? "\u2717" : s === "warning" ? "\u26A0" : "\u2139";
@@ -7700,22 +7888,26 @@ function printDoctorReportText(findings, counts) {
     console.log(`${icon(f.severity)} [${f.category}] ${f.path}: ${f.message}`);
   }
   console.log();
-  console.log(`  ${counts.errors} error(s), ${counts.warnings} warning(s), ${counts.infos} info (${counts.notesChecked} notes, ${counts.indexFilesChecked} NOTES.md checked)`);
+  console.log(
+    `  ${counts.errors} error(s), ${counts.warnings} warning(s), ${counts.infos} info (${counts.notesChecked} notes, ${counts.indexFilesChecked} NOTES.md checked)`
+  );
 }
-program2.command("quick-context").description("Print the contents of .context/index.md (SessionStart and PreCompact hooks call this)").action(async () => {
+program2.command("quick-context").description(
+  "Print the contents of .context/index.md (SessionStart and PreCompact hooks call this)"
+).action(async () => {
   const dd = await getDataDir();
   const indexPath = dd.contextIndexPath();
   try {
-    const content = await (0, import_promises6.readFile)(indexPath, "utf-8");
+    const content = await readFile4(indexPath, "utf-8");
     process.stdout.write(content);
   } catch {
   }
 });
 async function walkNotes(dir) {
   const results = [];
-  const entries = await (0, import_promises6.readdir)(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await readdir3(dir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
-    const full = (0, import_node_path6.join)(dir, entry.name);
+    const full = join22(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name !== "_archived") {
         results.push(...await walkNotes(full));
@@ -7726,7 +7918,9 @@ async function walkNotes(dir) {
   }
   return results;
 }
-program2.command("ui-exec", { hidden: true }).description("Internal-only UI bridge command").action(async () => {
+program2.command("ui-exec", { hidden: true }).description(
+  "Internal-only UI bridge command"
+).action(async () => {
   const raw = await readStdin();
   if (!raw) {
     process.stderr.write("ui-exec: no input received on stdin\n");
@@ -7745,44 +7939,48 @@ program2.command("ui-exec", { hidden: true }).description("Internal-only UI brid
     switch (command) {
       case "list-notes": {
         const paths = await walkNotes(dd.notesDir());
-        const notes = await Promise.all(paths.map(async (absPath) => {
-          const raw2 = await (0, import_promises6.readFile)(absPath, "utf-8");
-          const { metadata } = parseMarkdownNote(raw2);
-          return {
-            // path relative to data root for portable display
-            path: absPath.slice(dd.rootDir.length + 1),
-            type: metadata["type"] ?? null,
-            title: metadata["title"] ?? null,
-            description: metadata["description"] ?? null,
-            tags: metadata["tags"] ?? [],
-            updated: metadata["updated"] ?? null
-          };
-        }));
+        const notes = await Promise.all(
+          paths.map(async (absPath) => {
+            const raw2 = await readFile4(absPath, "utf-8");
+            const { metadata } = parseMarkdownNote(raw2);
+            return {
+              // path relative to data root for portable display
+              path: absPath.slice(dd.rootDir.length + 1),
+              type: metadata["type"] ?? null,
+              title: metadata["title"] ?? null,
+              description: metadata["description"] ?? null,
+              tags: metadata["tags"] ?? [],
+              updated: metadata["updated"] ?? null
+            };
+          })
+        );
         process.stdout.write(JSON.stringify({ ok: true, data: { notes } }));
         break;
       }
       case "list-inbox": {
         const inboxDir = dd.inboxDir();
-        const entries = await (0, import_promises6.readdir)(inboxDir, { withFileTypes: true }).catch(() => []);
-        const items = await Promise.all(entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map(async (e) => {
-          const absPath = (0, import_node_path6.join)(inboxDir, e.name);
-          const raw2 = await (0, import_promises6.readFile)(absPath, "utf-8");
-          const { metadata, body } = parseMarkdownNote(raw2);
-          return {
-            filename: e.name,
-            created: metadata["created"] ?? null,
-            type: metadata["type"] ?? null,
-            tags: metadata["tags"] ?? [],
-            content: body.trim()
-          };
-        }));
+        const entries = await readdir3(inboxDir, { withFileTypes: true }).catch(() => []);
+        const items = await Promise.all(
+          entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map(async (e) => {
+            const absPath = join22(inboxDir, e.name);
+            const raw2 = await readFile4(absPath, "utf-8");
+            const { metadata, body } = parseMarkdownNote(raw2);
+            return {
+              filename: e.name,
+              created: metadata["created"] ?? null,
+              type: metadata["type"] ?? null,
+              tags: metadata["tags"] ?? [],
+              content: body.trim()
+            };
+          })
+        );
         process.stdout.write(JSON.stringify({ ok: true, data: { items } }));
         break;
       }
       case "get-context": {
         let content = "";
         try {
-          content = await (0, import_promises6.readFile)(dd.contextIndexPath(), "utf-8");
+          content = await readFile4(dd.contextIndexPath(), "utf-8");
         } catch {
         }
         process.stdout.write(JSON.stringify({ ok: true, data: { content } }));
@@ -7792,7 +7990,7 @@ program2.command("ui-exec", { hidden: true }).description("Internal-only UI brid
         const date = typeof input["date"] === "string" ? input["date"] : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
         let content = "";
         try {
-          content = await (0, import_promises6.readFile)((0, import_node_path6.join)(dd.reportsDir(), `${date}.md`), "utf-8");
+          content = await readFile4(join22(dd.reportsDir(), `${date}.md`), "utf-8");
         } catch {
         }
         process.stdout.write(JSON.stringify({ ok: true, data: { content, date } }));
@@ -7802,13 +8000,15 @@ program2.command("ui-exec", { hidden: true }).description("Internal-only UI brid
         const rawFilename = typeof input["filename"] === "string" ? input["filename"] : "";
         const rawStatus = typeof input["status"] === "string" ? input["status"] : "processed";
         const reason = typeof input["reason"] === "string" ? input["reason"] : void 0;
-        const filename = (0, import_node_path6.basename)(rawFilename);
+        const filename = basename3(rawFilename);
         if (!filename || !filename.endsWith(".md") || filename !== rawFilename) {
           process.stderr.write("ui-exec: process-inbox requires a plain .md filename\n");
           process.exit(1);
         }
         if (rawStatus !== "processed" && rawStatus !== "user-ignored") {
-          process.stderr.write('ui-exec: process-inbox status must be "processed" or "user-ignored"\n');
+          process.stderr.write(
+            'ui-exec: process-inbox status must be "processed" or "user-ignored"\n'
+          );
           process.exit(1);
         }
         const inbox = new InboxStorage(dd);