@nseng-ai/ns 0.1.1 → 0.1.2

package/kernel/cli.js

@@ -3458,7 +3458,7 @@ var require_commander = __commonJS({
 });
 
 // ../../kernel/src/cli/index.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 
 // ../../infra/clinkr/src/exit.ts
 import { z } from "zod";
@@ -3516,6 +3516,14 @@ function ok(data, overrides = {}) {
     ...overrides.markdown === void 0 ? {} : { markdown: overrides.markdown }
   };
 }
+function negative(message, options = {}) {
+  return {
+    type: "negative",
+    message,
+    ...options.data === void 0 ? {} : { data: options.data },
+    ...options.human === void 0 ? {} : { human: options.human }
+  };
+}
 function failure(errorType, message, data) {
   return { type: "failure", errorType, message, ...data === void 0 ? {} : { data } };
 }
@@ -4714,6 +4722,9 @@ function optionalEntry(key, value) {
 function formatErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function resolveHomeDir(explicit, env) {
+  return explicit ?? env.HOME;
+}
 function isPathInside(parent, child) {
   const relativePath = relative(resolve(parent), resolve(child));
   return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
@@ -4925,8 +4936,8 @@ import { spawn } from "node:child_process";
 // ../../infra/foundation/src/time/timers.ts
 var TimerScheduler = class {
   async delay(delayMs) {
-    await new Promise((resolve5) => {
-      this.setTimeout(resolve5, delayMs);
+    await new Promise((resolve6) => {
+      this.setTimeout(resolve6, delayMs);
     });
   }
 };
@@ -4953,7 +4964,7 @@ var DEFAULT_TIMEOUT_KILL_GRACE_MS = 5e3;
 var TIMEOUT_EXIT_CODE = 124;
 var STARTUP_FAILURE_EXIT_CODE = 127;
 async function runCommand(command, args, options = {}) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const timers = options.timers ?? systemTimerScheduler;
     let stdout = "";
     let stderr = "";
@@ -4983,7 +4994,7 @@ async function runCommand(command, args, options = {}) {
       if (hasSettled) return;
       hasSettled = true;
       clearTimers();
-      resolve5({
+      resolve6({
         stdout,
         stderr,
         code: hasTimedOut ? TIMEOUT_EXIT_CODE : exitCode,
@@ -5065,6 +5076,8 @@ function defineRepoLocalNsExtensionDescriptor(descriptor) {
 import { z as z7 } from "zod";
 
 // ../../kernel/src/sdk/extension-manifest.ts
+var nsExtensionPointAcceptsValues = ["hook", "prompt"];
+var nsExtensionPointSemanticsValues = ["additive", "override"];
 var nsExtensionManifestCommandSchema = z7.looseObject({
   name: z7.string().optional(),
   path: z7.array(z7.string()).optional(),
@@ -5073,10 +5086,18 @@ var nsExtensionManifestCommandSchema = z7.looseObject({
   fullDescription: z7.string().optional(),
   entry: z7.string().optional()
 });
+var nsExtensionManifestPointSchema = z7.looseObject({
+  path: z7.array(z7.string()).optional(),
+  accepts: z7.enum(nsExtensionPointAcceptsValues).optional(),
+  semantics: z7.enum(nsExtensionPointSemanticsValues).optional(),
+  default: z7.string().optional(),
+  description: z7.string().optional()
+});
 var nsExtensionManifestSchema = z7.looseObject({
   description: z7.string().optional(),
   group: z7.string().optional(),
-  commands: z7.array(z7.unknown()).optional()
+  commands: z7.array(z7.unknown()).optional(),
+  points: z7.array(z7.unknown()).optional()
 });
 var nsExtensionPackageManifestSchema = z7.looseObject({
   description: z7.string().optional(),
@@ -5175,6 +5196,7 @@ var noopNsCommandIo = {
   }
 };
 var noopNsProgress = {
+  isLive: false,
   phase: () => {
   }
 };
@@ -5365,6 +5387,7 @@ function createTextGenerator() {
 function createRealNsCommandContext(options = {}) {
   const cwd = options.cwd ?? process4.cwd();
   const env = options.env ?? process4.env;
+  const homeDir = resolveHomeDir(options.homeDir, env);
   const textGenerator = createTextGenerator();
   const confirm = createTerminalConfirmPrompt();
   const stdout = (text) => process4.stdout.write(text);
@@ -5373,6 +5396,7 @@ function createRealNsCommandContext(options = {}) {
   return {
     cwd,
     env,
+    ...optionalEntry("homeDir", homeDir),
     textGenerator,
     commandIo,
     progress: noopNsProgress,
@@ -5623,141 +5647,1722 @@ function renderNsShellWrapperScript() {
 }
 
 // ../../kernel/src/extensions/registry.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2 } from "node:fs";
-import { dirname as dirname3, join as join4, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync2 } from "node:fs";
+import { dirname as dirname4, join as join6, resolve as resolve5 } from "node:path";
 import process5 from "node:process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../../kernel/src/extensions/command-registry.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 
-// ../../kernel/src/extensions/zod-issue-path.ts
-function classifyZodIssuePath(issue, rules, fallback) {
-  if (issue === void 0) return fallback;
-  for (const rule of rules) {
-    if (zodIssuePathMatchesRule(issue.path, rule)) return rule.value;
+// ../../kernel/src/extensions/built-in-extension-commands.ts
+import { z as z11 } from "zod";
+
+// ../../kernel/src/project-config/points.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join3, resolve as resolve3 } from "node:path";
+
+// ../../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
   }
-  return fallback;
+  return codeblock;
 }
-function classifyFirstMatchingZodIssuePath(issues, rules, fallback) {
-  for (const issue of issues) {
-    const kind = classifyZodIssuePath(issue, rules, fallback);
-    if (kind !== fallback) return kind;
+var TomlError = class extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
   }
-  return fallback;
+};
+
+// ../../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/util.js
+function isEscaped(str, ptr) {
+  let i = 0;
+  while (str[ptr - ++i] === "\\")
+    ;
+  return --i && i % 2;
+}
+function indexOfNewline(str, start = 0, end = str.length) {
+  let idx = str.indexOf("\n", start);
+  if (str[idx - 1] === "\r")
+    idx--;
+  return idx <= end ? idx : -1;
+}
+function skipComment(str, ptr) {
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "\n")
+      return i;
+    if (c === "\r" && str[i + 1] === "\n")
+      return i + 1;
+    if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: str,
+        ptr
+      });
+    }
+  }
+  return str.length;
 }
-function zodIssuePathMatchesRule(path, rule) {
-  if (rule.match === "exact" && path.length !== rule.pattern.length) return false;
-  if (rule.match === "prefix" && path.length < rule.pattern.length) return false;
-  return rule.pattern.every((segment, index) => zodIssuePathSegmentMatches(segment, path[index]));
+function skipVoid(str, ptr, banNewLines, banComments) {
+  let c;
+  while (1) {
+    while ((c = str[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n"))
+      ptr++;
+    if (banComments || c !== "#")
+      break;
+    ptr = skipComment(str, ptr);
+  }
+  return ptr;
+}
+function skipUntil(str, ptr, sep, end, banNewLines = false) {
+  if (!end) {
+    ptr = indexOfNewline(str, ptr);
+    return ptr < 0 ? str.length : ptr;
+  }
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "#") {
+      i = indexOfNewline(str, i);
+    } else if (c === sep) {
+      return i + 1;
+    } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
+      return i;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: str,
+    ptr
+  });
 }
-function zodIssuePathSegmentMatches(segment, value) {
-  if (typeof segment === "string") return value === segment;
-  return typeof value === "number";
+function getStringEnd(str, seek) {
+  let first = str[seek];
+  let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first;
+  seek += target.length - 1;
+  do
+    seek = str.indexOf(target, ++seek);
+  while (seek > -1 && first !== "'" && isEscaped(str, seek));
+  if (seek > -1) {
+    seek += target.length;
+    if (target.length > 1) {
+      if (str[seek] === first)
+        seek++;
+      if (str[seek] === first)
+        seek++;
+    }
+  }
+  return seek;
 }
 
-// ../../kernel/src/extensions/command-registry.ts
-var NS_COMMAND_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
-var NS_COMMAND_NAME_RULE = "[a-z][a-z0-9-]*";
-var builtInCommandDefinitions = {};
-var nsCommandSchema = z10.object({
-  name: z10.string(),
-  summary: z10.string(),
-  description: z10.string(),
-  schema: z10.custom(isZodObjectSchema).optional(),
-  positionals: z10.custom(isRecord).optional(),
-  options: z10.custom(isRecord).optional(),
-  resultSchema: z10.custom(isZodSchema).optional(),
-  renderHuman: z10.custom((value) => typeof value === "function").optional(),
-  renderMarkdown: z10.custom((value) => typeof value === "function").optional(),
-  completionProvider: z10.custom((value) => typeof value === "function").optional(),
-  run: z10.custom((value) => typeof value === "function")
-});
-var nsExtensionSchema = z10.object({
-  commands: z10.array(nsCommandSchema).optional().default([])
-});
-var nsResultSchema = z10.discriminatedUnion("ok", [
-  z10.object({ ok: z10.literal(true), message: z10.string() }),
-  z10.object({ ok: z10.literal(false), exitCode: z10.number(), message: z10.string() })
-]);
-function commandSegments(path) {
-  if (path.segments !== void 0) return path.segments;
-  return path.group === void 0 ? [path.name] : [path.group, path.name];
-}
-function commandKey(path) {
-  return commandSegments(path).join("/");
-}
-function commandLeafName(path) {
-  return path.segments?.at(-1) ?? path.name;
+// ../../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date === "string") {
+      let match = date.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date = `0000-01-01T${date}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) {
+          date = "";
+        } else {
+          offset = match[3] || null;
+          date = date.toUpperCase();
+          if (!offset && hasTime)
+            date += "Z";
+        }
+      } else {
+        date = "";
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// ../../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/primitive.js
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+var ESCAPE_REGEX = /^[0-9a-f]{2,8}$/i;
+var ESC_MAP = {
+  b: "\b",
+  t: "	",
+  n: "\n",
+  f: "\f",
+  r: "\r",
+  e: "\x1B",
+  '"': '"',
+  "\\": "\\"
+};
+function parseString(str, ptr = 0, endPtr = str.length) {
+  let isLiteral = str[ptr] === "'";
+  let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
+  if (isMultiline) {
+    endPtr -= 2;
+    if (str[ptr += 2] === "\r")
+      ptr++;
+    if (str[ptr] === "\n")
+      ptr++;
+  }
+  let tmp = 0;
+  let isEscape;
+  let parsed = "";
+  let sliceStart = ptr;
+  while (ptr < endPtr - 1) {
+    let c = str[ptr++];
+    if (c === "\n" || c === "\r" && str[ptr] === "\n") {
+      if (!isMultiline) {
+        throw new TomlError("newlines are not allowed in strings", {
+          toml: str,
+          ptr: ptr - 1
+        });
+      }
+    } else if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    }
+    if (isEscape) {
+      isEscape = false;
+      if (c === "x" || c === "u" || c === "U") {
+        let code = str.slice(ptr, ptr += c === "x" ? 2 : c === "u" ? 4 : 8);
+        if (!ESCAPE_REGEX.test(code)) {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+        try {
+          parsed += String.fromCodePoint(parseInt(code, 16));
+        } catch {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+      } else if (isMultiline && (c === "\n" || c === " " || c === "	" || c === "\r")) {
+        ptr = skipVoid(str, ptr - 1, true);
+        if (str[ptr] !== "\n" && str[ptr] !== "\r") {
+          throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+        ptr = skipVoid(str, ptr);
+      } else if (c in ESC_MAP) {
+        parsed += ESC_MAP[c];
+      } else {
+        throw new TomlError("unrecognized escape sequence", {
+          toml: str,
+          ptr: tmp
+        });
+      }
+      sliceStart = ptr;
+    } else if (!isLiteral && c === "\\") {
+      tmp = ptr - 1;
+      isEscape = true;
+      parsed += str.slice(sliceStart, tmp);
+    }
+  }
+  return parsed + str.slice(sliceStart, endPtr - 1);
 }
-function commandDisplayName(path) {
-  return commandSegments(path).join(" ");
+function parseValue(value, toml, ptr, integersAsBigInt) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value === "-inf")
+    return -Infinity;
+  if (value === "inf" || value === "+inf")
+    return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan")
+    return NaN;
+  if (value === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) {
+      throw new TomlError("leading zeroes are not allowed", {
+        toml,
+        ptr
+      });
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", {
+        toml,
+        ptr
+      });
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", {
+          toml,
+          ptr
+        });
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid()) {
+    throw new TomlError("invalid value", {
+      toml,
+      ptr
+    });
+  }
+  return date;
 }
-function commandPathMatches(left, right) {
-  return commandKey(left) === commandKey(right);
+
+// ../../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/extract.js
+function sliceAndTrimEndOf(str, startPtr, endPtr) {
+  let value = str.slice(startPtr, endPtr);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > -1) {
+    skipComment(str, commentIdx);
+    value = value.slice(0, commentIdx);
+  }
+  return [value.trimEnd(), commentIdx];
+}
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+  if (depth === 0) {
+    throw new TomlError("document contains excessively nested structures. aborting.", {
+      toml: str,
+      ptr
+    });
+  }
+  let c = str[ptr];
+  if (c === "[" || c === "{") {
+    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] === ",")
+        endPtr2++;
+      else if (str[endPtr2] !== end) {
+        throw new TomlError("expected comma or end of structure", {
+          toml: str,
+          ptr: endPtr2
+        });
+      }
+    }
+    return [value, endPtr2];
+  }
+  let endPtr;
+  if (c === '"' || c === "'") {
+    endPtr = getStringEnd(str, ptr);
+    let parsed = parseString(str, ptr, endPtr);
+    if (end) {
+      endPtr = skipVoid(str, endPtr);
+      if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") {
+        throw new TomlError("unexpected character encountered", {
+          toml: str,
+          ptr: endPtr
+        });
+      }
+      endPtr += +(str[endPtr] === ",");
+    }
+    return [parsed, endPtr];
+  }
+  endPtr = skipUntil(str, ptr, ",", end);
+  let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","));
+  if (!slice[0]) {
+    throw new TomlError("incomplete key-value declaration: no value specified", {
+      toml: str,
+      ptr
+    });
+  }
+  if (end && slice[1] > -1) {
+    endPtr = skipVoid(str, ptr + slice[1]);
+    endPtr += +(str[endPtr] === ",");
+  }
+  return [
+    parseValue(slice[0], str, ptr, integersAsBigInt),
+    endPtr
+  ];
 }
-function listBuiltInNsCommandCandidates() {
-  return Object.entries(builtInCommandDefinitions).map(([name, definition]) => ({
-    name,
-    description: definition.summary,
-    fullDescription: definition.description,
-    source: { level: "built-in", label: `built-in command ${name}` },
-    command: definition.command
-  })).sort((left, right) => commandKey(left).localeCompare(commandKey(right)));
+
+// ../../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/struct.js
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(str, ptr, end = "=") {
+  let dot = ptr - 1;
+  let parsed = [];
+  let endPtr = str.indexOf(end, ptr);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: str,
+      ptr
+    });
+  }
+  do {
+    let c = str[ptr = ++dot];
+    if (c !== " " && c !== "	") {
+      if (c === '"' || c === "'") {
+        if (c === str[ptr + 1] && c === str[ptr + 2]) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        let eos = getStringEnd(str, ptr);
+        if (eos < 0) {
+          throw new TomlError("unfinished string encountered", {
+            toml: str,
+            ptr
+          });
+        }
+        dot = str.indexOf(".", eos);
+        let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: str,
+            ptr: ptr + dot + newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: str,
+            ptr: eos
+          });
+        }
+        if (endPtr < eos) {
+          endPtr = str.indexOf(end, eos);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: str,
+              ptr
+            });
+          }
+        }
+        parsed.push(parseString(str, ptr, eos));
+      } else {
+        dot = str.indexOf(".", ptr);
+        let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "}" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let k;
+      let t = res;
+      let hasOwn = false;
+      let [key, keyEndPtr] = parseKey(str, ptr - 1);
+      for (let i = 0; i < key.length; i++) {
+        if (i)
+          t = hasOwn ? t[k] : t[k] = {};
+        k = key[i];
+        if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+          throw new TomlError("trying to redefine an already defined value", {
+            toml: str,
+            ptr
+          });
+        }
+        if (!hasOwn && k === "__proto__") {
+          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        }
+      }
+      if (hasOwn) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: str,
+          ptr
+        });
+      }
+      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+      seen.add(value);
+      t[k] = value;
+      ptr = valueEndPtr;
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished table encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+function parseArray(str, ptr, depth, integersAsBigInt) {
+  let res = [];
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "]" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
+      res.push(e[0]);
+      ptr = e[1];
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished array encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
 }
-function listStaticNsCommandInfos() {
-  return listBuiltInNsCommandCandidates().map(toCommandCliInfo);
+
+// ../../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/parse.js
+function peekTable(key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let res = {};
+  let meta = {};
+  let tbl = res;
+  let m = meta;
+  for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
+    if (toml[ptr] === "[") {
+      let isTableArray = toml[++ptr] === "[";
+      let k = parseKey(toml, ptr += +isTableArray, "]");
+      if (isTableArray) {
+        if (toml[k[1] - 1] !== "]") {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: k[1] - 1
+          });
+        }
+        k[1]++;
+      }
+      let p = peekTable(
+        k[0],
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+      ptr = k[1];
+    } else {
+      let k = parseKey(toml, ptr);
+      let p = peekTable(
+        k[0],
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
+      p[1][p[0]] = v[0];
+      ptr = v[1];
+    }
+    ptr = skipVoid(toml, ptr, true);
+    if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr
+      });
+    }
+    ptr = skipVoid(toml, ptr);
+  }
+  return res;
 }
-function toCommandCliInfo(candidate2) {
-  return {
-    ...candidate2.group === void 0 ? {} : { group: candidate2.group },
-    ...candidate2.segments === void 0 ? {} : { segments: candidate2.segments },
-    ...candidate2.groupDescription === void 0 ? {} : { groupDescription: candidate2.groupDescription },
-    name: candidate2.name,
-    description: candidate2.description,
-    fullDescription: candidate2.fullDescription
+
+// ../../kernel/src/project-config/points.ts
+import { z as z10 } from "zod";
+
+// ../../kernel/src/runtime/diagnostics.ts
+function makeKernelDiagnostic(request) {
+  const base = {
+    severity: request.severity ?? "error",
+    code: request.code,
+    message: request.message,
+    ...optionalEntry("path", request.path)
   };
+  return { ...base, ...request.extra ?? {} };
 }
-function commandInfoForLoadedCommand(command, sourceLevel, path) {
-  const definition = path.group === void 0 ? builtInCommandDefinitions[command.name] : void 0;
-  if (sourceLevel === "built-in" && definition !== void 0) {
+
+// ../../kernel/src/runtime/extension-root-discovery.ts
+import { existsSync as existsSync3, readdirSync, statSync } from "node:fs";
+import { join as join2 } from "node:path";
+function scanExtensionRoot(rootDir) {
+  if (!existsSync3(rootDir)) return { entries: [], diagnostics: [] };
+  let isDirectory;
+  try {
+    isDirectory = statSync(rootDir).isDirectory();
+  } catch (error) {
     return {
-      name: command.name,
-      description: definition.summary,
-      fullDescription: definition.description
+      entries: [],
+      diagnostics: [
+        diagnostic(
+          "extension_root_stat_failed",
+          `Could not inspect extension root ${rootDir}.
+${formatErrorMessage(error)}`,
+          { path: rootDir }
+        )
+      ]
     };
   }
-  return toCommandCliInfo({
-    ...path,
-    name: command.name,
-    description: command.summary,
-    fullDescription: command.description
-  });
-}
-function validateNsExtensionContribution(contribution, expectedPath, sourceLabel) {
-  const expectedName = typeof expectedPath === "string" ? expectedPath : commandLeafName(expectedPath);
-  const parsed = nsExtensionSchema.safeParse(contribution);
-  if (!parsed.success) {
+  if (!isDirectory) {
     return {
-      ok: false,
-      message: `Invalid ns extension contribution ${sourceLabel}: ${formatNsExtensionIssue(parsed.error.issues[0])}`
+      entries: [],
+      diagnostics: [
+        diagnostic(
+          "extension_root_not_directory",
+          `Extension root must be a directory: ${rootDir}.`,
+          {
+            path: rootDir
+          }
+        )
+      ]
     };
   }
-  const command = findCommandEntry(parsed.data, expectedName);
-  if (command === void 0) {
+  let dirents;
+  try {
+    dirents = readdirSync(rootDir, { withFileTypes: true });
+  } catch (error) {
     return {
-      ok: false,
-      message: `Invalid ns extension contribution ${sourceLabel}: expected a command entry named "${expectedName}" in commands[].`
+      entries: [],
+      diagnostics: [
+        diagnostic(
+          "extension_root_read_failed",
+          `Could not read extension root ${rootDir}.
+${formatErrorMessage(error)}`,
+          { path: rootDir }
+        )
+      ]
     };
   }
-  return { ok: true, command };
+  const entries = [];
+  for (const dirent of dirents.sort((left, right) => left.name.localeCompare(right.name))) {
+    const entryPath = join2(rootDir, dirent.name);
+    if (dirent.isFile()) {
+      entries.push({ type: "file", name: dirent.name, path: entryPath });
+      continue;
+    }
+    if (!dirent.isDirectory()) continue;
+    const packageJsonPath = join2(entryPath, "package.json");
+    if (existsSync3(packageJsonPath)) {
+      entries.push({ type: "directory", name: dirent.name, path: entryPath, packageJsonPath });
+      continue;
+    }
+    const indexPath = firstExistingDirectoryIndex(entryPath);
+    entries.push({
+      type: "directory",
+      name: dirent.name,
+      path: entryPath,
+      ...indexPath === void 0 ? {} : { indexPath }
+    });
+  }
+  return { entries, diagnostics: [] };
 }
-async function executeNsCommand(ctx, command, request) {
-  const parsedRequest = (command.schema ?? z10.object({})).safeParse(request);
-  if (!parsedRequest.success) {
-    return failed(
-      `Invalid request for command ${command.name}: ${parsedRequest.error.issues[0]?.message ?? "request did not match command schema"}`,
-      2
+function firstExistingDirectoryIndex(entryPath) {
+  for (const indexFileName of ["index.ts", "index.js"]) {
+    const indexPath = join2(entryPath, indexFileName);
+    if (existsSync3(indexPath)) return indexPath;
+  }
+  return void 0;
+}
+function diagnostic(code, message, options = {}) {
+  return makeKernelDiagnostic({ code, message, ...optionalEntry("path", options.path) });
+}
+
+// ../../kernel/src/sdk/command-name.ts
+var NS_COMMAND_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+var NS_COMMAND_NAME_RULE = "[a-z][a-z0-9-]*";
+
+// ../../kernel/src/project-config/points.ts
+var emptyLoadedProjectConfig = { points: [], settings: /* @__PURE__ */ new Map() };
+function tryProjectConfigProbe(probe) {
+  try {
+    return probe();
+  } catch (error) {
+    if (isNodeFileNotFound(error)) return { type: "missing" };
+    return { type: "error", message: formatErrorMessage(error) };
+  }
+}
+var nodeProjectConfigGateway = {
+  readTextFile(request) {
+    return tryProjectConfigProbe(() => ({
+      type: "found",
+      text: readFileSync2(join3(request.repoRoot, request.relativePath), "utf8")
+    }));
+  },
+  pathExists(request) {
+    return tryProjectConfigProbe(
+      () => existsSync4(join3(request.repoRoot, request.relativePath)) ? { type: "present" } : { type: "missing" }
+    );
+  }
+};
+function loadProjectConfig(request) {
+  const readResult = request.gateway.readTextFile({
+    repoRoot: request.repoRoot,
+    relativePath: "ns.toml"
+  });
+  if (readResult.type === "missing") {
+    return {
+      ok: true,
+      config: emptyLoadedProjectConfig,
+      diagnostics: []
+    };
+  }
+  if (readResult.type === "error") {
+    return {
+      ok: false,
+      diagnostics: [
+        diagnostic2("ns_toml_read_failed", `Failed to read ns.toml: ${readResult.message}`)
+      ]
+    };
+  }
+  return parseProjectConfigToml(readResult.text, {
+    pathLabel: "ns.toml",
+    pointsTable: { mode: "validate", pointDefinitions: request.pointDefinitions },
+    settingsSchemas: request.settingsSchemas ?? []
+  });
+}
+function parseProjectConfigToml(source, request) {
+  const pathLabel = request.pathLabel ?? "ns.toml";
+  let parsed;
+  try {
+    parsed = parse(source);
+  } catch (error) {
+    const causeMessage = formatErrorMessage(error);
+    return {
+      ok: false,
+      diagnostics: [
+        diagnostic2("ns_toml_invalid", `${pathLabel}: Invalid TOML.
+${causeMessage}`, {
+          causeMessage
+        })
+      ]
+    };
+  }
+  const documentResult = tomlDocumentSchema.safeParse(parsed);
+  if (!documentResult.success) {
+    return {
+      ok: false,
+      diagnostics: [
+        diagnostic2("ns_toml_invalid", `${pathLabel}: top-level TOML document must be a table.`)
+      ]
+    };
+  }
+  const document = documentResult.data;
+  const pointsResult = request.pointsTable.mode === "skip" ? { installations: [], diagnostics: [] } : parsePointsTable({
+    pathLabel,
+    value: document["points"],
+    pointDefinitions: request.pointsTable.pointDefinitions
+  });
+  const settingsResult = parseDeclaredSettings({
+    pathLabel,
+    document,
+    settingsSchemas: request.settingsSchemas ?? []
+  });
+  const diagnostics = [...pointsResult.diagnostics, ...settingsResult.diagnostics];
+  const config = { points: pointsResult.installations, settings: settingsResult.settings };
+  if (diagnostics.length > 0) return { ok: false, config, diagnostics };
+  return { ok: true, config, diagnostics: [] };
+}
+function discoverPointDefinitionsInRoot(rootDir) {
+  const rootScan = scanExtensionRoot(rootDir);
+  if (rootScan.diagnostics.length > 0) {
+    return { pointDefinitions: [], diagnostics: rootScan.diagnostics };
+  }
+  const pointDefinitions = [];
+  const diagnostics = [];
+  for (const entry2 of rootScan.entries) {
+    if (entry2.type !== "directory" || entry2.packageJsonPath === void 0) continue;
+    const packageResult = discoverPackagePointDefinitions(entry2.packageJsonPath);
+    pointDefinitions.push(...packageResult.pointDefinitions);
+    diagnostics.push(...packageResult.diagnostics);
+  }
+  return { pointDefinitions, diagnostics };
+}
+function loadPointCatalog(request) {
+  const definitionResult = request.pointDefinitions === void 0 ? discoverPointDefinitionsInRoot(
+    join3(request.repoRoot, request.extensionRoot ?? ".ns/extensions")
+  ) : { pointDefinitions: request.pointDefinitions, diagnostics: [] };
+  const configResult = loadProjectConfig({
+    repoRoot: request.repoRoot,
+    gateway: request.gateway,
+    pointDefinitions: definitionResult.pointDefinitions,
+    settingsSchemas: request.settingsSchemas ?? []
+  });
+  return buildPointCatalog({
+    repoRoot: request.repoRoot,
+    gateway: request.gateway,
+    pointDefinitions: definitionResult.pointDefinitions,
+    config: configResult.config ?? emptyLoadedProjectConfig,
+    diagnostics: [...definitionResult.diagnostics, ...configResult.diagnostics],
+    ...optionalEntry("promptEnvOverride", request.promptEnvOverride),
+    env: request.env ?? {}
+  });
+}
+function resolvePromptPointSource(catalog, pointId) {
+  const entry2 = catalog.entries.find((catalogEntry) => catalogEntry.definition.id === pointId);
+  if (entry2 === void 0 || entry2.definition.accepts !== "prompt")
+    return { type: "missing", pointId };
+  const envOverride = findCatalogInstallation(entry2, "env-prompt");
+  if (envOverride !== void 0) {
+    return {
+      type: "env",
+      pointId,
+      envVar: envOverride.envVar,
+      path: envOverride.path
+    };
+  }
+  const configured = findPromptConfigInstallation(entry2);
+  if (configured !== void 0) {
+    return { type: "ns.toml", pointId, path: configured.installation.path };
+  }
+  const conventional = findCatalogInstallation(entry2, "conventional-prompt");
+  if (conventional !== void 0) {
+    return { type: "conventional", pointId, path: conventional.path };
+  }
+  if (entry2.definition.defaultPath !== void 0 && entry2.definition.manifestPath !== void 0) {
+    return {
+      type: "default",
+      pointId,
+      path: entry2.definition.defaultPath,
+      manifestPath: entry2.definition.manifestPath
+    };
+  }
+  return { type: "missing", pointId };
+}
+function buildPointCatalog(request) {
+  const diagnostics = [...request.diagnostics ?? []];
+  const installationsByPoint = /* @__PURE__ */ new Map();
+  for (const installation of request.config.points) {
+    const existing = installationsByPoint.get(installation.pointId) ?? [];
+    installationsByPoint.set(installation.pointId, [
+      ...existing,
+      { source: "ns.toml", installation }
+    ]);
+  }
+  const entries = [];
+  for (const definition of [...request.pointDefinitions].sort(
+    (left, right) => left.id.localeCompare(right.id)
+  )) {
+    let installations = installationsByPoint.get(definition.id) ?? [];
+    if (definition.accepts === "prompt") {
+      const envOverride = findPromptEnvOverride({
+        pointId: definition.id,
+        env: request.env ?? {},
+        ...optionalEntry("override", request.promptEnvOverride)
+      });
+      if (envOverride !== void 0) {
+        installations = [{ source: "env-prompt", ...envOverride }, ...installations];
+        diagnostics.push(
+          diagnostic2(
+            "point_prompt_env_override_in_effect",
+            `Prompt point ${definition.id} is overridden by env var ${envOverride.envVar}.`,
+            { path: definition.id, severity: "info" }
+          )
+        );
+      }
+    }
+    if (definition.accepts === "prompt" && installations.length === 0) {
+      const conventionalPath = `.ns/prompts/${definition.id}.md`;
+      const existsResult = request.gateway.pathExists({
+        repoRoot: request.repoRoot,
+        relativePath: conventionalPath
+      });
+      if (existsResult.type === "present") {
+        installations = [
+          { source: "conventional-prompt", pointId: definition.id, path: conventionalPath }
+        ];
+      } else if (existsResult.type === "error") {
+        diagnostics.push(
+          diagnostic2(
+            "point_conventional_prompt_probe_failed",
+            `Failed to inspect conventional prompt installation ${conventionalPath}: ${existsResult.message}`,
+            { path: conventionalPath }
+          )
+        );
+      }
+    }
+    if (definition.semantics === "override" && installations.length > 0) {
+      diagnostics.push(
+        diagnostic2(
+          "point_override_in_effect",
+          `Override point ${definition.id} has a repo installation in effect.`,
+          { path: definition.id, severity: "info" }
+        )
+      );
+    } else if (installations.length === 0) {
+      diagnostics.push(
+        diagnostic2(
+          "point_defined_uninstalled",
+          `Point ${definition.id} is defined but not installed in this repo.`,
+          { path: definition.id, severity: "info" }
+        )
+      );
+    }
+    entries.push({ definition, installations });
+  }
+  return { entries, diagnostics };
+}
+function findCatalogInstallation(entry2, source) {
+  return entry2.installations.find(
+    (installation) => installation.source === source
+  );
+}
+function findPromptConfigInstallation(entry2) {
+  return entry2.installations.find(
+    (installation) => installation.source === "ns.toml" && installation.installation.accepts === "prompt"
+  );
+}
+function findPromptEnvOverride(request) {
+  if (request.override?.pointId !== request.pointId) return void 0;
+  const path = request.env[request.override.envVar]?.trim();
+  if (!path) return void 0;
+  return { pointId: request.pointId, envVar: request.override.envVar, path };
+}
+function parsePointsTable(request) {
+  if (request.value === void 0) return { installations: [], diagnostics: [] };
+  const diagnostics = [];
+  const tableResult = recordSchema.safeParse(request.value);
+  if (!tableResult.success) {
+    diagnostics.push(
+      diagnostic2("points_table_invalid", `${request.pathLabel}: [points] must be a TOML table.`, {
+        path: "points"
+      })
+    );
+    return { installations: [], diagnostics };
+  }
+  const definitions = new Map(
+    request.pointDefinitions.map((definition) => [definition.id, definition])
+  );
+  const installations = [];
+  for (const [pointId, value] of Object.entries(tableResult.data)) {
+    const definition = definitions.get(pointId);
+    if (definition === void 0) {
+      diagnostics.push(
+        diagnostic2(
+          "point_installation_undefined",
+          `${request.pathLabel}: [points].${JSON.stringify(pointId)} installs an undefined point.`,
+          { path: `points.${pointId}` }
+        )
+      );
+      continue;
+    }
+    const parsed = parsePointInstallation({
+      pathLabel: request.pathLabel,
+      pointId,
+      definition,
+      value
+    });
+    if (parsed.ok) installations.push(parsed.installation);
+    else diagnostics.push(parsed.diagnostic);
+  }
+  return { installations, diagnostics };
+}
+function parsePointInstallation(request) {
+  if (request.definition.accepts === "hook") {
+    return parseInstallationValue({
+      ...request,
+      schema: z10.array(z10.string()),
+      invalidMessage: `${request.pathLabel}: hook point ${request.pointId} must be an array of command strings.`,
+      buildInstallation: (commands) => ({
+        pointId: request.pointId,
+        accepts: "hook",
+        commands
+      })
+    });
+  }
+  return parseInstallationValue({
+    ...request,
+    schema: z10.string().min(1),
+    invalidMessage: `${request.pathLabel}: prompt point ${request.pointId} must be a non-empty path string.`,
+    buildInstallation: (path) => ({ pointId: request.pointId, accepts: "prompt", path })
+  });
+}
+function parseInstallationValue(request) {
+  const valueResult = request.schema.safeParse(request.value);
+  if (!valueResult.success) {
+    return {
+      ok: false,
+      diagnostic: diagnostic2("point_installation_invalid", request.invalidMessage, {
+        path: `points.${request.pointId}`
+      })
+    };
+  }
+  return { ok: true, installation: request.buildInstallation(valueResult.data) };
+}
+function parseDeclaredSettings(request) {
+  const settings = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  for (const setting of request.settingsSchemas) {
+    const settingValue = valueAtPath(request.document, setting.path);
+    if (settingValue === void 0) continue;
+    const schemaResult = setting.schema.safeParse(settingValue);
+    const key = setting.path.join(".");
+    if (!schemaResult.success) {
+      const message = setting.invalidMessage?.({ pathLabel: request.pathLabel }) ?? `${request.pathLabel}: [${key}] does not match its declared settings schema.`;
+      diagnostics.push(diagnostic2("settings_table_invalid", message, { path: key }));
+      continue;
+    }
+    settings.set(key, schemaResult.data);
+  }
+  return { settings, diagnostics };
+}
+function valueAtPath(document, path) {
+  let current = document;
+  for (const segment of path) {
+    const tableResult = recordSchema.safeParse(current);
+    if (!tableResult.success) return void 0;
+    current = tableResult.data[segment];
+    if (current === void 0) return void 0;
+  }
+  return current;
+}
+function discoverPackagePointDefinitions(packageJsonPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+  } catch (error) {
+    return {
+      pointDefinitions: [],
+      diagnostics: [
+        diagnostic2(
+          "extension_manifest_parse_failed",
+          `Could not parse extension manifest ${packageJsonPath}.
+${formatErrorMessage(error)}`,
+          { path: packageJsonPath }
+        )
+      ]
+    };
+  }
+  const manifestResult = nsExtensionPackageManifestSchema.safeParse(parsed);
+  if (!manifestResult.success) {
+    return {
+      pointDefinitions: [],
+      diagnostics: [
+        diagnostic2(
+          "extension_manifest_invalid",
+          `Extension manifest contains invalid ns metadata: ${packageJsonPath}.`,
+          { path: packageJsonPath }
+        )
+      ]
+    };
+  }
+  const manifest = manifestResult.data;
+  if (manifest.ns?.points === void 0) return { pointDefinitions: [], diagnostics: [] };
+  const group = readManifestNameSegment(manifest.ns.group);
+  if (group === void 0) {
+    return {
+      pointDefinitions: [],
+      diagnostics: [
+        diagnostic2(
+          "extension_manifest_point_group_invalid",
+          `Extension manifest point group must be a non-empty segment: ${packageJsonPath}.`,
+          { path: packageJsonPath }
+        )
+      ]
+    };
+  }
+  const pointDefinitions = [];
+  const diagnostics = [];
+  const location = { packageJsonPath, packageDir: dirname3(packageJsonPath) };
+  for (const point of manifest.ns.points) {
+    const pointResult = pointDefinitionFromManifestPoint({
+      group,
+      location,
+      point
+    });
+    if (pointResult.ok) pointDefinitions.push(pointResult.definition);
+    else diagnostics.push(...pointResult.diagnostics);
+  }
+  return { pointDefinitions, diagnostics };
+}
+function pointDefinitionFromManifestPoint(request) {
+  const pointResult = nsExtensionManifestPointSchema.safeParse(request.point);
+  if (!pointResult.success) {
+    return {
+      ok: false,
+      diagnostics: [
+        diagnostic2(
+          "extension_manifest_point_invalid",
+          `Extension manifest points must be objects with supported known fields: ${request.location.packageJsonPath}.`,
+          { path: request.location.packageJsonPath }
+        )
+      ]
+    };
+  }
+  const point = pointResult.data;
+  const path = parsePointManifestPath(point.path);
+  const diagnostics = [...path.diagnostics];
+  if (point.accepts === void 0) {
+    diagnostics.push(manifestPointFieldDiagnostic("accepts", request.location.packageJsonPath));
+  }
+  if (point.semantics === void 0) {
+    diagnostics.push(manifestPointFieldDiagnostic("semantics", request.location.packageJsonPath));
+  }
+  let defaultPath;
+  if (point.default !== void 0) {
+    const defaultValidation = validateManifestRelativePath({
+      location: request.location,
+      rawPath: point.default
+    });
+    if (defaultValidation.ok) defaultPath = point.default;
+    else diagnostics.push(defaultValidation.diagnostic);
+  }
+  if (diagnostics.length > 0 || path.value === void 0 || point.accepts === void 0 || point.semantics === void 0) {
+    return { ok: false, diagnostics };
+  }
+  const description = readNonEmptyString(point.description);
+  return {
+    ok: true,
+    definition: {
+      id: [request.group, ...path.value].join("."),
+      accepts: point.accepts,
+      semantics: point.semantics,
+      ...description === void 0 ? {} : { description },
+      ...defaultPath === void 0 ? {} : { defaultPath },
+      manifestPath: request.location.packageJsonPath
+    }
+  };
+}
+function parsePointManifestPath(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return {
+      value: void 0,
+      diagnostics: [manifestPointFieldDiagnostic("path", void 0)]
+    };
+  }
+  const segments = value.filter((segment) => typeof segment === "string");
+  if (segments.length !== value.length || segments.some((segment) => readManifestNameSegment(segment) === void 0)) {
+    return {
+      value: void 0,
+      diagnostics: [manifestPointFieldDiagnostic("path", void 0)]
+    };
+  }
+  return { value: segments, diagnostics: [] };
+}
+function validateManifestRelativePath(request) {
+  if (request.rawPath.trim() === "" || request.rawPath.startsWith("/") || request.rawPath.includes("\\")) {
+    return {
+      ok: false,
+      diagnostic: diagnostic2(
+        "extension_manifest_point_default_not_relative",
+        `Extension manifest point default must be a relative POSIX-style path inside the package: ${request.rawPath}.`,
+        { path: request.location.packageJsonPath }
+      )
+    };
+  }
+  if (!request.rawPath.endsWith(".md")) {
+    return {
+      ok: false,
+      diagnostic: diagnostic2(
+        "extension_manifest_point_default_not_markdown",
+        `Extension manifest point default must be a markdown file path: ${request.rawPath}.`,
+        { path: request.location.packageJsonPath }
+      )
+    };
+  }
+  const resolvedPath = resolve3(request.location.packageDir, request.rawPath);
+  if (!isPathInside(request.location.packageDir, resolvedPath)) {
+    return {
+      ok: false,
+      diagnostic: diagnostic2(
+        "extension_manifest_point_default_escapes",
+        `Extension manifest point default must not escape its package directory: ${request.rawPath}.`,
+        { path: request.location.packageJsonPath }
+      )
+    };
+  }
+  return { ok: true };
+}
+function manifestPointFieldDiagnostic(field, packageJsonPath) {
+  return diagnostic2(
+    "extension_manifest_point_field_invalid",
+    `Extension manifest point ${field} is required and must match the point manifest schema.`,
+    optionalEntry("path", packageJsonPath)
+  );
+}
+function readManifestNameSegment(value) {
+  return typeof value === "string" && NS_COMMAND_NAME_PATTERN.test(value) ? value : void 0;
+}
+function readNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function diagnostic2(code, message, options = {}) {
+  return makeKernelDiagnostic({
+    code,
+    message,
+    ...optionalEntry("path", options.path),
+    extra: optionalEntry("causeMessage", options.causeMessage),
+    ...optionalEntry("severity", options.severity)
+  });
+}
+function isNodeFileNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+var recordSchema = z10.record(z10.string(), z10.unknown());
+var tomlDocumentSchema = recordSchema;
+
+// ../../kernel/src/extensions/built-in-extension-commands.ts
+var knownPromptEnvOverride = {
+  pointId: "flow.submit.pr-description",
+  envVar: "NS_DEV_PR_DESCRIPTION_PROMPT"
+};
+var pointDiagnosticSchema = z11.object({
+  severity: z11.enum(["error", "info"]),
+  code: z11.string(),
+  message: z11.string(),
+  path: z11.string().optional()
+});
+var pointSourceSchema = z11.union([
+  z11.object({ source: z11.literal("env"), envVar: z11.string(), path: z11.string() }),
+  z11.object({ source: z11.literal("repo-prompt"), path: z11.string() }),
+  z11.object({ source: z11.literal("repo-hook"), commands: z11.array(z11.string()) }),
+  z11.object({ source: z11.literal("conventional"), path: z11.string() }),
+  z11.object({ source: z11.literal("default"), path: z11.string(), manifestPath: z11.string() }),
+  z11.object({ source: z11.literal("missing") })
+]);
+var pointSummarySchema = z11.object({
+  id: z11.string(),
+  accepts: z11.enum(nsExtensionPointAcceptsValues),
+  semantics: z11.enum(nsExtensionPointSemanticsValues),
+  description: z11.string().optional(),
+  manifestPath: z11.string().optional(),
+  defaultPath: z11.string().optional(),
+  activeSource: pointSourceSchema,
+  installationCount: z11.number().int().nonnegative()
+});
+var extensionPointsResultSchema = z11.object({
+  points: z11.array(pointSummarySchema),
+  diagnostics: z11.array(pointDiagnosticSchema)
+});
+var extensionPointsRequestSchema = z11.object({});
+var extensionPointDetailRequestSchema = z11.object({ id: z11.string().min(1) });
+var extensionPointDetailSchema = pointSummarySchema.extend({
+  installations: z11.array(pointSourceSchema)
+});
+var extensionPointDetailResultSchema = z11.object({
+  point: extensionPointDetailSchema,
+  diagnostics: z11.array(pointDiagnosticSchema)
+});
+var missingPointDataSchema = z11.object({
+  pointId: z11.string(),
+  availablePointIds: z11.array(z11.string()),
+  diagnostics: z11.array(pointDiagnosticSchema)
+});
+var extensionPointResultSchema = z11.union([
+  extensionPointDetailResultSchema,
+  missingPointDataSchema
+]);
+var extensionPointsCommand = {
+  name: "points",
+  summary: "List defined ns points and their active sources.",
+  description: "List defined ns points and their active sources.",
+  schema: extensionPointsRequestSchema,
+  resultSchema: extensionPointsResultSchema,
+  run: (ctx) => ok(toPointsResult(loadCatalog(ctx.cwd, ctx.env))),
+  renderHuman: (data) => renderPointsHuman(extensionPointsResultSchema.parse(data))
+};
+var extensionPointCommand = {
+  name: "point",
+  summary: "Show one ns point definition and its active source.",
+  description: "Show one ns point definition and its active source.",
+  schema: extensionPointDetailRequestSchema,
+  positionals: { id: { position: 0 } },
+  resultSchema: extensionPointResultSchema,
+  run: (ctx, request) => {
+    const catalog = loadCatalog(ctx.cwd, ctx.env);
+    const entry2 = catalog.entries.find((candidate2) => candidate2.definition.id === request.id);
+    if (entry2 === void 0) {
+      const data = missingPointDataSchema.parse({
+        pointId: request.id,
+        availablePointIds: catalog.entries.map((candidate2) => candidate2.definition.id),
+        diagnostics: catalog.diagnostics
+      });
+      return negative(`Point ${request.id} is not defined.`, { data });
+    }
+    return ok(toPointDetailResult(catalog, entry2));
+  },
+  renderHuman: (data) => renderPointDetailHuman(extensionPointDetailResultSchema.parse(data))
+};
+function loadCatalog(cwd, env) {
+  return loadPointCatalog({
+    repoRoot: cwd,
+    gateway: nodeProjectConfigGateway,
+    env,
+    promptEnvOverride: knownPromptEnvOverride
+  });
+}
+function toPointsResult(catalog) {
+  return {
+    points: catalog.entries.map((entry2) => toPointSummary(catalog, entry2)),
+    diagnostics: [...catalog.diagnostics]
+  };
+}
+function toPointDetailResult(catalog, entry2) {
+  return {
+    point: {
+      ...toPointSummary(catalog, entry2),
+      installations: entry2.installations.map(toPointSource)
+    },
+    diagnostics: [...diagnosticsForPoint(catalog.diagnostics, entry2.definition.id)]
+  };
+}
+function toPointSummary(catalog, entry2) {
+  return {
+    id: entry2.definition.id,
+    accepts: entry2.definition.accepts,
+    semantics: entry2.definition.semantics,
+    ...optionalEntries({
+      description: entry2.definition.description,
+      manifestPath: entry2.definition.manifestPath,
+      defaultPath: entry2.definition.defaultPath
+    }),
+    activeSource: activeSourceForEntry(catalog, entry2),
+    installationCount: entry2.installations.length
+  };
+}
+function activeSourceForEntry(catalog, entry2) {
+  if (entry2.definition.accepts === "prompt") {
+    return pointSourceFromPromptSource(resolvePromptPointSource(catalog, entry2.definition.id));
+  }
+  const installation = entry2.installations.find(
+    (candidate2) => candidate2.source === "ns.toml" && candidate2.installation.accepts === "hook"
+  );
+  if (installation?.source === "ns.toml" && installation.installation.accepts === "hook") {
+    return pointSourceFromHookCommands(installation.installation.commands);
+  }
+  return missingPointSource();
+}
+function toPointSource(installation) {
+  if (installation.source === "env-prompt") {
+    return envPointSource(installation.envVar, installation.path);
+  }
+  if (installation.source === "conventional-prompt") {
+    return conventionalPointSource(installation.path);
+  }
+  if (installation.installation.accepts === "hook") {
+    return pointSourceFromHookCommands(installation.installation.commands);
+  }
+  return repoPromptPointSource(installation.installation.path);
+}
+function pointSourceFromPromptSource(source) {
+  switch (source.type) {
+    case "env":
+      return envPointSource(source.envVar, source.path);
+    case "ns.toml":
+      return repoPromptPointSource(source.path);
+    case "conventional":
+      return conventionalPointSource(source.path);
+    case "default":
+      return { source: "default", path: source.path, manifestPath: source.manifestPath };
+    case "missing":
+      return missingPointSource();
+  }
+}
+function envPointSource(envVar, path) {
+  return { source: "env", envVar, path };
+}
+function repoPromptPointSource(path) {
+  return { source: "repo-prompt", path };
+}
+function pointSourceFromHookCommands(commands) {
+  return { source: "repo-hook", commands: [...commands] };
+}
+function conventionalPointSource(path) {
+  return { source: "conventional", path };
+}
+function missingPointSource() {
+  return { source: "missing" };
+}
+function diagnosticsForPoint(diagnostics, pointId) {
+  return diagnostics.filter(
+    (diagnostic5) => diagnostic5.path === pointId || diagnostic5.path === `points.${pointId}`
+  );
+}
+function renderPointsHuman(result) {
+  const lines = ["ns points:"];
+  for (const point of result.points) {
+    lines.push(
+      `- ${point.id} (${point.accepts}, ${point.semantics}) \u2014 ${renderSource(point.activeSource)}`
+    );
+  }
+  appendDiagnosticsSection(lines, result.diagnostics, { leadingBlank: true });
+  return `${lines.join("\n")}
+`;
+}
+function renderPointDetailHuman(result) {
+  const point = result.point;
+  const lines = [
+    `${point.id}`,
+    `accepts: ${point.accepts}`,
+    `semantics: ${point.semantics}`,
+    `active source: ${renderSource(point.activeSource)}`
+  ];
+  if (point.description !== void 0) lines.push(`description: ${point.description}`);
+  if (point.manifestPath !== void 0) lines.push(`definition: ${point.manifestPath}`);
+  if (point.defaultPath !== void 0) lines.push(`default: ${point.defaultPath}`);
+  if (point.installations.length > 0) {
+    lines.push(
+      "installations:",
+      ...point.installations.map((source) => `- ${renderSource(source)}`)
+    );
+  }
+  appendDiagnosticsSection(lines, result.diagnostics);
+  return `${lines.join("\n")}
+`;
+}
+function appendDiagnosticsSection(lines, diagnostics, options = {}) {
+  if (diagnostics.length === 0) return;
+  if (options.leadingBlank === true) lines.push("");
+  lines.push("diagnostics:", ...diagnostics.map(renderDiagnostic));
+}
+function renderSource(source) {
+  switch (source.source) {
+    case "env":
+      return `env ${source.envVar} -> ${source.path}`;
+    case "repo-prompt":
+      return `repo ns.toml -> ${source.path}`;
+    case "repo-hook":
+      return `repo ns.toml commands: ${source.commands.join(", ")}`;
+    case "conventional":
+      return `conventional ${source.path}`;
+    case "default":
+      return `default ${source.path}`;
+    case "missing":
+      return "missing";
+  }
+}
+function renderDiagnostic(diagnostic5) {
+  return `- ${diagnostic5.severity} ${diagnostic5.code}: ${diagnostic5.message}`;
+}
+
+// ../../kernel/src/extensions/zod-issue-path.ts
+function classifyZodIssuePath(issue, rules, fallback) {
+  if (issue === void 0) return fallback;
+  for (const rule of rules) {
+    if (zodIssuePathMatchesRule(issue.path, rule)) return rule.value;
+  }
+  return fallback;
+}
+function classifyFirstMatchingZodIssuePath(issues, rules, fallback) {
+  for (const issue of issues) {
+    const kind = classifyZodIssuePath(issue, rules, fallback);
+    if (kind !== fallback) return kind;
+  }
+  return fallback;
+}
+function zodIssuePathMatchesRule(path, rule) {
+  if (rule.match === "exact" && path.length !== rule.pattern.length) return false;
+  if (rule.match === "prefix" && path.length < rule.pattern.length) return false;
+  return rule.pattern.every((segment, index) => zodIssuePathSegmentMatches(segment, path[index]));
+}
+function zodIssuePathSegmentMatches(segment, value) {
+  if (typeof segment === "string") return value === segment;
+  return typeof value === "number";
+}
+
+// ../../kernel/src/extensions/command-registry.ts
+var builtInCommandDefinitions = {
+  "extension/point": {
+    name: "point",
+    segments: ["extension", "point"],
+    groupDescription: "Inspect ns extension metadata.",
+    command: extensionPointCommand
+  },
+  "extension/points": {
+    name: "points",
+    segments: ["extension", "points"],
+    groupDescription: "Inspect ns extension metadata.",
+    command: extensionPointsCommand
+  }
+};
+var nsCommandSchema = z12.object({
+  name: z12.string(),
+  summary: z12.string(),
+  description: z12.string(),
+  schema: z12.custom(isZodObjectSchema).optional(),
+  positionals: z12.custom(isRecord).optional(),
+  options: z12.custom(isRecord).optional(),
+  resultSchema: z12.custom(isZodSchema).optional(),
+  renderHuman: z12.custom((value) => typeof value === "function").optional(),
+  renderMarkdown: z12.custom((value) => typeof value === "function").optional(),
+  completionProvider: z12.custom((value) => typeof value === "function").optional(),
+  run: z12.custom((value) => typeof value === "function")
+});
+var nsExtensionSchema = z12.object({
+  commands: z12.array(nsCommandSchema).optional().default([])
+});
+var nsResultSchema = z12.discriminatedUnion("ok", [
+  z12.object({ ok: z12.literal(true), message: z12.string() }),
+  z12.object({ ok: z12.literal(false), exitCode: z12.number(), message: z12.string() })
+]);
+function commandSegments(path) {
+  if (path.segments !== void 0) return path.segments;
+  return path.group === void 0 ? [path.name] : [path.group, path.name];
+}
+function commandKey(path) {
+  return commandSegments(path).join("/");
+}
+function commandLeafName(path) {
+  return path.segments?.at(-1) ?? path.name;
+}
+function commandDisplayName(path) {
+  return commandSegments(path).join(" ");
+}
+function commandPathMatches(left, right) {
+  return commandKey(left) === commandKey(right);
+}
+function listBuiltInNsCommandCandidates() {
+  return Object.entries(builtInCommandDefinitions).map(([name, definition]) => ({
+    name: definition.name ?? name,
+    ...optionalEntries({
+      group: definition.group,
+      segments: definition.segments,
+      groupDescription: definition.groupDescription
+    }),
+    description: definition.command.summary,
+    fullDescription: definition.command.description,
+    source: { level: "built-in", label: `built-in command ${name}` },
+    command: definition.command
+  })).sort((left, right) => commandKey(left).localeCompare(commandKey(right)));
+}
+function listStaticNsCommandInfos() {
+  return listBuiltInNsCommandCandidates().map(toCommandCliInfo);
+}
+function toCommandCliInfo(candidate2) {
+  return {
+    ...optionalEntries({
+      group: candidate2.group,
+      segments: candidate2.segments,
+      groupDescription: candidate2.groupDescription
+    }),
+    name: candidate2.name,
+    description: candidate2.description,
+    fullDescription: candidate2.fullDescription
+  };
+}
+function commandInfoForLoadedCommand(command, sourceLevel, path) {
+  const definition = path.group === void 0 ? builtInCommandDefinitions[command.name] : void 0;
+  if (sourceLevel === "built-in" && definition !== void 0) {
+    return {
+      name: command.name,
+      description: definition.command.summary,
+      fullDescription: definition.command.description
+    };
+  }
+  return toCommandCliInfo({
+    ...path,
+    name: command.name,
+    description: command.summary,
+    fullDescription: command.description
+  });
+}
+function validateNsExtensionContribution(contribution, expectedPath, sourceLabel) {
+  const expectedName = typeof expectedPath === "string" ? expectedPath : commandLeafName(expectedPath);
+  const parsed = nsExtensionSchema.safeParse(contribution);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      message: `Invalid ns extension contribution ${sourceLabel}: ${formatNsExtensionIssue(parsed.error.issues[0])}`
+    };
+  }
+  const command = findCommandEntry(parsed.data, expectedName);
+  if (command === void 0) {
+    return {
+      ok: false,
+      message: `Invalid ns extension contribution ${sourceLabel}: expected a command entry named "${expectedName}" in commands[].`
+    };
+  }
+  return { ok: true, command };
+}
+async function executeNsCommand(ctx, command, request) {
+  const parsedRequest = (command.schema ?? z12.object({})).safeParse(request);
+  if (!parsedRequest.success) {
+    return failed(
+      `Invalid request for command ${command.name}: ${parsedRequest.error.issues[0]?.message ?? "request did not match command schema"}`,
+      2
     );
   }
   try {
@@ -5831,13 +7436,13 @@ function formatNsCommandEntryIssueKind(kind) {
   return "command entry must include name, summary, description, and run";
 }
 function isZodObjectSchema(value) {
-  if (value instanceof z10.ZodObject) return true;
+  if (value instanceof z12.ZodObject) return true;
   if (!isRecord(value)) return false;
   const candidate2 = value;
   return typeof candidate2.safeParse === "function" && candidate2._zod?.def?.type === "object";
 }
 function isZodSchema(value) {
-  if (value instanceof z10.ZodType) return true;
+  if (value instanceof z12.ZodType) return true;
   if (!isRecord(value)) return false;
   const candidate2 = value;
   return typeof candidate2.safeParse === "function" && candidate2._zod?.def !== void 0;
@@ -5862,8 +7467,8 @@ function hasInvalidFailureExitCode(issues) {
 }
 
 // ../../kernel/src/extensions/discovery.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync, statSync } from "node:fs";
-import { basename as basename3, extname, join as join2, relative as relative3, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { basename as basename3, extname, join as join4, relative as relative3, resolve as resolve4 } from "node:path";
 var requiredManifestCommandStringFields = [
   {
     field: "description",
@@ -5880,56 +7485,14 @@ var manifestStructureIssueRules = [
   { pattern: ["ns", "commands"], match: "prefix", value: "commands-not-array" }
 ];
 function discoverExtensionsInRoot(rootDir) {
-  if (!existsSync3(rootDir)) return { commands: [], diagnostics: [] };
-  let rootStat;
-  try {
-    rootStat = statSync(rootDir);
-  } catch (error) {
-    return {
-      commands: [],
-      diagnostics: [
-        diagnostic(
-          "extension_root_stat_failed",
-          `Could not inspect extension root ${rootDir}.
-${formatUnknownError(error)}`,
-          { path: rootDir }
-        )
-      ]
-    };
-  }
-  if (!rootStat.isDirectory()) {
-    return {
-      commands: [],
-      diagnostics: [
-        diagnostic(
-          "extension_root_not_directory",
-          `Extension root must be a directory: ${rootDir}.`,
-          { path: rootDir }
-        )
-      ]
-    };
-  }
-  let entries;
-  try {
-    entries = readdirSync(rootDir, { withFileTypes: true });
-  } catch (error) {
-    return {
-      commands: [],
-      diagnostics: [
-        diagnostic(
-          "extension_root_read_failed",
-          `Could not read extension root ${rootDir}.
-${formatUnknownError(error)}`,
-          { path: rootDir }
-        )
-      ]
-    };
+  const rootScan = scanExtensionRoot(rootDir);
+  if (rootScan.diagnostics.length > 0) {
+    return { commands: [], diagnostics: rootScan.diagnostics };
   }
   const commands = [];
   const diagnostics = [];
-  for (const entry2 of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-    const entryPath = join2(rootDir, entry2.name);
-    if (entry2.isFile()) {
+  for (const entry2 of rootScan.entries) {
+    if (entry2.type === "file") {
       if (isLoadableExtensionFile(entry2.name)) {
         pushDirectEntryCommand(
           commands,
@@ -5937,38 +7500,35 @@ ${formatUnknownError(error)}`,
           commandForDirectEntry({
             rootDir,
             name: basename3(entry2.name, extname(entry2.name)),
-            entryPath
+            entryPath: entry2.path
           })
         );
       }
       continue;
     }
-    if (!entry2.isDirectory()) continue;
-    const packageJsonPath = join2(entryPath, "package.json");
-    if (existsSync3(packageJsonPath)) {
-      const packageResult = discoverPackageCommands(rootDir, entryPath, packageJsonPath);
+    if (entry2.packageJsonPath !== void 0) {
+      const packageResult = discoverPackageCommands(rootDir, entry2.path, entry2.packageJsonPath);
       commands.push(...packageResult.commands);
       diagnostics.push(...packageResult.diagnostics);
       continue;
     }
-    const indexPath = firstExistingDirectoryIndex(entryPath);
-    if (indexPath !== void 0) {
+    if (entry2.indexPath !== void 0) {
       pushDirectEntryCommand(
         commands,
         diagnostics,
         commandForDirectEntry({
           rootDir,
           name: entry2.name,
-          entryPath: indexPath
+          entryPath: entry2.indexPath
         })
       );
       continue;
     }
     diagnostics.push(
-      diagnostic(
+      diagnostic3(
         "extension_directory_missing_entry",
-        `Extension directory must contain package.json, index.ts, or index.js: ${entryPath}.`,
-        { path: entryPath, commandName: entry2.name }
+        `Extension directory must contain package.json, index.ts, or index.js: ${entry2.path}.`,
+        { path: entry2.path, commandName: entry2.name }
       )
     );
   }
@@ -5980,8 +7540,8 @@ ${formatUnknownError(error)}`,
   };
 }
 function discoverNsPackageCommands(rootDir, packageDir) {
-  const packageJsonPath = join2(packageDir, "package.json");
-  if (!existsSync3(packageJsonPath)) return { commands: [], diagnostics: [] };
+  const packageJsonPath = join4(packageDir, "package.json");
+  if (!existsSync5(packageJsonPath)) return { commands: [], diagnostics: [] };
   const resolution = resolvePackageManifest(packageJsonPath, () => ({
     commands: [],
     diagnostics: []
@@ -5993,11 +7553,11 @@ function discoverNsPackageCommands(rootDir, packageDir) {
 function readPackageManifest(packageJsonPath) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+    parsed = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
   } catch (error) {
     return {
       outcome: "parse-failed",
-      diagnostic: diagnostic(
+      diagnostic: diagnostic3(
         "extension_manifest_parse_failed",
         `Could not parse extension manifest ${packageJsonPath}.
 ${formatUnknownError(error)}`,
@@ -6027,8 +7587,8 @@ function resolvePackageManifest(packageJsonPath, onSchemaFailed) {
   }
   return { outcome: "ok", manifest: parseResult.manifest };
 }
-function manifestReadFailureResult(diagnostic3) {
-  return { commands: [], diagnostics: [diagnostic3] };
+function manifestReadFailureResult(diagnostic5) {
+  return { commands: [], diagnostics: [diagnostic5] };
 }
 function discoverPackageCommands(rootDir, packageDir, packageJsonPath, parsedManifest) {
   let manifest;
@@ -6048,8 +7608,8 @@ function discoverPackageCommands(rootDir, packageDir, packageJsonPath, parsedMan
       diagnostics: [missingNsDiagnostic(packageJsonPath)]
     };
   }
-  const packageGroup = readNonEmptyString(manifest.ns.group);
-  const packageGroupDescription = readNonEmptyString(manifest.ns.description) ?? readNonEmptyString(manifest.description);
+  const packageGroup = readNonEmptyString2(manifest.ns.group);
+  const packageGroupDescription = readNonEmptyString2(manifest.ns.description) ?? readNonEmptyString2(manifest.description);
   const packageGroupDiagnostic = groupDiagnostic({
     group: manifest.ns.group,
     packageJsonPath,
@@ -6088,33 +7648,26 @@ function manifestStructureDiagnostic(issues, packageJsonPath) {
   const kind = classifyFirstMatchingZodIssuePath(issues, manifestStructureIssueRules, "other");
   if (kind === "missing-ns") return missingNsDiagnostic(packageJsonPath);
   if (kind === "commands-not-array") return commandsNotArrayDiagnostic(packageJsonPath);
-  return diagnostic(
+  return diagnostic3(
     "extension_manifest_invalid",
     `Extension manifest contains invalid ns metadata: ${packageJsonPath}.`,
     { path: packageJsonPath }
   );
 }
 function missingNsDiagnostic(packageJsonPath) {
-  return diagnostic(
+  return diagnostic3(
     "extension_manifest_missing_ns",
     `Extension manifest must contain an ns object: ${packageJsonPath}.`,
     { path: packageJsonPath }
   );
 }
 function commandsNotArrayDiagnostic(packageJsonPath) {
-  return diagnostic(
+  return diagnostic3(
     "extension_manifest_commands_not_array",
     `Extension manifest ns.commands must be an array: ${packageJsonPath}.`,
     { path: packageJsonPath }
   );
 }
-function firstExistingDirectoryIndex(entryPath) {
-  for (const indexFileName of ["index.ts", "index.js"]) {
-    const indexPath = join2(entryPath, indexFileName);
-    if (existsSync3(indexPath)) return indexPath;
-  }
-  return void 0;
-}
 function pushDirectEntryCommand(commands, diagnostics, command) {
   if (command.ok) commands.push(command.command);
   else diagnostics.push(command.diagnostic);
@@ -6123,7 +7676,7 @@ function commandForDirectEntry(options) {
   if (!NS_COMMAND_NAME_PATTERN.test(options.name)) {
     return {
       ok: false,
-      diagnostic: diagnostic(
+      diagnostic: diagnostic3(
         "extension_command_name_invalid",
         `ns command entry name inferred from ${options.entryPath} must match ${NS_COMMAND_NAME_RULE}.`,
         { path: options.entryPath, commandName: options.name }
@@ -6138,7 +7691,7 @@ function commandForManifestEntry(options) {
     return {
       ok: false,
       diagnostics: [
-        diagnostic(
+        diagnostic3(
           "extension_manifest_command_invalid",
           `Extension manifest commands must be objects with supported known fields: ${options.packageJsonPath}.`,
           { path: options.packageJsonPath }
@@ -6156,7 +7709,7 @@ function commandForManifestEntry(options) {
   const commandName = parsedEntry.commandName;
   if (parsedEntry.entry.name !== void 0 && !NS_COMMAND_NAME_PATTERN.test(parsedEntry.entry.name)) {
     diagnostics.push(
-      diagnostic(
+      diagnostic3(
         "extension_manifest_command_name_invalid",
         `Extension manifest command name must match ${NS_COMMAND_NAME_RULE}: ${parsedEntry.entry.name}.`,
         diagnosticLocation(options.packageJsonPath, commandName)
@@ -6202,7 +7755,7 @@ function validateManifestEntryPath(options) {
     return {
       ok: false,
       diagnostics: [
-        diagnostic(
+        diagnostic3(
           "extension_manifest_entry_not_relative",
           `Extension manifest command entry must be a relative POSIX-style path inside the package: ${options.rawEntryPath}.`,
           diagnosticLocation(options.packageJsonPath, options.commandName)
@@ -6210,12 +7763,12 @@ function validateManifestEntryPath(options) {
       ]
     };
   }
-  const resolvedEntry = resolve3(options.packageDir, options.rawEntryPath);
+  const resolvedEntry = resolve4(options.packageDir, options.rawEntryPath);
   if (!isPathInside(options.packageDir, resolvedEntry)) {
     return {
       ok: false,
       diagnostics: [
-        diagnostic(
+        diagnostic3(
           "extension_manifest_entry_escapes",
           `Extension manifest command entry must not escape its package directory: ${options.rawEntryPath}.`,
           diagnosticLocation(options.packageJsonPath, options.commandName)
@@ -6227,7 +7780,7 @@ function validateManifestEntryPath(options) {
     return {
       ok: false,
       diagnostics: [
-        diagnostic(
+        diagnostic3(
           "extension_manifest_entry_unsupported",
           `Extension manifest command entry must be a .ts or .js file, excluding .d.ts: ${options.rawEntryPath}.`,
           diagnosticLocation(options.packageJsonPath, options.commandName)
@@ -6237,12 +7790,12 @@ function validateManifestEntryPath(options) {
   }
   let entryStat;
   try {
-    entryStat = statSync(resolvedEntry);
+    entryStat = statSync2(resolvedEntry);
   } catch {
     return {
       ok: false,
       diagnostics: [
-        diagnostic(
+        diagnostic3(
           "extension_manifest_entry_missing",
           `Extension manifest command entry does not exist: ${options.rawEntryPath}.`,
           diagnosticLocation(options.packageJsonPath, options.commandName)
@@ -6254,7 +7807,7 @@ function validateManifestEntryPath(options) {
     return {
       ok: false,
       diagnostics: [
-        diagnostic(
+        diagnostic3(
           "extension_manifest_entry_not_file",
           `Extension manifest command entry must be a file: ${options.rawEntryPath}.`,
           diagnosticLocation(options.packageJsonPath, options.commandName)
@@ -6270,10 +7823,10 @@ function commandNameFromManifestPath(segments) {
 }
 function parseManifestCommandEntry(options) {
   const rawPath = parseManifestPath(options.entry.path);
-  const explicitName = readNonEmptyString(options.entry.name);
+  const explicitName = readNonEmptyString2(options.entry.name);
   const commandName = explicitName ?? commandNameFromManifestPath(rawPath.value);
   const rawEntryGroup = options.entry.group;
-  const entryGroup = rawEntryGroup === void 0 ? options.packageGroup : readNonEmptyString(rawEntryGroup);
+  const entryGroup = rawEntryGroup === void 0 ? options.packageGroup : readNonEmptyString2(rawEntryGroup);
   const segments = rawPath.value === void 0 ? void 0 : [...entryGroup === void 0 ? [] : [entryGroup], ...rawPath.value];
   const packageGroupDescription = options.packageGroupDescription;
   const shouldApplyPackageGroupDescription = packageGroupDescription !== void 0 && (entryGroup !== void 0 || (segments?.length ?? 0) > 1);
@@ -6305,7 +7858,7 @@ function parseManifestCommandEntry(options) {
     });
   }
   for (const { field, code } of requiredManifestCommandStringFields) {
-    const value = readNonEmptyString(options.entry[field]);
+    const value = readNonEmptyString2(options.entry[field]);
     if (value !== void 0) {
       fields[field] = value;
       continue;
@@ -6318,7 +7871,7 @@ function parseManifestCommandEntry(options) {
       commandName
     });
   }
-  const fullDescription = readNonEmptyString(options.entry.fullDescription);
+  const fullDescription = readNonEmptyString2(options.entry.fullDescription);
   if (fullDescription !== void 0) {
     fields.fullDescription = fullDescription;
   } else if (options.entry.fullDescription === void 0) {
@@ -6336,7 +7889,7 @@ function parseManifestCommandEntry(options) {
 }
 function pushManifestStringDiagnostic(options) {
   options.diagnostics.push(
-    diagnostic(
+    diagnostic3(
       options.code,
       `Extension manifest command ${options.field} must be a non-empty string: ${options.packageJsonPath}.`,
       diagnosticLocation(options.packageJsonPath, options.commandName)
@@ -6345,9 +7898,9 @@ function pushManifestStringDiagnostic(options) {
 }
 function groupDiagnostic(options) {
   if (options.group === void 0) return void 0;
-  const group = readNonEmptyString(options.group);
+  const group = readNonEmptyString2(options.group);
   if (group !== void 0 && NS_COMMAND_NAME_PATTERN.test(group)) return void 0;
-  return diagnostic(
+  return diagnostic3(
     "extension_manifest_command_group_invalid",
     `Extension manifest command group must match ${NS_COMMAND_NAME_RULE}.`,
     diagnosticLocation(options.packageJsonPath, options.commandName)
@@ -6359,7 +7912,7 @@ function parseManifestPath(value) {
     return {
       value: void 0,
       diagnostics: [
-        diagnostic(
+        diagnostic3(
           "extension_manifest_command_path_invalid",
           `Extension manifest command path must be a non-empty array of segments matching ${NS_COMMAND_NAME_RULE}.`
         )
@@ -6371,7 +7924,7 @@ function parseManifestPath(value) {
     return {
       value: void 0,
       diagnostics: [
-        diagnostic(
+        diagnostic3(
           "extension_manifest_command_path_invalid",
           `Extension manifest command path segments must match ${NS_COMMAND_NAME_RULE}.`
         )
@@ -6380,7 +7933,7 @@ function parseManifestPath(value) {
   }
   return { value: segments, diagnostics: [] };
 }
-function readNonEmptyString(value) {
+function readNonEmptyString2(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
 function buildCommand(options) {
@@ -6398,7 +7951,7 @@ function buildCommand(options) {
 function moduleReferenceForEntryPath(entryPath) {
   let source;
   try {
-    source = readFileSync2(entryPath, "utf8");
+    source = readFileSync3(entryPath, "utf8");
   } catch {
     return {};
   }
@@ -6418,7 +7971,7 @@ function isLoadableExtensionFile(name) {
   return extension === ".ts" || extension === ".js";
 }
 function relativeDisplayPath(rootDir, entryPath) {
-  return join2(basename3(rootDir), relative3(rootDir, entryPath));
+  return join4(basename3(rootDir), relative3(rootDir, entryPath));
 }
 function commandSortKey(command) {
   return command.displayPath;
@@ -6429,13 +7982,13 @@ function diagnosticLocation(path, commandName) {
     ...optionalEntry("commandName", commandName)
   };
 }
-function diagnostic(code, message, options = {}) {
-  return {
-    severity: "error",
+function diagnostic3(code, message, options = {}) {
+  return makeKernelDiagnostic({
     code,
     message,
-    ...optionalEntries({ path: options.path, commandName: options.commandName })
-  };
+    ...optionalEntry("path", options.path),
+    extra: optionalEntry("commandName", options.commandName)
+  });
 }
 
 // ../../kernel/src/extensions/module-reference.ts
@@ -6518,7 +8071,7 @@ async function loadNsExtensionContribution(reference) {
   } catch (error) {
     return {
       ok: false,
-      diagnostic: diagnostic2(
+      diagnostic: diagnostic4(
         "ns_extension_contribution_import_failed",
         `Failed to load ns extension contribution ${displayPath}.
 ${formatUnknownError(error)}`,
@@ -6534,12 +8087,12 @@ async function loadDefaultExport(reference) {
     loaded: async (loadedReference) => await loadedReference.load()
   });
 }
-function diagnostic2(code, message, path) {
+function diagnostic4(code, message, path) {
   return { severity: "error", code, message, path };
 }
 
 // ../../infra/foundation/src/config/xdg-path.ts
-import { isAbsolute as isAbsolute2, join as join3 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join5 } from "node:path";
 
 // ../../infra/foundation/src/primitives/result.ts
 function resultOk(value) {
@@ -6580,17 +8133,17 @@ function resolveXdgHome(kind, env) {
       message: `HOME environment variable must be absolute to resolve default ${XDG_ENV_BY_KIND[kind]}: ${home}`
     });
   }
-  return resultOk(join3(home, ...XDG_DEFAULT_SEGMENTS_BY_KIND[kind]));
+  return resultOk(join5(home, ...XDG_DEFAULT_SEGMENTS_BY_KIND[kind]));
 }
 function resolveNsXdgPath(options) {
   if (options.overrideEnv !== void 0) {
     const override = resolvePathOverride({ env: options.env, name: options.overrideEnv });
     if (!override.ok) return override;
-    if (override.value !== void 0) return resultOk(join3(override.value, ...options.segments ?? []));
+    if (override.value !== void 0) return resultOk(join5(override.value, ...options.segments ?? []));
   }
   const home = resolveXdgHome(options.kind, options.env);
   if (!home.ok) return home;
-  return resultOk(join3(home.value, "ns", ...options.segments ?? []));
+  return resultOk(join5(home.value, "ns", ...options.segments ?? []));
 }
 function requireXdgPath(result) {
   if (result.ok) return result.value;
@@ -6624,7 +8177,7 @@ function expandHomeRelativePath(path, env) {
       message: `HOME environment variable must be absolute to expand ~/ in storage override: ${home}`
     });
   }
-  return resultOk(join3(home, path.slice(2)));
+  return resultOk(join5(home, path.slice(2)));
 }
 
 // ../../kernel/src/extensions/registry.ts
@@ -6659,12 +8212,12 @@ async function loadNsCommandCatalog(options) {
   }
   const projectCandidates = loadRootCandidates({
     level: "project",
-    rootDir: join4(options.cwd, ".ns", "extensions")
+    rootDir: join6(options.cwd, ".ns", "extensions")
   });
   diagnostics.push(...projectCandidates.diagnostics);
   orderedSources.push({
     level: "project",
-    label: join4(options.cwd, ".ns", "extensions"),
+    label: join6(options.cwd, ".ns", "extensions"),
     candidates: projectCandidates.candidates
   });
   const merged = /* @__PURE__ */ new Map();
@@ -6767,30 +8320,30 @@ function commandInfosForSelectedCommand(commandInfos, loaded) {
 }
 function classifyExtensionDiagnosticsForInvocation(options) {
   const errorDiagnostics = options.diagnostics.filter(
-    (diagnostic3) => diagnostic3.severity === "error"
+    (diagnostic5) => diagnostic5.severity === "error"
   );
   if (options.requestedCommandName === void 0) {
     return { fatal: [], warnings: errorDiagnostics };
   }
   const fatal = [];
   const warnings = [];
-  for (const diagnostic3 of errorDiagnostics) {
-    if (diagnostic3.commandName !== options.requestedCommandName) {
-      warnings.push(diagnostic3);
+  for (const diagnostic5 of errorDiagnostics) {
+    if (diagnostic5.commandName !== options.requestedCommandName) {
+      warnings.push(diagnostic5);
       continue;
     }
-    if (isFatalForSelectedCandidate(diagnostic3, options.selectedCandidate)) {
-      fatal.push(diagnostic3);
+    if (isFatalForSelectedCandidate(diagnostic5, options.selectedCandidate)) {
+      fatal.push(diagnostic5);
       continue;
     }
-    warnings.push(diagnostic3);
+    warnings.push(diagnostic5);
   }
   return { fatal, warnings };
 }
 function formatExtensionErrorDiagnostics(diagnostics) {
   return formatExtensionDiagnosticMessages(
     diagnostics.filter(
-      (diagnostic3) => diagnostic3.severity === "error"
+      (diagnostic5) => diagnostic5.severity === "error"
     )
   );
 }
@@ -6799,18 +8352,18 @@ function formatExtensionWarningDiagnostics(diagnostics) {
 }
 function formatExtensionDiagnosticMessages(diagnostics, options = {}) {
   const prefix = options.prefix ?? "";
-  return diagnostics.map((diagnostic3) => `${prefix}${diagnostic3.message}`).join("\n");
+  return diagnostics.map((diagnostic5) => `${prefix}${diagnostic5.message}`).join("\n");
 }
-function isFatalForSelectedCandidate(diagnostic3, selectedCandidate) {
+function isFatalForSelectedCandidate(diagnostic5, selectedCandidate) {
   if (selectedCandidate === void 0) return true;
-  if (diagnostic3.sourceLevel === void 0) return true;
-  return sourceLevelRank(diagnostic3.sourceLevel) >= sourceLevelRank(selectedCandidate.source.level);
+  if (diagnostic5.sourceLevel === void 0) return true;
+  return sourceLevelRank(diagnostic5.sourceLevel) >= sourceLevelRank(selectedCandidate.source.level);
 }
 function loadRootCandidates(options) {
   const discovered = discoverExtensionsInRoot(options.rootDir);
   return {
     diagnostics: discovered.diagnostics.map(
-      (diagnostic3) => fromDiscoveryDiagnostic(diagnostic3, options.level)
+      (diagnostic5) => fromDiscoveryDiagnostic(diagnostic5, options.level)
     ),
     candidates: discovered.commands.map(
       (command) => discoveredCommandCandidateForLevel(command, options.level)
@@ -6839,7 +8392,7 @@ function loadSourceDevPreinstalledCandidates(cwd, catalogKeys) {
     const discovered = discoverNsPackageCommands(packagesRoot, packageDir);
     diagnostics.push(
       ...discovered.diagnostics.map(
-        (diagnostic3) => fromDiscoveryDiagnostic(diagnostic3, "preinstalled")
+        (diagnostic5) => fromDiscoveryDiagnostic(diagnostic5, "preinstalled")
       )
     );
     candidates.push(
@@ -6849,10 +8402,10 @@ function loadSourceDevPreinstalledCandidates(cwd, catalogKeys) {
   return { diagnostics, candidates };
 }
 function sourceDevWorkspacePackagesRoot(cwd) {
-  const packagesRoot = resolve4(dirname3(fileURLToPath2(import.meta.url)), "..", "..", "..");
-  const checkoutRoot = resolve4(packagesRoot, "..", "..");
-  const kernelSourceDir = join4(packagesRoot, "kernel", "src");
-  if (!existsSync4(kernelSourceDir)) return void 0;
+  const packagesRoot = resolve5(dirname4(fileURLToPath2(import.meta.url)), "..", "..", "..");
+  const checkoutRoot = resolve5(packagesRoot, "..", "..");
+  const kernelSourceDir = join6(packagesRoot, "kernel", "src");
+  if (!existsSync6(kernelSourceDir)) return void 0;
   return isPathInside(checkoutRoot, cwd) ? packagesRoot : void 0;
 }
 function discoverWorkspacePackageDirs(packagesRoot) {
@@ -6862,8 +8415,8 @@ function discoverWorkspacePackageDirs(packagesRoot) {
 }
 function collectPackageDirs(options) {
   if (options.depth > 3) return;
-  const packageJsonPath = join4(options.current, "package.json");
-  if (options.current !== options.root && existsSync4(packageJsonPath)) {
+  const packageJsonPath = join6(options.current, "package.json");
+  if (options.current !== options.root && existsSync6(packageJsonPath)) {
     options.packageDirs.push(options.current);
     return;
   }
@@ -6877,7 +8430,7 @@ function collectPackageDirs(options) {
     if (!entry2.isDirectory() || entry2.name === "node_modules") continue;
     collectPackageDirs({
       root: options.root,
-      current: join4(options.current, entry2.name),
+      current: join6(options.current, entry2.name),
       depth: options.depth + 1,
       packageDirs: options.packageDirs
     });
@@ -7063,11 +8616,11 @@ function sourceLevelRank(level) {
 function isBuiltInCandidate(candidate2) {
   return candidate2.source.level === "built-in";
 }
-function fromDiscoveryDiagnostic(diagnostic3, sourceLevel) {
-  return { ...diagnostic3, sourceLevel };
+function fromDiscoveryDiagnostic(diagnostic5, sourceLevel) {
+  return { ...diagnostic5, sourceLevel };
 }
-function fromLoadDiagnostic(diagnostic3, sourceLevel, commandName) {
-  return { ...diagnostic3, sourceLevel, commandName };
+function fromLoadDiagnostic(diagnostic5, sourceLevel, commandName) {
+  return { ...diagnostic5, sourceLevel, commandName };
 }
 function candidateDiagnosticPath(candidate2) {
   if (isBuiltInCandidate(candidate2)) return formatSource(candidate2.source);
@@ -7077,6 +8630,25 @@ function formatSource(source) {
   return source.path === void 0 ? source.label : `${source.label} (${source.path})`;
 }
 
+// ../../kernel/src/extensions/repo-local-catalog.ts
+function repoLocalNsExtensionToPreinstalledCatalog(descriptor) {
+  return descriptor.commands.map((commandDescriptor) => ({
+    group: descriptor.group,
+    groupDescription: descriptor.description,
+    ...repoLocalNsCommandDescriptorToPreinstalledCatalogEntry(commandDescriptor)
+  }));
+}
+function repoLocalNsCommandDescriptorToPreinstalledCatalogEntry(commandDescriptor) {
+  return {
+    name: commandDescriptor.manifestName ?? commandDescriptor.command.name,
+    description: commandDescriptor.command.summary,
+    fullDescription: commandDescriptor.command.description,
+    ...optionalEntry("path", commandDescriptor.manifestPath),
+    displayPath: commandDescriptor.packageExport,
+    load: () => defineExtension({ commands: [commandDescriptor.command] })
+  };
+}
+
 // ../../kernel/src/cli/index.ts
 var entry = defineCli({
   metaUrl: new URL("../cli.ts", import.meta.url).href,
@@ -7088,7 +8660,7 @@ var entry = defineCli({
     const resolvedStderr = deps.stderr ?? injectedContext?.stderr ?? stderr;
     const resolvedCwd = deps.cwd ?? injectedContext?.cwd ?? cwd;
     const resolvedEnv = deps.env ?? injectedContext?.env ?? env;
-    const homeDir = deps.homeDir ?? resolvedEnv.HOME;
+    const homeDir = resolveHomeDir(deps.homeDir, resolvedEnv) ?? injectedContext?.homeDir;
     const commandCatalog = await (deps.extensionRegistry?.loadCommandCatalog ?? loadNsCommandCatalog)({
       cwd: resolvedCwd,
       env: resolvedEnv,
@@ -7101,12 +8673,14 @@ var entry = defineCli({
         commandCatalog,
         cwd: resolvedCwd,
         env: resolvedEnv,
+        ...optionalEntry("homeDir", homeDir),
         stdout: resolvedStdout,
         stderr: resolvedStderr,
         ...optionalEntries({
           loadSelectedCommand: deps.extensionRegistry?.loadSelectedCommand,
           injectedContext,
           onOutput: deps.onOutput,
+          onProgress: deps.onProgress,
           confirm: deps.confirm,
           caps: io.caps
         })
@@ -7149,11 +8723,13 @@ var entry = defineCli({
       args,
       cwd: resolvedCwd,
       env: resolvedEnv,
+      ...optionalEntry("homeDir", homeDir),
       stdout: resolvedStdout,
       stderr: resolvedStderr,
       ...optionalEntries({
         injectedContext,
         onOutput: deps.onOutput,
+        onProgress: deps.onProgress,
         confirm: deps.confirm,
         caps: io.caps
       })
@@ -7169,7 +8745,7 @@ var entry = defineCli({
     for (const commandInfo of buildState.commandInfos) {
       const parent = groupForCommand(root, groups, commandInfo);
       const selectedCommand = buildState.selectedCommandPath !== void 0 && commandPathMatches(buildState.selectedCommandPath, commandInfo) ? buildState.selectedCommand : void 0;
-      const schema = selectedCommand?.schema ?? z11.object({});
+      const schema = selectedCommand?.schema ?? z13.object({});
       const commandOptions2 = {
         name: cliLeafCommandName(commandInfo),
         description: commandInfo.fullDescription,
@@ -7248,11 +8824,13 @@ async function handleCompletionResolverInvocation(options) {
     args: options.args,
     cwd: options.cwd,
     env: options.env,
+    ...optionalEntry("homeDir", options.homeDir),
     stdout: options.stdout,
     stderr: options.stderr,
     ...optionalEntries({
       injectedContext: options.injectedContext,
       onOutput: options.onOutput,
+      onProgress: options.onProgress,
       confirm: options.confirm,
       caps: options.caps
     })
@@ -7294,7 +8872,11 @@ async function resolveSelectedNsCommand(options) {
   };
 }
 async function buildNsCliContext(options) {
-  const baseContext = options.injectedContext ?? createRealNsCommandContext({ cwd: options.cwd, env: options.env });
+  const baseContext = options.injectedContext ?? createRealNsCommandContext({
+    cwd: options.cwd,
+    env: options.env,
+    ...optionalEntry("homeDir", options.homeDir)
+  });
   const onOutput = options.onOutput ?? baseContext.onOutput;
   const confirm = options.confirm ?? baseContext.confirm;
   const stdin = baseContext.stdin ?? readStdin;
@@ -7308,9 +8890,10 @@ async function buildNsCliContext(options) {
   const context = {
     cwd: options.cwd,
     env: options.env,
+    ...optionalEntry("homeDir", options.homeDir),
     textGenerator: baseContext.textGenerator,
     commandIo,
-    progress: noopNsProgress,
+    progress: options.onProgress === void 0 ? noopNsProgress : { isLive: true, phase: options.onProgress },
     renderCapabilities: renderCapabilities2,
     outputFormat: clinkrFormatFromArgs(options.args),
     exec: baseContext.exec.bind(baseContext),
@@ -7373,7 +8956,7 @@ function buildNsCompletionGroup() {
     completion.command({
       name: shell,
       description: `Print ${shell} completion setup for ns.`,
-      schema: z11.object({}),
+      schema: z13.object({}),
       resultSchema: nsCompletionScriptResultSchema,
       handler: async () => ok(buildNsCompletionScript(shell)),
       renderHuman: renderNsCompletionScriptResult
@@ -7388,7 +8971,7 @@ function buildNsCompletionGroup() {
     rawCommand({
       name: "resolve",
       description: "Resolve newline-delimited shell completion candidates.",
-      schema: z11.object({ words: z11.array(z11.string()).default([]) }),
+      schema: z13.object({ words: z13.array(z13.string()).default([]) }),
       positionals: { words: { position: 0 } },
       run: async () => 0
     })
@@ -7486,9 +9069,52 @@ function writeNsResultOutput(result, deps) {
   }
   deps.stderr(output);
 }
+var VERSION = entry.version;
 await entry.runIfMain({ isImportMetaMain: import.meta.main });
 export {
+  VERSION,
   buildCli,
   listNsCommands,
+  repoLocalNsCommandDescriptorToPreinstalledCatalogEntry,
+  repoLocalNsExtensionToPreinstalledCatalog,
   runCli
 };
+/*! Bundled license information:
+
+smol-toml/dist/error.js:
+smol-toml/dist/util.js:
+smol-toml/dist/date.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/