@mnemonik/cli 7.104.2 → 7.104.5

package/dist/status.js

@@ -60,8 +60,8 @@ var require_ignore = __commonJS({
       TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
     }
     var KEY_IGNORE = TMP_KEY_IGNORE;
-    var define = (object, key, value) => {
-      Object.defineProperty(object, key, { value });
+    var define = (object2, key, value) => {
+      Object.defineProperty(object2, key, { value });
       return value;
     };
     var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
@@ -566,8 +566,8 @@ async function pendingProjectSetup(root) {
   for (const host of ["credit", "cursor", "grok"]) {
     const directory = join2(tmpdir(), `mnemonik-${host}-${uid}`);
     try {
-      const stat = await lstat(directory);
-      if (stat.isSymbolicLink() || !stat.isDirectory())
+      const stat2 = await lstat(directory);
+      if (stat2.isSymbolicLink() || !stat2.isDirectory())
         continue;
       for (const name2 of await readdir(directory)) {
         if (!/^[a-f0-9]{64}$/.test(name2))
@@ -608,6 +608,8 @@ var init_hookRuntime = __esm({
 });
 
 // packages/cli/src/status.ts
+import { genericReadinessMessage, messageFor } from "./humanReason.js";
+import { CODEX_TRUST_MESSAGE } from "./humanReason.js";
 import { cliCredentialStatus } from "./auth/credentials.js";
 import { readOwnership } from "./install/ownership.js";
 import { scannerReceipt } from "./scanner/control.js";
@@ -4904,9 +4906,657 @@ function stateDirectory(platform = process.platform, env = process.env, home = h
 var MAX_ORIGINAL_BYTES = 64 * 1024;
 
 // packages/cli/src/status.ts
-init_hookRuntime();
-import { readFile } from "node:fs/promises";
+import { readFile, stat } from "node:fs/promises";
 import { join as join4 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// 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/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 i2 = line - 1; i2 <= line + 1; i2++) {
+    let l = lines[i2 - 1];
+    if (!l)
+      continue;
+    codeblock += i2.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i2 === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+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;
+  }
+};
+
+// node_modules/smol-toml/dist/util.js
+function indexOfNewline(str, start2 = 0) {
+  let idx = str.indexOf("\n", start2);
+  if (str.charCodeAt(idx - 1) === 13)
+    idx--;
+  return idx;
+}
+function skipComment(ctx) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
+    }
+    if (c < 32 && c !== 9 || c === 127) {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    }
+  }
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (1) {
+    while ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
+  }
+}
+function skipUntil(ctx, sep, end) {
+  let ptr = ctx.p;
+  if (!end) {
+    ptr = indexOfNewline(ctx.s, ptr);
+    ctx.p = ptr < 0 ? ctx.s.length : ptr;
+    return;
+  }
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 35) {
+      skipComment(ctx);
+    } else if (c === end || c === sep) {
+      return;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: ctx.s,
+    ptr
+  });
+}
+
+// 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_]/;
+function parseString(ctx) {
+  let start2 = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
+  let first = c;
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
+  if (isMultiline) {
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
+  }
+  let parsed = "";
+  let sliceStart = ctx.p;
+  let state = 0;
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    c = ctx.s.charCodeAt(ctx.p);
+    if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
+      state = state && 3;
+    } else if (c < 32 && c !== 9 || c === 127) {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    } else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
+      if (isMultiline) {
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+      }
+      if (!state)
+        parsed += ctx.s.slice(sliceStart, ctx.p);
+      ctx.p += isMultiline ? 3 : 1;
+      return parsed;
+    } else if (!state) {
+      if (!isLiteral && c === 92) {
+        parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
+        state = 1;
+      }
+    } else if (state === 1) {
+      if (c === 120 || c === 117 || c === 85) {
+        let value = 0;
+        let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+        for (let j = 0; j < len; j++, ctx.p++) {
+          let hex = ctx.s.charCodeAt(ctx.p + 1);
+          let digit = (
+            /* 0-9 */
+            hex >= 48 && hex <= 57 ? hex - 48 : (
+              /* A-F */
+              hex >= 65 && hex <= 70 ? hex - 65 + 10 : (
+                /* a-f */
+                hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1
+              )
+            )
+          );
+          if (digit < 0)
+            throw new TomlError("invalid non-hex character in unicode escape", { toml: ctx.s, ptr: ctx.p + 1 });
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          throw new TomlError("invalid unicode escape", { toml: ctx.s, ptr: ctx.p });
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = ctx.p + 1;
+        state = 0;
+      } else if (c === 32 || c === 9) {
+        state = 2;
+      } else {
+        if (c === 98)
+          parsed += "\b";
+        else if (c === 116)
+          parsed += "	";
+        else if (c === 110)
+          parsed += "\n";
+        else if (c === 102)
+          parsed += "\f";
+        else if (c === 114)
+          parsed += "\r";
+        else if (c === 101)
+          parsed += "\x1B";
+        else if (c === 34)
+          parsed += '"';
+        else if (c === 92)
+          parsed += "\\";
+        else
+          throw new TomlError("unrecognized escape sequence", { toml: ctx.s, ptr: ctx.p });
+        sliceStart = ctx.p + 1;
+        state = 0;
+      }
+    } else if (c !== 32 && c !== 9) {
+      if (state === 2) {
+        throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+          toml: ctx.s,
+          ptr: sliceStart
+        });
+      }
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
+    }
+  }
+  throw new TomlError("unfinished string", { toml: ctx.s, ptr: start2 });
+}
+function sliceAndTrimEndOf(ctx, start2, end) {
+  let value = ctx.s.slice(start2, end);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > 0) {
+    skipComment({ s: value, p: commentIdx, d: 0 });
+    value = value.slice(0, commentIdx);
+  }
+  return value.trimEnd();
+}
+function parseValue(ctx, integersAsBigInt, end) {
+  let ptr = ctx.p;
+  let err2 = { toml: ctx.s, ptr };
+  skipUntil(ctx, 44, end);
+  let value = sliceAndTrimEndOf(ctx, ptr, ctx.p);
+  if (!value)
+    throw new TomlError("incomplete declaration: value expected", err2);
+  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", err2);
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", err2);
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", err2);
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid())
+    throw new TomlError("invalid value", err2);
+  return date;
+}
+
+// node_modules/smol-toml/dist/extract.js
+function extractValue(ctx, end, integersAsBigInt) {
+  let ptr = ctx.p;
+  let c = ctx.s.charCodeAt(ptr);
+  if (c === 91 || c === 123) {
+    if (!ctx.d--) {
+      throw new TomlError("document contains excessively nested structures. aborting.", {
+        toml: ctx.s,
+        ptr
+      });
+    }
+    let value = c === 91 ? parseArray(ctx, integersAsBigInt) : parseInlineTable(ctx, integersAsBigInt);
+    ctx.d++;
+    return value;
+  }
+  if (c === 34 || c === 39) {
+    return parseString(ctx);
+  }
+  if (c === 116) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      throw new TomlError("invalid value", { toml: ctx.s, ptr });
+    ctx.p++;
+    return true;
+  }
+  if (c === 102) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      throw new TomlError("invalid value", { toml: ctx.s, ptr });
+    ctx.p++;
+    return false;
+  }
+  return parseValue(ctx, integersAsBigInt, end);
+}
+
+// node_modules/smol-toml/dist/struct.js
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(ctx, end = "=") {
+  let start2 = ctx.p;
+  let dot = start2 - 1;
+  let parsed = [];
+  let endPtr = ctx.s.indexOf(end, start2);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: ctx.s,
+      ptr: start2
+    });
+  }
+  do {
+    let c = ctx.s.charCodeAt(ctx.p = ++dot);
+    if (c !== 32 && c !== 9) {
+      if (c === 34 || c === 39) {
+        if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2)) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        let part = parseString(ctx);
+        dot = ctx.s.indexOf(".", ctx.p);
+        let strEnd = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: ctx.s,
+            ptr: newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        if (endPtr < ctx.p) {
+          endPtr = ctx.s.indexOf(end, ctx.p);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: ctx.s,
+              ptr: start2
+            });
+          }
+        }
+        parsed.push(part);
+      } else {
+        dot = ctx.s.indexOf(".", ctx.p);
+        let part = ctx.s.slice(ctx.p, 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: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  ctx.p = endPtr + 1;
+  skipVoid(ctx, true, true);
+  return parsed;
+}
+function parseInlineTable(ctx, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  ctx.p++;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t = res;
+    let hasOwn = false;
+    let p = ctx.p;
+    let key = parseKey(ctx);
+    for (let i2 = 0; i2 < key.length; i2++) {
+      if (i2)
+        t = hasOwn ? t[k] : t[k] = {};
+      k = key[i2];
+      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: ctx.s,
+          ptr: p
+        });
+      }
+      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: ctx.s,
+        ptr: ctx.p
+      });
+    }
+    let value = extractValue(ctx, 125, integersAsBigInt);
+    seen.add(t[k] = value);
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
+    }
+    if (c !== 44) {
+      throw new TomlError("expected comma or end of structure", { toml: ctx.s, ptr: ctx.p - 1 });
+    }
+  }
+  throw new TomlError("unfinished table encountered", {
+    toml: ctx.s,
+    ptr: ctx.p
+  });
+}
+function parseArray(ctx, integersAsBigInt) {
+  let res = [];
+  let c;
+  ctx.p++;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+      ctx.p++;
+      return res;
+    }
+    res.push(extractValue(ctx, 93, integersAsBigInt));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44) {
+      throw new TomlError("expected comma or end of structure", { toml: ctx.s, ptr: ctx.p - 1 });
+    }
+  }
+  throw new TomlError("unfinished array encountered", {
+    toml: ctx.s,
+    ptr: ctx.p
+  });
+}
+
+// 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 i2 = 0; i2 < key.length; i2++) {
+    if (i2) {
+      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[i2];
+    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: i2 < 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 ctx = { s: toml, p: 0, d: maxDepth };
+  let res = {};
+  let meta = {};
+  let tmp;
+  let tbl = res;
+  let m = meta;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      let k = parseKey(ctx, "]");
+      if (isTableArray) {
+        if (toml.charCodeAt(ctx.p - 1) !== 93) {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: ctx.p - 1
+          });
+        }
+        ctx.p++;
+      }
+      let p = peekTable(
+        k,
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr: tmp
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+    } else {
+      tmp = ctx.p;
+      let k = parseKey(ctx);
+      let p = peekTable(
+        k,
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr: tmp
+        });
+      }
+      p[1][p[0]] = extractValue(ctx, void 0, integersAsBigInt);
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && tmp !== 13) {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr: ctx.p
+      });
+    }
+    skipVoid(ctx);
+  }
+  return res;
+}
+
+// packages/cli/src/status.ts
+init_hookRuntime();
 import { devReadiness } from "./runtime/releaseSource.js";
 import { basename, isAbsolute, relative as relative2, resolve } from "node:path";
 import { Output } from "./output.js";
@@ -4916,6 +5566,109 @@ import {
 import { hostOrder } from "./install/adapters.js";
 import { hookStatusConditions } from "./install/hosts.js";
 import { launcherStatus } from "./launcher.js";
+var editorFiles = [
+  ["claude-code", "Claude Code", ".claude/settings.json", ".claude.json"],
+  ["codex", "Codex", ".codex/hooks.json", ".codex/config.toml"],
+  ["cursor", "Cursor", ".cursor/hooks.json", ".cursor/mcp.json"]
+];
+var object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function hookCommands(value, owner) {
+  if (Array.isArray(value)) return value.flatMap((entry) => hookCommands(entry, owner));
+  if (!object(value)) return [];
+  return [
+    ...typeof value.command === "string" && value.command.includes(`--mnemonik-owner=${owner}`) ? [value.command] : [],
+    ...Object.values(value).flatMap((entry) => hookCommands(entry, owner))
+  ];
+}
+function hookTarget(command) {
+  try {
+    const plain = /^node ("(?:[^"\\]|\\.)*")/u.exec(command)?.[1];
+    if (plain) {
+      const parsed = JSON.parse(plain);
+      if (typeof parsed === "string") return parsed;
+    }
+    const token = /^node -e .* -- ([A-Za-z0-9_-]+)(?:\s|$)/u.exec(command)?.[1];
+    if (token) return fileURLToPath2(Buffer.from(token, "base64url").toString("utf8"));
+  } catch {
+  }
+  return void 0;
+}
+async function localEditorStatus(home) {
+  return Promise.all(
+    editorFiles.map(async ([host, name2, hooksFile, mcpFile]) => {
+      const read = (file) => readFile(join4(home, file), "utf8").catch(
+        (error) => error.code === "ENOENT" ? null : ""
+      );
+      const [hooksRaw, mcpRaw] = await Promise.all([read(hooksFile), read(mcpFile)]);
+      let commands = [];
+      try {
+        commands = hookCommands(JSON.parse(hooksRaw ?? "{}"), `${host}-hooks`);
+      } catch {
+      }
+      const hooks = commands.length > 0 && (await Promise.all(
+        commands.map(async (command) => {
+          const target = hookTarget(command);
+          return !!target && (await stat(target).catch(() => null))?.isFile() === true;
+        })
+      )).every(Boolean);
+      let declaration;
+      try {
+        const config = host === "codex" ? parse(mcpRaw ?? "") : JSON.parse(mcpRaw ?? "{}");
+        declaration = object(config.mcp_servers) ? config.mcp_servers.mnemonik : object(config.mcpServers) ? config.mcpServers.mnemonik : void 0;
+      } catch {
+      }
+      return {
+        host,
+        name: name2,
+        // Only a Mnemonik mark in the editor's own settings counts. The mere
+        // presence of ~/.codex or a project-local .cursor is not a choice.
+        marked: commands.length > 0 || object(declaration),
+        hooks,
+        mcp: !object(declaration) ? "missing" : declaration.enabled === false || declaration.disabled === true ? "disabled" : "ready"
+      };
+    })
+  );
+}
+var mcpTurnOnAction = {
+  "claude-code": "In Claude Code, type /mcp, choose mnemonik, then turn it on.",
+  codex: "Open ~/.codex/config.toml, find mnemonik and set enabled = true.",
+  cursor: "Open Cursor Settings, Customize, MCPs, then turn on mnemonik."
+};
+async function localInstallationConditions(home, stateDir, launcherOptions) {
+  const conditions = [];
+  const issue = (reason, action, component) => conditions.push({
+    kind: "selected_component_failed",
+    reason,
+    action,
+    ...component ? { component } : {}
+  });
+  if ((await launcherStatus({ stateDir, home, ...launcherOptions })).ownership !== "ours")
+    issue(
+      "The mnemonik command is missing.",
+      "Run npx -y @mnemonik/cli@latest install to restore it."
+    );
+  const owned = (await readOwnership(stateDir)).targets.map((target) => target.host);
+  const editors = (await localEditorStatus(home)).filter(
+    (editor) => editor.marked || owned.includes(editor.host)
+  );
+  if (!editors.length)
+    issue("No editor connections were found.", "Run mnemonik install to set them up again.");
+  for (const editor of editors) {
+    if (!editor.hooks)
+      issue(
+        `${editor.name} hooks are missing.`,
+        "Run mnemonik install to set them up again.",
+        editor.host
+      );
+    if (editor.mcp !== "ready")
+      issue(
+        `${editor.name} connection is ${editor.mcp === "disabled" ? "turned off" : "missing"}.`,
+        editor.mcp === "missing" ? "Run mnemonik install to set it up again." : mcpTurnOnAction[editor.host],
+        editor.host
+      );
+  }
+  return conditions;
+}
 var contains = (parent, child) => {
   const path = relative2(resolve(parent), resolve(child));
   return path === "" || !path.startsWith("..") && !isAbsolute(path);
@@ -5046,144 +5799,6 @@ function buildStatusDocument(input) {
     generatedAt: input.generatedAt
   });
 }
-var CODEX_TRUST_MESSAGE = {
-  sentence: "Codex needs permission to use the Mnemonik hooks.",
-  nextStep: "Open Codex, allow the Mnemonik hooks, then quit and reopen Codex."
-};
-var readinessMessages = [
-  [/host_trust_pending|trust_pending/iu, CODEX_TRUST_MESSAGE],
-  [
-    /vendor_policy_pending|vendor policy/iu,
-    {
-      sentence: "Your editor is waiting for permission to use Mnemonik.",
-      nextStep: "Open the editor, approve Mnemonik, then start a new session."
-    }
-  ],
-  [
-    /restart_pending|needs? (?:a )?restart/iu,
-    {
-      sentence: "An editor needs to restart before Mnemonik can work.",
-      nextStep: "Quit and reopen the editor, then start a new session."
-    }
-  ],
-  [
-    /project_identity_choice_pending|project_setup_required|project identity|pending project setup/iu,
-    {
-      sentence: "A project on this machine still needs to be connected.",
-      nextStep: "Run mnemonik status in the project and follow the project setup step."
-    }
-  ],
-  [
-    /scanner_not_verified|background_indexing_not_verified|scanner_paused|dev_release_source/iu,
-    {
-      sentence: "The scanner has not checked in yet.",
-      nextStep: "Run mnemonik status on this machine after the scanner starts."
-    }
-  ],
-  [
-    /hook_not_verified|hooks? (?:still )?needs? verification|could not be inspected/iu,
-    {
-      sentence: "Mnemonik has not received context from an editor hook yet.",
-      nextStep: "Start a new editor session, then run mnemonik status."
-    }
-  ],
-  [
-    /hooks_missing|hook (?:declaration|credential family) is missing|hooks are not installed/iu,
-    {
-      sentence: "The Mnemonik hooks are not installed correctly for an editor.",
-      nextStep: "Run mnemonik repair on this machine, then restart the editor."
-    }
-  ],
-  [
-    /host_grant_unbound|credential_revoked/iu,
-    {
-      sentence: "An editor is signed out of Mnemonik on this machine.",
-      nextStep: "Sign in to Mnemonik from that editor to restore context."
-    }
-  ],
-  [
-    /host_not_connected|signed in, not connected yet/iu,
-    {
-      sentence: "An editor is signed in but has not used Mnemonik yet.",
-      nextStep: "Open the editor and start a session in a connected project."
-    }
-  ],
-  [
-    /scanner_omitted|scanner (?:was |coverage was )?(?:deliberately )?(?:omitted|skipped)/iu,
-    {
-      sentence: "The scanner is not watching projects on this machine.",
-      nextStep: "Run mnemonik scanner enable to choose the projects to watch."
-    }
-  ],
-  [
-    /project_uncovered|outside approved scanner roots/iu,
-    {
-      sentence: "A connected project is outside the folders watched by the scanner.",
-      nextStep: "Run mnemonik scanner enable and add that project."
-    }
-  ],
-  [
-    /host_skipped/iu,
-    {
-      sentence: "An editor on this machine is not connected to Mnemonik.",
-      nextStep: "Open that editor and sign in to Mnemonik."
-    }
-  ],
-  [
-    /windows_task_creation_failed|windows.*task/iu,
-    {
-      sentence: "Windows could not start the scanner in the background.",
-      nextStep: "Run mnemonik scanner enable again from a terminal with permission to create tasks."
-    }
-  ],
-  [
-    /post_commit_upload_failed|status could not be uploaded/iu,
-    {
-      sentence: "Setup finished on this machine, but its status did not reach Mnemonik.",
-      nextStep: "Run mnemonik doctor, then run mnemonik status again."
-    }
-  ],
-  [
-    /indexing_failed|indexing failed/iu,
-    {
-      sentence: "The scanner could not index one or more projects.",
-      nextStep: "Run mnemonik doctor on this machine and follow the scanner repair step."
-    }
-  ],
-  [
-    /indexing_stalled|not_reporting|indexing stalled/iu,
-    {
-      sentence: "The scanner stopped making progress.",
-      nextStep: "Run mnemonik doctor on this machine and restart the scanner when prompted."
-    }
-  ],
-  [
-    /selected_component_failed|failed|unreachable/iu,
-    {
-      sentence: "Part of Mnemonik did not finish setting up.",
-      nextStep: "Run mnemonik doctor on this machine and follow the first repair step."
-    }
-  ],
-  [
-    /login_pending|sign.?in|grants? could not be verified|access has not been verified/iu,
-    {
-      sentence: "A Mnemonik sign-in has not finished on this machine.",
-      nextStep: "Finish signing in from the editor, then run mnemonik status."
-    }
-  ]
-];
-var genericReadinessMessage = {
-  sentence: "This machine needs attention before Mnemonik can work fully.",
-  nextStep: "Run mnemonik doctor on this machine and follow the first repair step."
-};
-function messageFor(reason, actions) {
-  const message = readinessMessages.find(([pattern]) => pattern.test(reason))?.[1] ?? genericReadinessMessage;
-  if (!/host_trust_pending|trust_pending/iu.test(reason)) return message;
-  const nextStep = actions.find(
-    (action) => action.startsWith("Run the codex command in a terminal ") || action.startsWith("Open the ChatGPT app ")
-  );
-  return nextStep ? { ...message, nextStep } : message;
-}
 function renderAttention(label, summary2, output, rendered) {
   output.line(`${label}: Needs attention.`);
   const messages = summary2.reasons.length ? summary2.reasons.map((reason) => messageFor(reason, summary2.actions)) : [genericReadinessMessage];
@@ -5277,14 +5892,7 @@ async function collectStatusDocument(input) {
         reason: "scanner_paused",
         action: "mnemonik install"
       };
-    let alive = false;
-    if (snapshot?.lifecycle.pid)
-      try {
-        process.kill(snapshot.lifecycle.pid, 0);
-        alive = true;
-      } catch {
-      }
-    if (state && alive && (snapshot?.lifecycle.state === "running" || snapshot?.lifecycle.state === "starting") && heartbeat && Date.now() - heartbeat < 36e4) {
+    if (state && (snapshot?.lifecycle.state === "running" || snapshot?.lifecycle.state === "starting") && heartbeat && Date.now() - heartbeat < 36e4) {
       scannerStatus = {
         roots: state.config.roots,
         exclusions: state.config.exclusions ?? [],
@@ -5358,7 +5966,49 @@ export {
   CODEX_TRUST_MESSAGE,
   buildStatusDocument,
   collectStatusDocument,
+  localEditorStatus,
+  localInstallationConditions,
+  mcpTurnOnAction,
   readProjectStatus,
   renderStatusSummaries,
   statusExitCode
 };
+/*! Bundled license information:
+
+smol-toml/dist/date.js:
+smol-toml/dist/error.js:
+smol-toml/dist/util.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.
+   *)
+*/