sphica 0.6.30 → 0.6.32

package/dist/cli.js

@@ -92,7 +92,8 @@ var require_src = __commonJS(function(exports, module) {
 });
 
 // server/src/cli.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
+import os4 from "node:os";
 import path10 from "node:path";
 
 // server/node_modules/@clack/core/dist/index.mjs
@@ -2966,7 +2967,7 @@ async function run(app, inputs, context) {
 }
 
 // server/src/admin.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import path9 from "node:path";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 
@@ -3007,11 +3008,1114 @@ import os from "node:os";
 import path2 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
+// server/src/codex-trust.ts
+import crypto from "node:crypto";
+
+// server/node_modules/smol-toml/dist/error.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.
+ */
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r?\n/);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r?\n/);
+  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 += `
+`;
+    if (i2 === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += `^
+`;
+    }
+  }
+  return codeblock;
+}
+
+class TomlError 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;
+  }
+  static x(message, ctx, ptr) {
+    throw new TomlError(message, { toml: ctx.s, ptr: ptr ?? ctx.p });
+  }
+}
+
+// server/node_modules/smol-toml/dist/primitive.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.
+ */
+function parseString(ctx) {
+  let startPtr = 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) {
+      TomlError.x("control characters are not allowed in strings", ctx);
+    } 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) {
+        let s = ctx.s.slice(sliceStart, ctx.p);
+        parsed = parsed ? parsed + s : s;
+      }
+      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 errPtr = ctx.p++ - 1;
+        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);
+          let digit = hex >= 48 && hex <= 57 ? hex - 48 : hex >= 65 && hex <= 70 ? hex - 65 + 10 : hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1;
+          if (digit < 0)
+            TomlError.x("invalid non-hex character in unicode escape", ctx);
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          TomlError.x("invalid unicode escape", ctx, errPtr);
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = ctx.p--;
+        state = 0;
+      } else if (isMultiline && (c === 32 || c === 9)) {
+        state = 2;
+      } else {
+        if (c === 98)
+          parsed += "\b";
+        else if (c === 116)
+          parsed += "\t";
+        else if (c === 110)
+          parsed += `
+`;
+        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
+          TomlError.x("unrecognised escape sequence", ctx);
+        sliceStart = ctx.p + 1;
+        state = 0;
+      }
+    } else if (c !== 32 && c !== 9) {
+      if (state === 2)
+        TomlError.x("invalid escape: only line-ending whitespace may be escaped", ctx, sliceStart);
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
+    }
+  }
+  TomlError.x("unfinished string", ctx, startPtr);
+}
+
+// server/node_modules/smol-toml/dist/date.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.
+ */
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[Tt ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|z|[-+]\d{2}:\d{2})?$/i;
+
+class TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date, fasttype, unsafeDelim) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    let c;
+    if (typeof date === "string") {
+      if (fasttype)
+        prep: {
+          if (fasttype < 3) {
+            if (+date.slice(11, 13) > 23) {
+              date = "";
+              break prep;
+            }
+            if (fasttype === 2) {
+              offset = null;
+              date += "Z";
+            } else if ((c = date.charCodeAt(date.length - 1)) !== 90 && c !== 122) {
+              offset = date.slice(date.length - 6);
+            }
+            if (unsafeDelim)
+              date = date.slice(0, 10) + "T" + date.slice(11);
+          } else if (fasttype === 4) {
+            date = +date.slice(0, 2) > 23 ? "" : `0000-01-01T${date}Z`;
+          }
+          hasDate = fasttype !== 4;
+          hasTime = fasttype !== 3;
+        }
+      else {
+        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;
+            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" || 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 * 60000);
+    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;
+  }
+}
+
+// server/node_modules/smol-toml/dist/extract.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.
+ */
+function isDigit(char, base = 10) {
+  return base === 16 ? char > 47 && char < 58 || char > 64 && char < 71 || char > 96 && char < 103 : char > 47 && char < 48 + base;
+}
+function isEndOfValue(char, delim) {
+  return char === 32 || char === 9 || char === 10 || char === 13 || delim && (char === delim || char === 44) || char === 35;
+}
+function extractValue(ctx, end) {
+  let errPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p);
+  if (c === 91 || c === 123) {
+    ctx.d-- || TomlError.x("document contains excessively nested structures. aborting.", ctx);
+    let value = c === 91 ? parseArray(ctx) : parseInlineTable(ctx);
+    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)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, 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)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, false;
+  }
+  if (c === 43 || c === 45) {
+    return parseNumber(ctx, ctx.p, ctx.s.charCodeAt(++ctx.p), 44 - c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 4) === 45 && ctx.s.charCodeAt(ctx.p + 7) === 45) {
+    return parseDate(ctx, c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 2) === 58) {
+    return parseTime(ctx, c, end);
+  }
+  return parseNumber(ctx, ctx.p, c, 0, end);
+}
+function parseNumber(ctx, startPtr, startChr, sign, endChr) {
+  let c = startChr;
+  let state = 0;
+  let hasUnderscores = false;
+  if (c === 105) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 110 || ctx.s.charCodeAt(++ctx.p) !== 102)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, (sign || 1) / 0;
+  }
+  if (c === 110) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 110)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, NaN;
+  }
+  if (c === 48) {
+    if (++ctx.p >= ctx.s.length || isEndOfValue(c = ctx.s.charCodeAt(ctx.p), endChr))
+      return ctx.bi === true ? 0n : 0;
+    if (!sign) {
+      if (c === 120)
+        return parseIntegerBaseN(ctx, startPtr, 16, endChr);
+      else if (c === 98)
+        return parseIntegerBaseN(ctx, startPtr, 2, endChr);
+      else if (c === 111)
+        return parseIntegerBaseN(ctx, startPtr, 8, endChr);
+    }
+    if (c === 46)
+      state = 2;
+    else if (c === 101 || c === 69)
+      state = 4;
+    else
+      TomlError.x("illegal leading zero", ctx, startPtr);
+  } else if (!isDigit(c))
+    TomlError.x("invalid value", ctx, startPtr);
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (!state)
+      state = 1;
+    if (c === 95) {
+      if (!(state & 1))
+        TomlError.x("illegal underscore", ctx);
+      state += 11;
+      hasUnderscores = true;
+    } else if (state === 1 && c === 46)
+      state = 2;
+    else if ((state === 1 || state === 3) && (c === 101 || c === 69))
+      state = 4;
+    else if (state === 4 && (c === 43 || c === 45)) {} else if (!isDigit(c))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (state > 9)
+      state -= 11;
+    else if (!(state & 1))
+      state++;
+  }
+  if (!state) {
+    let val = (startChr - 48) * (sign || 1);
+    return ctx.bi === true ? BigInt(val) : val;
+  }
+  if (!(state & 1))
+    TomlError.x("unfinished numeric value", ctx, startPtr);
+  let str = ctx.s.slice(startPtr, ctx.p);
+  if (hasUnderscores)
+    str = str.replaceAll("_", "");
+  return state > 1 ? parseFloat(str) : parseInteger(ctx, str, 10, startPtr);
+}
+function parseIntegerBaseN(ctx, startPtr, base, endChr) {
+  let c, underscore = 1;
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (c === 95) {
+      if (underscore & 1)
+        TomlError.x("illegal underscore", ctx);
+      underscore = 3;
+    } else if (!isDigit(c, base))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (underscore & 1)
+      underscore--;
+  }
+  if (underscore & 1)
+    TomlError.x("unfinished numeric value", ctx);
+  let str = ctx.s.slice(startPtr + 2, ctx.p);
+  if (underscore)
+    str = str.replaceAll("_", "");
+  return parseInteger(ctx, str, base, startPtr);
+}
+function parseInteger(ctx, str, base, startPtr) {
+  if (ctx.bi !== true)
+    int: {
+      let val = parseInt(str, base);
+      if (!Number.isSafeInteger(val)) {
+        if (ctx.bi)
+          break int;
+        TomlError.x("integer value cannot be represented losslessly", ctx, startPtr);
+      }
+      return val;
+    }
+  return base === 10 ? BigInt(str) : BigInt((base === 2 ? "0b" : base === 8 ? "0o" : "0x") + str);
+}
+function parseDate(ctx, c, endChr) {
+  let startPtr = ctx.p++, unsafeSeparator;
+  if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++))) {
+    return parseNumber(ctx, ctx.p = startPtr, c, 0, endChr);
+  }
+  ctx.p += 5;
+  if (!isDigit(ctx.s.charCodeAt(ctx.p++)))
+    TomlError.x("invalid date-time: date part is malformed", ctx, startPtr);
+  if (ctx.p >= ctx.s.length || ((c = ctx.s.charCodeAt(ctx.p)) !== 32 || (unsafeSeparator = true, !isDigit(ctx.s.charCodeAt(ctx.p + 1)))) && c !== 84 && c !== 116) {
+    let t3 = ctx.s.slice(startPtr, ctx.p);
+    return readDate(ctx, t3, 3, false, startPtr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 3) !== 58)
+    TomlError.x("invalid date-time: time part is malformed", ctx, startPtr);
+  if (ctx.s.charCodeAt(ctx.p += 3) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  if (c = ctx.s.charCodeAt(ctx.p)) {
+    if (c === 90 || c === 122) {
+      let t3 = ctx.s.slice(startPtr, ++ctx.p);
+      return readDate(ctx, t3, 1, unsafeSeparator, startPtr, "[+00:00]");
+    }
+    if (c === 43 || c === 45) {
+      let t3 = ctx.s.slice(startPtr, ctx.p += 6);
+      return readDate(ctx, t3, 1, unsafeSeparator, startPtr, !ctx.ld && "[" + ctx.s.slice(ctx.p - 6, ctx.p) + "]");
+    }
+  }
+  let t2 = ctx.s.slice(startPtr, ctx.p);
+  return readDate(ctx, t2, 2, unsafeSeparator, startPtr);
+}
+function parseTime(ctx, c, endChr) {
+  let start = ctx.p;
+  if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(++ctx.p))) {
+    return parseNumber(ctx, --ctx.p, c, 0, endChr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 4) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  let t2 = ctx.s.slice(start, ctx.p);
+  return readDate(ctx, t2, 4, false, start);
+}
+function readDate(ctx, str, type, unsafeDelim, errPtr, temporalSuffix) {
+  if (ctx.ld) {
+    let date = new TomlDate(str, type, unsafeDelim);
+    if (!date.isValid())
+      TomlError.x("invalid date", ctx, errPtr);
+    return date;
+  }
+  try {
+    if (temporalSuffix)
+      str += temporalSuffix;
+    switch (type) {
+      case 1:
+        return Temporal.ZonedDateTime.from(str);
+      case 2:
+        return Temporal.PlainDateTime.from(str);
+      case 3:
+        return Temporal.PlainDate.from(str);
+      case 4:
+        return Temporal.PlainTime.from(str);
+    }
+  } catch (e) {
+    TomlError.x(e instanceof Error ? e.message : "" + e, ctx, errPtr);
+  }
+}
+
+// server/node_modules/smol-toml/dist/util.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.
+ */
+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) {
+      TomlError.x("control characters are not allowed in comments", ctx);
+    }
+  }
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (ctx.p < ctx.s.length) {
+    while (ctx.p < ctx.s.length && ((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);
+  }
+}
+
+// server/node_modules/smol-toml/dist/struct.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.
+ */
+function parseKey(ctx, end = 61) {
+  let startPtr;
+  let state = 0;
+  let parsed = [];
+  let sliceStart;
+  let c = ctx.s.charCodeAt(startPtr = ctx.p);
+  do {
+    if (c === end) {
+      if (!state)
+        TomlError.x("unexpected end of key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      return ctx.p++, parsed;
+    } else if (c === 46) {
+      if (!state)
+        TomlError.x("illegal empty bare key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      state = 0;
+    } else if (!state && (c === 34 || c === 39)) {
+      if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2))
+        TomlError.x("illegal quoted key: multiline strings are not allowed", ctx);
+      parsed.push(parseString(ctx));
+      state = 2;
+      ctx.p--;
+    } else if (c === 32 || c === 9) {
+      if (state === 1) {
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+        state = 2;
+      }
+    } else if (state === 2 || c < 48 && c !== 45 || c > 57 && c < 65 || c > 90 && c < 97 && c !== 95 || c > 122) {
+      TomlError.x("illegal character in key", ctx);
+    } else if (!state) {
+      state = 1;
+      sliceStart = ctx.p;
+    }
+  } while (c = ctx.s.charCodeAt(++ctx.p));
+  TomlError.x("incomplete key-value: cannot find end of key", ctx, startPtr);
+}
+function parseInlineTable(ctx) {
+  let startPtr = ctx.p++;
+  let res = Object.create(null);
+  let seen = new Set;
+  let c;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t2 = res;
+    let hasOwn = false;
+    let errPtr = ctx.p;
+    let key = parseKey(ctx);
+    for (let i2 = 0;i2 < key.length; i2++) {
+      if (i2)
+        t2 = hasOwn ? t2[k] : t2[k] = Object.create(null);
+      k = key[i2];
+      if ((hasOwn = Object.hasOwn(t2, k)) && (typeof t2[k] !== "object" || seen.has(t2[k]))) {
+        TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+      }
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor")) {
+        t2 = ctx.uk !== 1 && TomlError.x("document contains an unsafe property", ctx, errPtr);
+        break;
+      }
+      if (!hasOwn && unsafe) {
+        Object.defineProperty(t2, k, { enumerable: true, configurable: true, writable: true });
+      }
+    }
+    if (hasOwn) {
+      TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+    }
+    skipVoid(ctx, true, true);
+    let value = extractValue(ctx, 125);
+    if (t2 && typeof (t2[k] = value) === "object")
+      seen.add(value);
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
+    }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+  }
+  TomlError.x("unfinished table", ctx, startPtr);
+}
+function parseArray(ctx) {
+  let startPtr = ctx.p++;
+  let res = [];
+  let c;
+  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));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+  }
+  TomlError.x("unfinished array", ctx, startPtr);
+}
+
+// server/node_modules/smol-toml/dist/parse.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.
+ */
+function peekTable(ctx, key, table, meta, type) {
+  let t2 = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i2 = 0;i2 < key.length; i2++) {
+    if (i2) {
+      t2 = hasOwn ? t2[k] : t2[k] = Object.create(null);
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t2.length - 1;
+        t2 = t2[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i2];
+    if ((hasOwn = Object.hasOwn(t2, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor"))
+        return false;
+      if (unsafe) {
+        Object.defineProperty(t2, 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: Object.create(null)
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t2[k] = [];
+    }
+    t2[k].push(t2 = Object.create(null));
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: Object.create(null) };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t2 = hasOwn ? t2[k] : t2[k] = Object.create(null);
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t2, state.c];
+}
+function validateTablePeek(ctx, peek, ptr) {
+  if (peek === null || ctx.uk === 2)
+    TomlError.x(peek === null ? "trying to redefine an already defined table or value" : "document contains an unsafe property", ctx, ptr);
+}
+function parse(toml, options = {}) {
+  let ctx = {
+    s: toml,
+    p: 0,
+    d: options.maxDepth ?? 1000,
+    bi: options.integersAsBigInt ?? false,
+    ld: options.useLegacyDate ?? true,
+    uk: options.unsafeKeyBehaviour === "throw" ? 2 : options.unsafeKeyBehaviour === "drop" ? 1 : 0
+  };
+  let res = Object.create(null);
+  let meta = Object.create(null);
+  let tmp;
+  let skipping = false;
+  let tbl = res;
+  let m = meta;
+  if (toml.charCodeAt(0) === 65279)
+    ctx.p++;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      skipping = false;
+      let k = parseKey(ctx, 93);
+      if (isTableArray) {
+        if (toml.charCodeAt(ctx.p) !== 93) {
+          TomlError.x("expected end of table array declaration", ctx);
+        }
+        ctx.p++;
+      }
+      let p = peekTable(ctx, k, res, meta, isTableArray ? 2 : 1);
+      if (!p) {
+        validateTablePeek(ctx, p, tmp);
+        skipping = true;
+      } else {
+        m = p[2];
+        tbl = p[1];
+      }
+    } else {
+      tmp = ctx.p;
+      let k = parseKey(ctx);
+      let p = peekTable(ctx, k, tbl, m, 0);
+      if (!p && !skipping)
+        validateTablePeek(ctx, p, tmp);
+      skipVoid(ctx, true, true);
+      let v = extractValue(ctx, undefined);
+      if (p && !skipping)
+        p[1][p[0]] = v;
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && (tmp !== 13 || toml.charCodeAt(ctx.p + 1) !== 10)) {
+      TomlError.x("each key-value declaration must be followed by an end-of-line", ctx);
+    }
+    skipVoid(ctx);
+  }
+  return res;
+}
+
+// server/node_modules/smol-toml/dist/stringify.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.
+ */
+var HAS_WELLFORMED = !!"".isWellFormed;
+
+// server/node_modules/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.
+ */
+
+// server/src/codex-trust.ts
+var CODEX_TRUST_VERIFIED = ["0.160.0"];
+var LABELS = {
+  PreToolUse: "pre_tool_use",
+  PermissionRequest: "permission_request",
+  PostToolUse: "post_tool_use",
+  PreCompact: "pre_compact",
+  PostCompact: "post_compact",
+  SessionStart: "session_start",
+  SessionEnd: "session_end",
+  UserPromptSubmit: "user_prompt_submit",
+  SubagentStart: "subagent_start",
+  SubagentStop: "subagent_stop",
+  Stop: "stop",
+  Interrupt: "interrupt"
+};
+var NO_MATCHER = new Set(["UserPromptSubmit", "Stop", "Interrupt"]);
+var CONTEXT = new Set(["PreToolUse", "PostToolUse", "SessionStart", "UserPromptSubmit", "SubagentStart"]);
+var DEFAULT_CONTEXT_LIMIT = 2500;
+var SHORT = new Set(["SessionEnd", "Interrupt"]);
+var RUST_SPACE = /^[\t\n\v\f\r \u0085\u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]+|[\t\n\v\f\r \u0085\u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]+$/g;
+var isTable = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isCount = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
+function canonical(v) {
+  if (Array.isArray(v))
+    return `[${v.map(canonical).join(",")}]`;
+  if (isTable(v))
+    return `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${canonical(v[k])}`).join(",")}}`;
+  return JSON.stringify(v);
+}
+var sha256 = (text) => `sha256:${crypto.createHash("sha256").update(text).digest("hex")}`;
+function readHookStates(configToml) {
+  const states = new Map;
+  if (configToml === null)
+    return states;
+  let config;
+  try {
+    config = parse(configToml);
+  } catch {
+    return { unknown: "config.toml could not be parsed" };
+  }
+  const hooks = isTable(config) ? config.hooks : undefined;
+  if (hooks === undefined)
+    return states;
+  const table = isTable(hooks) ? hooks.state : undefined;
+  if (table === undefined)
+    return states;
+  if (!isTable(table))
+    return { unknown: "hooks.state in config.toml is not a table" };
+  for (const [raw, value] of Object.entries(table)) {
+    const key = raw.replace(RUST_SPACE, "");
+    if (!key || !isTable(value))
+      continue;
+    const { enabled, trusted_hash } = value;
+    if (enabled !== undefined && typeof enabled !== "boolean" || trusted_hash !== undefined && typeof trusted_hash !== "string")
+      continue;
+    const s = states.get(key) ?? {};
+    if (enabled !== undefined)
+      s.enabled = enabled;
+    if (trusted_hash !== undefined)
+      s.trusted_hash = trusted_hash;
+    states.set(key, s);
+  }
+  return states;
+}
+function hookTrust(hooksJson, pluginId, relativePath, platform, states) {
+  let file;
+  try {
+    file = JSON.parse(hooksJson, (_key, value, context) => typeof value === "number" && /[.eE]/.test(context?.source ?? "") ? Number.NaN : value);
+  } catch {
+    return { unknown: "the hooks file is not JSON" };
+  }
+  if (isTable(file) && (Object.keys(file).some((k) => k !== "hooks" && k !== "description") || file.description != null && typeof file.description !== "string"))
+    return { unknown: "the hooks file has a top-level field Codex would not read" };
+  const events = isTable(file) ? file.hooks : undefined;
+  if (!isTable(events))
+    return { unknown: "the hooks file has no hooks table" };
+  const hooks = [];
+  for (const [event, groups] of Object.entries(events)) {
+    const label = LABELS[event];
+    if (!label)
+      return { unknown: `the hooks file has an event Codex does not know (${event})` };
+    if (!Array.isArray(groups))
+      return { unknown: `${event} in the hooks file is not a list` };
+    for (const [g, group2] of groups.entries()) {
+      if (!isTable(group2) || !Array.isArray(group2.hooks))
+        return { unknown: `a ${event} group has no hooks list` };
+      if (group2.matcher !== undefined && group2.matcher !== null && typeof group2.matcher !== "string")
+        return { unknown: `a ${event} matcher is not a string` };
+      const matcher = NO_MATCHER.has(event) ? undefined : group2.matcher ?? undefined;
+      for (const [h2, handler] of group2.hooks.entries()) {
+        if (!isTable(handler) || handler.type !== "command")
+          return { unknown: `a ${event} hook is not a command` };
+        const { command, timeout, statusMessage, additionalContextLimit } = handler;
+        if ("commandWindows" in handler && "command_windows" in handler)
+          return { unknown: `a ${event} hook names its Windows command twice` };
+        const commandWindows = handler.commandWindows ?? handler.command_windows;
+        if (typeof command !== "string" || commandWindows !== undefined && commandWindows !== null && typeof commandWindows !== "string" || timeout !== undefined && timeout !== null && !isCount(timeout) || handler.async !== undefined && typeof handler.async !== "boolean" || statusMessage !== undefined && statusMessage !== null && typeof statusMessage !== "string" || additionalContextLimit !== undefined && additionalContextLimit !== null && !isCount(additionalContextLimit))
+          return { unknown: `a ${event} hook has a field Codex would not read` };
+        const chosen = platform === "win32" ? commandWindows ?? command : command;
+        if (!chosen.trim())
+          return { unknown: `a ${event} hook has an empty command` };
+        const given = timeout ?? undefined;
+        const seconds = SHORT.has(event) ? Math.min(Math.max(given ?? 1, 1), 3) : Math.max(given ?? 600, 1);
+        const limit = CONTEXT.has(event) && additionalContextLimit != null && additionalContextLimit !== DEFAULT_CONTEXT_LIMIT ? additionalContextLimit : undefined;
+        const normalized = {
+          type: "command",
+          command: chosen,
+          timeout: seconds,
+          async: handler.async === true
+        };
+        if (typeof statusMessage === "string")
+          normalized.statusMessage = statusMessage;
+        if (limit !== undefined)
+          normalized.additionalContextLimit = limit;
+        const identity = { event_name: label, hooks: [normalized] };
+        if (typeof matcher === "string")
+          identity.matcher = matcher;
+        const hash = sha256(canonical(identity));
+        const key = `${pluginId}:${relativePath}:${label}:${g}:${h2}`;
+        const state = states.get(key);
+        const stored = state?.trusted_hash;
+        const trust = stored === undefined ? "untrusted" : stored === hash ? "trusted" : "modified";
+        hooks.push({ key, hash, trust, enabled: state?.enabled !== false });
+      }
+    }
+  }
+  if (!hooks.length)
+    return { unknown: "the hooks file defines no hooks" };
+  return { hooks };
+}
+
 // server/src/panel.ts
 import { stripVTControlCharacters as stripVTControlCharacters2, styleText as styleText2 } from "node:util";
 
 // server/src/text.ts
-import crypto from "node:crypto";
+import crypto2 from "node:crypto";
 var segmenter = new Intl.Segmenter("ja", { granularity: "word" });
 var HIRAGANA_ONLY = /^[\p{Script=Hiragana}ー]+$/u;
 var STOP = new Set(["the", "a", "an", "of", "to", "in", "is", "and", "or", "for", "on", "it", "be"]);
@@ -3109,9 +4213,9 @@ var QUESTION = new Set([
   ...["理由", "仕組", "何", "方", "場合", "今", "件"]
 ]);
 var FOLDED_QUESTION = new Set([...QUESTION].flatMap((w) => terms(w)));
-var sha256 = (s) => crypto.createHash("sha256").update(s).digest();
+var sha2562 = (s) => crypto2.createHash("sha256").update(s).digest();
 function uuidFrom(...parts) {
-  const b = crypto.createHash("sha256").update(parts.join("\x00")).digest().subarray(0, 16);
+  const b = crypto2.createHash("sha256").update(parts.join("\x00")).digest().subarray(0, 16);
   b[6] = (b[6] ?? 0) & 15 | 128;
   b[8] = (b[8] ?? 0) & 63 | 128;
   const h2 = b.toString("hex");
@@ -3469,11 +4573,18 @@ function observe(cwdRoot, platform = process.platform, env = process.env, execPa
   } catch {}
   const codexCache = path2.join(codexHome, "plugins", "cache");
   const codex = [];
+  const markets = [];
   for (const market of safeDirs(codexCache)) {
     for (const v of safeDirs(path2.join(codexCache, market, "sphica"))) {
       codex.push(install(path2.join(codexCache, market, "sphica", v)));
+      markets.push(market);
     }
   }
+  let codexHooks;
+  if (codex.length > 1)
+    codexHooks = { unknown: "more than one Codex cache" };
+  else if (codex[0] && markets[0])
+    codexHooks = codexHookTrust(codex[0].root, `sphica@${markets[0]}`, codexHome, platform, env, execPath);
   let running;
   if (platform === "win32")
     running = { unknown: "not checked on Windows" };
@@ -3527,7 +4638,88 @@ function observe(cwdRoot, platform = process.platform, env = process.env, execPa
     } catch {
       global = { unknown: "npm root -g failed" };
     }
-  return { repository, cli: install(ROOT), global, claude, claudeVersion, codex, codexCache, running };
+  return {
+    repository,
+    cli: install(ROOT),
+    global,
+    claude,
+    claudeVersion,
+    codex,
+    codexCache,
+    codexHooks,
+    running
+  };
+}
+function codexCommand(platform, env, execPath) {
+  if (platform !== "win32")
+    return ["codex", ["--version"]];
+  const exts = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+  for (const dir of (env.PATH ?? env.Path ?? "").split(";").filter(Boolean))
+    for (const ext of exts) {
+      const at = path2.join(dir, `codex${ext.toLowerCase()}`);
+      if (!fs2.existsSync(at))
+        continue;
+      if (ext.toLowerCase() === ".exe")
+        return [at, ["--version"]];
+      const js = path2.join(dir, "node_modules", "@openai", "codex", "bin", "codex.js");
+      return fs2.existsSync(js) ? [execPath, [js, "--version"]] : null;
+    }
+  return null;
+}
+function codexHookTrust(root, pluginId, codexHome, platform, env, execPath) {
+  const command = codexCommand(platform, env, execPath);
+  if (!command)
+    return { unknown: "no codex.exe, or codex.js beside codex.cmd, on PATH" };
+  let version2;
+  try {
+    const out = execFileSync(command[0], command[1], {
+      encoding: "utf8",
+      env,
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e4
+    });
+    version2 = /^codex-cli (\d+\.\d+\.\d+)$/m.exec(out)?.[1];
+  } catch {
+    return { unknown: "codex --version failed" };
+  }
+  if (!version2)
+    return { unknown: "codex --version printed no version" };
+  if (!CODEX_TRUST_VERIFIED.includes(version2))
+    return {
+      unknown: `Codex ${version2}; Sphica reads its hook trust only for ${CODEX_TRUST_VERIFIED.join(", ")}`
+    };
+  let file;
+  try {
+    const manifest = JSON.parse(fs2.readFileSync(path2.join(root, ".codex-plugin", "plugin.json"), "utf8"));
+    if (typeof manifest.hooks !== "string")
+      return { unknown: "the Codex plugin manifest names no hooks file" };
+    file = path2.resolve(root, manifest.hooks);
+  } catch {
+    return { unknown: "the Codex plugin manifest could not be read" };
+  }
+  const relative = path2.relative(root, file);
+  if (!relative || relative.startsWith("..") || path2.isAbsolute(relative))
+    return { unknown: "the hooks file is outside the plugin" };
+  let hooksJson;
+  try {
+    hooksJson = fs2.readFileSync(file, "utf8");
+  } catch {
+    return { unknown: "the hooks file could not be read" };
+  }
+  const config = path2.join(codexHome, "config.toml");
+  let toml;
+  try {
+    toml = fs2.readFileSync(config, "utf8");
+  } catch (e) {
+    if (e.code !== "ENOENT")
+      return { unknown: "config.toml could not be read" };
+    toml = null;
+  }
+  const states = readHookStates(toml);
+  if (!(states instanceof Map))
+    return states;
+  const trust = hookTrust(hooksJson, pluginId, relative.split(path2.sep).join("/"), platform, states);
+  return "unknown" in trust ? trust : { config, hooks: trust.hooks };
 }
 function safeDirs(dir) {
   try {
@@ -3651,6 +4843,29 @@ ${indent}${caution(note)}` : ""}`);
       todo.add("codex");
     row("Codex", x2, note);
   }
+  if (unknown(s.codexHooks))
+    say("none", "Codex hooks", `unknown (${s.codexHooks.unknown}). Check /hooks in Codex`);
+  else if (s.codexHooks) {
+    const { hooks, config } = s.codexHooks;
+    const count = (t2) => hooks.filter((h2) => h2.trust === t2).length;
+    const trusted = count("trusted");
+    const disabled = hooks.filter((h2) => !h2.enabled).length;
+    const summary = `${trusted} of ${hooks.length} trusted in ${short(config)}`;
+    if (trusted === hooks.length && !disabled)
+      say("ok", "Codex hooks", summary);
+    else {
+      const parts = [
+        [count("modified"), "modified"],
+        [count("untrusted"), "untrusted"],
+        [disabled, "disabled"]
+      ].filter(([n2]) => n2);
+      const steps = [
+        trusted < hooks.length ? "open /hooks in Codex and trust Sphica's hooks" : "",
+        disabled ? "enable the disabled ones in /hooks if that was not intended" : ""
+      ].filter(Boolean);
+      say("warn", "Codex hooks", `${summary}; ${parts.map(([n2, w]) => `${n2} ${w}`).join(", ")}. ${steps.join("; ")}`);
+    }
+  }
   const x = s.codex.length === 1 ? s.codex[0] : undefined;
   if (!base && s.claude && !unknown(s.claude) && x && s.claude.version === x.version) {
     if (fs2.existsSync(s.claude.root) && differingFiles(s.claude.root, x.root).length) {
@@ -3799,7 +5014,7 @@ function backups(file = dbFile()) {
 
 // server/src/capture.ts
 import { spawn } from "node:child_process";
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import path8 from "node:path";
 
 // server/node_modules/kysely/dist/util/object-utils.js
@@ -14511,36 +15726,36 @@ class ParseJSONResultsPlugin {
   async transformResult(args) {
     return {
       ...args.result,
-      rows: parseArray(args.result.rows, "$", this.#options)
+      rows: parseArray2(args.result.rows, "$", this.#options)
     };
   }
 }
-function parseArray(arr, jsonPath, options) {
+function parseArray2(arr, jsonPath, options) {
   const target = options.objectStrategy === "create" ? new Array(arr.length) : arr;
   for (let i2 = 0;i2 < arr.length; ++i2) {
-    target[i2] = parse(arr[i2], `${jsonPath}[${i2}]`, options);
+    target[i2] = parse2(arr[i2], `${jsonPath}[${i2}]`, options);
   }
   return target;
 }
-function parse(value, jsonPath, options) {
+function parse2(value, jsonPath, options) {
   if (isString(value)) {
-    return parseString(value, jsonPath, options);
+    return parseString2(value, jsonPath, options);
   }
   if (Array.isArray(value)) {
-    return parseArray(value, jsonPath, options);
+    return parseArray2(value, jsonPath, options);
   }
   if (isPlainObject(value)) {
     return parseObject(value, jsonPath, options);
   }
   return value;
 }
-function parseString(str, jsonPath, options) {
+function parseString2(str, jsonPath, options) {
   const { shouldParse } = options;
   if (!shouldParse(str, jsonPath)) {
     return str;
   }
   try {
-    return parse(JSON.parse(str, (key, value, ...otherArgs) => {
+    return parse2(JSON.parse(str, (key, value, ...otherArgs) => {
       if (key === "__proto__") {
         return;
       }
@@ -14567,7 +15782,7 @@ function parseObject(obj, jsonPath, options) {
     if (key === "__proto__") {
       continue;
     }
-    const parsed = parse(obj[key], `${jsonPath}."${key}"`, options);
+    const parsed = parse2(obj[key], `${jsonPath}."${key}"`, options);
     if (key === "constructor" && isPlainObject(parsed) && Object.hasOwn(parsed, "prototype")) {
       delete parsed.prototype;
     }
@@ -14904,7 +16119,7 @@ var sessionId = (projectId, host, externalId) => uuidFrom(String(projectId), hos
 
 // server/src/project.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import os3 from "node:os";
 import path6 from "node:path";
 
@@ -14913,6 +16128,127 @@ import path5 from "node:path";
 var MAX_BYTES = 2 * 1024 * 1024;
 var leaves = (rel) => rel === ".." || rel.startsWith(`..${path5.sep}`) || path5.isAbsolute(rel);
 
+// server/src/file-lock.ts
+import fs5 from "node:fs";
+var WAIT_MS = 5000;
+var POLL_MS = 40;
+var TRIES = 5;
+var sleep = (ms) => {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+function retryBusy(op) {
+  for (let attempt = 1;; attempt++) {
+    try {
+      op();
+      return;
+    } catch (e) {
+      const code = e.code;
+      if (attempt >= TRIES || !(code === "EPERM" || code === "EACCES" || code === "EBUSY"))
+        throw e;
+      sleep(50 * attempt);
+    }
+  }
+}
+function heldBy(lock) {
+  let holder = 0;
+  try {
+    holder = Number(fs5.readFileSync(lock, "utf8").trim()) || 0;
+  } catch {}
+  if (holder <= 0)
+    return `${lock} is held by another process. Run this again when it finishes.`;
+  try {
+    process.kill(holder, 0);
+  } catch (e) {
+    if (e.code === "ESRCH")
+      return `${lock} is held by process ${holder}, which is not running. If no sphica init is running, delete ${lock} and run this again.`;
+  }
+  return `${lock} is held by process ${holder}. Run this again when it finishes.`;
+}
+function withFileLock(lock, fn, waitMs = WAIT_MS) {
+  const mine = String(process.pid);
+  const until = performance.now() + waitMs;
+  for (;; ) {
+    let fd = null;
+    let refused = null;
+    try {
+      fd = fs5.openSync(lock, "wx");
+    } catch (e) {
+      const code = e.code;
+      if (code === "EPERM" || code === "EACCES" || code === "EBUSY")
+        refused = e;
+      else if (code !== "EEXIST")
+        throw e;
+    }
+    if (fd !== null) {
+      try {
+        try {
+          fs5.writeFileSync(fd, mine);
+        } finally {
+          fs5.closeSync(fd);
+        }
+      } catch (e) {
+        try {
+          retryBusy(() => fs5.rmSync(lock, { force: true }));
+        } catch {}
+        throw e;
+      }
+      break;
+    }
+    if (performance.now() >= until)
+      throw refused ?? new Error(heldBy(lock));
+    sleep(POLL_MS);
+  }
+  let result;
+  try {
+    result = fn();
+  } catch (e) {
+    try {
+      release(lock, mine);
+    } catch {}
+    throw e;
+  }
+  release(lock, mine);
+  return result;
+}
+function release(lock, mine) {
+  const cannot = (e) => new Error(`The work finished, but Sphica could not remove ${lock} (${e.message}). Delete it before running this again.`);
+  let held = "";
+  try {
+    retryBusy(() => {
+      held = fs5.readFileSync(lock, "utf8");
+    });
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return;
+    throw cannot(e);
+  }
+  if (held !== mine)
+    return;
+  try {
+    retryBusy(() => fs5.rmSync(lock, { force: true }));
+  } catch (e) {
+    throw cannot(e);
+  }
+}
+function replaceFile(file, text) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  try {
+    const fd = fs5.openSync(tmp, "w");
+    try {
+      fs5.writeFileSync(fd, text);
+      fs5.fsyncSync(fd);
+    } finally {
+      fs5.closeSync(fd);
+    }
+    retryBusy(() => fs5.renameSync(tmp, file));
+  } catch (e) {
+    try {
+      retryBusy(() => fs5.rmSync(tmp, { force: true }));
+    } catch {}
+    throw e;
+  }
+}
+
 // server/src/project.ts
 var localFile = () => path6.join(sphicaHome(), "projects.json");
 var LOCAL_KEY = /^[a-z0-9][a-z0-9._-]*$/;
@@ -14956,7 +16292,7 @@ var git = (dir, ...args) => {
 function localMap() {
   let raw;
   try {
-    raw = fs5.readFileSync(localFile(), "utf8");
+    raw = fs6.readFileSync(localFile(), "utf8");
   } catch (e) {
     if (e.code === "ENOENT")
       return {};
@@ -15003,14 +16339,27 @@ function nameLocal(dir, name) {
   if (place?.key.startsWith("git:"))
     throw new Error(`${place.root} has a git remote, so its key is ${place.key}. Add it without --name.`);
   const root = rootOf(dir);
-  const m = localMap();
-  m[root] = name;
-  fs5.mkdirSync(path6.dirname(localFile()), { recursive: true, mode: 448 });
-  fs5.writeFileSync(localFile(), `${JSON.stringify(m, null, 2)}
+  fs6.mkdirSync(path6.dirname(localFile()), { recursive: true, mode: 448 });
+  withFileLock(`${localFile()}.lock`, () => {
+    const m = localMap();
+    m[root] = name;
+    replaceFile(localFile(), `${JSON.stringify(m, null, 2)}
 `);
+  });
   return { key: `local:${name}`, root, name };
 }
-function localRoots(roots = [path6.join(os3.homedir(), "Projects")]) {
+function underHome(p, homes, api = path6) {
+  for (const h2 of homes) {
+    const rel = api.relative(h2, p);
+    if (rel === "")
+      return "~";
+    if (rel !== ".." && !rel.startsWith(`..${api.sep}`) && !api.isAbsolute(rel))
+      return `~${api.sep}${rel}`;
+  }
+  return p;
+}
+var projectsDir = () => path6.join(os3.homedir(), "Projects");
+function localRoots(roots = [projectsDir()]) {
   const seen = new Map;
   const add = (p) => {
     if (p)
@@ -15019,7 +16368,7 @@ function localRoots(roots = [path6.join(os3.homedir(), "Projects")]) {
   for (const r2 of roots) {
     let entries = [];
     try {
-      entries = fs5.readdirSync(r2, { withFileTypes: true });
+      entries = fs6.readdirSync(r2, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -15028,7 +16377,7 @@ function localRoots(roots = [path6.join(os3.homedir(), "Projects")]) {
         add(identify(path6.join(r2, e.name)));
   }
   for (const [root, name] of Object.entries(localMap())) {
-    if (LOCAL_KEY.test(name) && fs5.existsSync(root))
+    if (LOCAL_KEY.test(name) && fs6.existsSync(root))
       add({ key: `local:${name}`, root, name });
   }
   const found = new Map;
@@ -15061,7 +16410,7 @@ function patchPaths(patch) {
 
 // server/src/worktree.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import path7 from "node:path";
 var MAX_PATHS = 200;
 var git2 = (root, args) => {
@@ -15096,7 +16445,7 @@ function snapshot(root) {
       continue;
     let st;
     try {
-      st = fs6.lstatSync(path7.join(root, p), { throwIfNoEntry: false });
+      st = fs7.lstatSync(path7.join(root, p), { throwIfNoEntry: false });
     } catch {
       st = undefined;
     }
@@ -15174,7 +16523,7 @@ ${z}`,
 function prune(held) {
   let files;
   try {
-    files = fs7.readdirSync(held).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort();
+    files = fs8.readdirSync(held).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort();
   } catch {
     return;
   }
@@ -15182,21 +16531,21 @@ function prune(held) {
   const stale = files.filter((f) => Number(f.split("-")[0]) < cutoff);
   const over = files.slice(0, Math.max(0, files.length - HOLD_MAX));
   for (const f of new Set([...stale, ...over]))
-    fs7.rmSync(path8.join(held, f), { force: true });
+    fs8.rmSync(path8.join(held, f), { force: true });
 }
 function spool(record) {
   const dir = spoolDir();
-  fs7.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs8.mkdirSync(dir, { recursive: true, mode: 448 });
   const name = `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 10)}.json`;
   const tmp = path8.join(dir, `.${name}`);
-  fs7.writeFileSync(tmp, JSON.stringify(record), { mode: 384 });
-  fs7.renameSync(tmp, path8.join(dir, name));
+  fs8.writeFileSync(tmp, JSON.stringify(record), { mode: 384 });
+  fs8.renameSync(tmp, path8.join(dir, name));
 }
 var branchOf = (root) => {
   try {
     const dotgit = path8.join(root, ".git");
-    const gitdir = fs7.statSync(dotgit).isFile() ? path8.resolve(root, fs7.readFileSync(dotgit, "utf8").match(/^gitdir: (.+)$/m)?.[1]?.trim() ?? "") : dotgit;
-    const h2 = fs7.readFileSync(path8.join(gitdir, "HEAD"), "utf8").trim();
+    const gitdir = fs8.statSync(dotgit).isFile() ? path8.resolve(root, fs8.readFileSync(dotgit, "utf8").match(/^gitdir: (.+)$/m)?.[1]?.trim() ?? "") : dotgit;
+    const h2 = fs8.readFileSync(path8.join(gitdir, "HEAD"), "utf8").trim();
     return h2.startsWith("ref: refs/heads/") ? h2.slice("ref: refs/heads/".length) : null;
   } catch {
     return null;
@@ -15218,7 +16567,7 @@ var INJECTED = [
   /^(?:\d+ background agents were stopped by the user:|Background agent ".*" was stopped by the user\.)/,
   /^(?:Another Claude|A peer) session sent a message(?: while you were working)?:/
 ];
-var digest = (s) => sha256(s).toString("hex").slice(0, 16);
+var digest = (s) => sha2562(s).toString("hex").slice(0, 16);
 function answersOf(input) {
   const response = input.tool_response;
   const answers = response?.answers;
@@ -15242,7 +16591,7 @@ Notes: ${notes.trim()}` : "";
   };
 }
 function captureNotice(file = dbFile()) {
-  if (!fs7.existsSync(file))
+  if (!fs8.existsSync(file))
     return panel("sphica: no database, so conversations are not recorded", [file], "Create it with sphica init");
   const s = readState();
   if (s.stuck)
@@ -15259,7 +16608,7 @@ var isStart = (v) => {
 };
 function readStart(file) {
   try {
-    const s = JSON.parse(fs7.readFileSync(file, "utf8"));
+    const s = JSON.parse(fs8.readFileSync(file, "utf8"));
     return isStart(s) ? s : null;
   } catch {
     return null;
@@ -15268,7 +16617,7 @@ function readStart(file) {
 function readStarts(dir) {
   let names;
   try {
-    names = fs7.readdirSync(dir);
+    names = fs8.readdirSync(dir);
   } catch (e) {
     return e.code === "ENOENT" ? [] : null;
   }
@@ -15291,10 +16640,10 @@ function newestTurn(starts) {
   return at.length === 1 ? at[0]?.turn ?? null : null;
 }
 function writeStart(dir, s, file = startFile(dir, s.turn)) {
-  fs7.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs8.mkdirSync(dir, { recursive: true, mode: 448 });
   const tmp = path8.join(dir, `.${path8.basename(file)}.${process.pid}.tmp`);
-  fs7.writeFileSync(tmp, JSON.stringify(s), { mode: 384 });
-  fs7.renameSync(tmp, file);
+  fs8.writeFileSync(tmp, JSON.stringify(s), { mode: 384 });
+  fs8.renameSync(tmp, file);
 }
 function openTurn(dir, turn, root) {
   if (readStart(startFile(dir, turn))?.running)
@@ -15324,22 +16673,22 @@ function stopTurn(dir, turn) {
 }
 function pruneBaselines() {
   const cutoff = Date.now() - HOLD_DAYS * 24 * 60 * 60 * 1000;
-  const fresh = (file) => (fs7.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? Date.now()) >= cutoff;
+  const fresh = (file) => (fs8.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? Date.now()) >= cutoff;
   let names;
   try {
-    names = fs7.readdirSync(baselineDir());
+    names = fs8.readdirSync(baselineDir());
   } catch {
     return;
   }
   for (const name of names) {
     const at = path8.join(baselineDir(), name);
-    if (!fs7.statSync(at, { throwIfNoEntry: false })?.isDirectory()) {
+    if (!fs8.statSync(at, { throwIfNoEntry: false })?.isDirectory()) {
       if (!fresh(at))
-        fs7.rmSync(at, { force: true });
+        fs8.rmSync(at, { force: true });
     } else {
-      const files = fs7.readdirSync(at);
+      const files = fs8.readdirSync(at);
       if (files.length && !files.some((f) => fresh(path8.join(at, f))))
-        fs7.rmSync(at, { recursive: true, force: true });
+        fs8.rmSync(at, { recursive: true, force: true });
     }
   }
 }
@@ -15358,7 +16707,7 @@ function onHook(host, input) {
       return { flush: false };
     const file = process.env.CLAUDE_ENV_FILE;
     if (file && input.session_id && /^[A-Za-z0-9_-]+$/.test(input.session_id)) {
-      fs7.appendFileSync(file, `export SPHICA_PARENT_SESSION=${input.session_id}
+      fs8.appendFileSync(file, `export SPHICA_PARENT_SESSION=${input.session_id}
 `);
     }
     attempt(pruneBaselines);
@@ -15440,13 +16789,13 @@ function onHook(host, input) {
 }
 function writeState(s) {
   try {
-    fs7.writeFileSync(stateFile(), JSON.stringify(s));
+    fs8.writeFileSync(stateFile(), JSON.stringify(s));
   } catch {}
 }
 function readState() {
   const count = (dir) => {
     try {
-      return fs7.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).length;
+      return fs8.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).length;
     } catch {
       return 0;
     }
@@ -15458,7 +16807,7 @@ function readState() {
   };
   let raw = {};
   try {
-    const parsed = JSON.parse(fs7.readFileSync(stateFile(), "utf8"));
+    const parsed = JSON.parse(fs8.readFileSync(stateFile(), "utf8"));
     if (parsed && typeof parsed === "object")
       raw = parsed;
   } catch {}
@@ -15473,24 +16822,24 @@ function readState() {
 }
 function lock() {
   const file = path8.join(spoolDir(), ".lock");
-  fs7.mkdirSync(spoolDir(), { recursive: true, mode: 448 });
+  fs8.mkdirSync(spoolDir(), { recursive: true, mode: 448 });
   for (let attempt2 = 0;attempt2 < 2; attempt2++) {
     try {
-      fs7.writeFileSync(file, String(process.pid), { flag: "wx", mode: 384 });
+      fs8.writeFileSync(file, String(process.pid), { flag: "wx", mode: 384 });
       return () => {
         try {
-          if (fs7.readFileSync(file, "utf8") === String(process.pid))
-            fs7.rmSync(file, { force: true });
+          if (fs8.readFileSync(file, "utf8") === String(process.pid))
+            fs8.rmSync(file, { force: true });
         } catch {}
       };
     } catch (e) {
       if (e.code !== "EEXIST")
         throw e;
     }
-    const st = fs7.statSync(file, { throwIfNoEntry: false });
+    const st = fs8.statSync(file, { throwIfNoEntry: false });
     if (!st)
       continue;
-    const holder = Number(fs7.readFileSync(file, "utf8") || 0);
+    const holder = Number(fs8.readFileSync(file, "utf8") || 0);
     const fresh = Date.now() - st.mtimeMs < 5 * 60000;
     const alive = (() => {
       if (holder <= 0)
@@ -15503,7 +16852,7 @@ function lock() {
     })();
     if (alive && fresh)
       return null;
-    fs7.rmSync(file, { force: true });
+    fs8.rmSync(file, { force: true });
   }
   return null;
 }
@@ -15575,7 +16924,7 @@ async function write(db, batch) {
         truncated: x.m.truncated ? 1 : 0,
         redacted: x.m.redacted ? 1 : 0,
         original_bytes: x.m.originalBytes,
-        content_hash: sha256(x.m.body)
+        content_hash: sha2562(x.m.body)
       }))).execute();
     const after = await present();
     const edits = batch.flatMap((r2) => {
@@ -15602,7 +16951,7 @@ var REJECTED = new Set([18, 19, 20, 25]);
 var rejected = (e) => REJECTED.has(sqliteCode(e) ?? -1);
 var queued = (from) => {
   try {
-    return fs7.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort().map((name) => ({ name, from }));
+    return fs8.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort().map((name) => ({ name, from }));
   } catch {
     return [];
   }
@@ -15613,16 +16962,16 @@ async function sendBatch(db, names) {
   for (const { name, from } of names) {
     let r2;
     try {
-      r2 = current(JSON.parse(fs7.readFileSync(path8.join(from, name), "utf8")));
+      r2 = current(JSON.parse(fs8.readFileSync(path8.join(from, name), "utf8")));
     } catch {
-      fs7.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-      fs7.renameSync(path8.join(from, name), path8.join(rejectedDir(), name));
+      fs8.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+      fs8.renameSync(path8.join(from, name), path8.join(rejectedDir(), name));
       continue;
     }
     if (r2)
       records.push({ name, from, r: r2 });
     else
-      fs7.rmSync(path8.join(from, name), { force: true });
+      fs8.rmSync(path8.join(from, name), { force: true });
   }
   let sent = 0;
   let strayed = [];
@@ -15648,10 +16997,10 @@ async function sendBatch(db, names) {
     }
   }
   if (bad.length) {
-    fs7.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+    fs8.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
     for (const x of bad) {
       try {
-        fs7.renameSync(path8.join(x.from, x.name), path8.join(rejectedDir(), x.name));
+        fs8.renameSync(path8.join(x.from, x.name), path8.join(rejectedDir(), x.name));
       } catch (e) {
         if (e.code !== "ENOENT")
           throw e;
@@ -15659,12 +17008,12 @@ async function sendBatch(db, names) {
     }
   }
   if (strayed.length) {
-    fs7.mkdirSync(held, { recursive: true, mode: 448 });
+    fs8.mkdirSync(held, { recursive: true, mode: 448 });
     for (const x of strayed) {
       if (x.from === held)
         continue;
       try {
-        fs7.renameSync(path8.join(x.from, x.name), path8.join(held, x.name));
+        fs8.renameSync(path8.join(x.from, x.name), path8.join(held, x.name));
       } catch (e) {
         if (e.code !== "ENOENT")
           throw e;
@@ -15674,7 +17023,7 @@ async function sendBatch(db, names) {
   const moved = new Set([...bad, ...strayed].map((x) => x.name));
   for (const x of records)
     if (!moved.has(x.name))
-      fs7.rmSync(path8.join(x.from, x.name), { force: true });
+      fs8.rmSync(path8.join(x.from, x.name), { force: true });
   return { sent, rejected: bad.length };
 }
 async function flush(file = dbFile(), budgetMs = FLUSH_BUDGET_MS) {
@@ -16134,7 +17483,7 @@ var STOP2 = "sphica_migration_stop";
 var NOTE = "sphica_migration_note";
 var KEEP2 = 3;
 function backUp(raw, file, from) {
-  fs8.mkdirSync(backupDir(file), { recursive: true, mode: 448 });
+  fs9.mkdirSync(backupDir(file), { recursive: true, mode: 448 });
   const done = backupPath(file, from);
   const partial = `${done}.partial`;
   try {
@@ -16150,10 +17499,10 @@ function backUp(raw, file, from) {
     } finally {
       look.close();
     }
-    fs8.renameSync(partial, done);
+    fs9.renameSync(partial, done);
   } catch (e) {
     for (const f of [partial, `${partial}-wal`, `${partial}-shm`])
-      fs8.rmSync(f, { force: true });
+      fs9.rmSync(f, { force: true });
     throw new Error(`Could not back up ${file} before migrating it, so nothing was migrated (${e.message}). Check free space in ${backupDir(file)}.`);
   }
   return done;
@@ -16167,7 +17516,7 @@ function prune2(file, kept) {
   }
   for (const old of all.filter((b) => b !== kept).slice(KEEP2 - 1))
     try {
-      fs8.rmSync(old, { force: true });
+      fs9.rmSync(old, { force: true });
     } catch {}
 }
 var versionOf = (raw) => raw.prepare("pragma user_version").get().user_version;
@@ -16259,20 +17608,20 @@ function migrate(file = dbFile(), dir = MIGRATIONS()) {
     try {
       for (let r2 = from + 1;r2 <= SCHEMA_REVISION; r2++) {
         const script = MIGRATION(dir, r2);
-        if (!fs8.existsSync(script))
+        if (!fs9.existsSync(script))
           throw new Error(`This Sphica has no migration script for revision ${r2} (${script} is missing). Reinstall sphica (\`npm i -g sphica@${packageVersionAt(ROOT) ?? "latest"}\`), then run \`sphica init\` again.`);
         raw.exec("pragma foreign_keys = off");
         try {
           const notes = immediate(raw, () => {
             if (versionOf(raw) !== r2 - 1)
               return [];
-            if (fs8.existsSync(CHECK(dir, r2))) {
-              raw.exec(fs8.readFileSync(CHECK(dir, r2), "utf8"));
+            if (fs9.existsSync(CHECK(dir, r2))) {
+              raw.exec(fs9.readFileSync(CHECK(dir, r2), "utf8"));
               const stops = taken(raw, STOP2);
               if (stops.length)
                 throw new Stop(r2, stops);
             }
-            raw.exec(fs8.readFileSync(script, "utf8"));
+            raw.exec(fs9.readFileSync(script, "utf8"));
             if (r2 === 10)
               judgeEveryRecord(raw);
             const broken = raw.prepare("pragma foreign_key_check").all().length;
@@ -16297,7 +17646,7 @@ ${e.list}` : "";
       if (now === from) {
         let left = "the backup made for this run was removed";
         try {
-          fs8.rmSync(backup, { force: true });
+          fs9.rmSync(backup, { force: true });
         } catch {
           left = `the backup made for this run is still at ${backup}; delete it yourself`;
         }
@@ -16314,7 +17663,7 @@ ${e.list}` : "";
   });
 }
 function dbInit(file = dbFile()) {
-  if (fs8.existsSync(file)) {
+  if (fs9.existsSync(file)) {
     const look = new DatabaseSync3(file, { readOnly: true });
     let generation;
     try {
@@ -16335,27 +17684,32 @@ function dbInit(file = dbFile()) {
     }
     return;
   }
-  fs8.mkdirSync(path9.dirname(file), { recursive: true, mode: 448 });
+  fs9.mkdirSync(path9.dirname(file), { recursive: true, mode: 448 });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs8.rmSync(tmp, { force: true });
+  fs9.rmSync(tmp, { force: true });
   try {
     withOwner(tmp, (raw) => {
       raw.exec("pragma journal_mode = wal");
-      raw.exec(fs8.readFileSync(SCHEMA(), "utf8"));
+      raw.exec(fs9.readFileSync(SCHEMA(), "utf8"));
       if (versionOf(raw) !== SCHEMA_REVISION)
         throw new Error(`db/schema.sql has user_version ${versionOf(raw)}, but the code expects ${SCHEMA_REVISION}`);
       optimize(raw);
     }, true);
-    try {
-      fs8.linkSync(tmp, file);
-    } catch (e) {
-      if (e.code === "EEXIST" || fs8.existsSync(file))
-        throw new Error(`${file} already exists (another sphica init created it first). Run this again to check it.`);
-      fs8.renameSync(tmp, file);
-    }
+    const taken2 = () => new Error(`${file} already exists (another sphica init created it first). Run this again to check it.`);
+    withFileLock(`${file}.init.lock`, () => {
+      if (fs9.existsSync(file))
+        throw taken2();
+      try {
+        fs9.linkSync(tmp, file);
+      } catch (e) {
+        if (e.code === "EEXIST")
+          throw taken2();
+        fs9.renameSync(tmp, file);
+      }
+    });
   } finally {
     for (const f of [tmp, `${tmp}-wal`, `${tmp}-shm`])
-      fs8.rmSync(f, { force: true });
+      fs9.rmSync(f, { force: true });
   }
   say(`Created: ${file} (revision ${SCHEMA_REVISION})`);
 }
@@ -16391,7 +17745,7 @@ function reindex(file = dbFile()) {
   say(`Rebuilt the index: ${plural(counts.units, "unit")}, ${plural(counts.sources, "source")}`);
 }
 function inspect(file = dbFile()) {
-  const size = (f) => fs8.existsSync(f) ? fs8.statSync(f).size : 0;
+  const size = (f) => fs9.existsSync(f) ? fs9.statSync(f).size : 0;
   return withOwner(file, (raw) => {
     const check = (table) => {
       try {
@@ -17115,7 +18469,7 @@ async function doctor(cwd) {
   let usable2 = false;
   if (!runtime)
     say2("none", "DB", "cannot check until Node is upgraded");
-  else if (!fs9.existsSync(file))
+  else if (!fs10.existsSync(file))
     say2("fail", "DB", `missing (${file}). Create it with sphica init`);
   else {
     try {
@@ -17139,7 +18493,12 @@ async function doctor(cwd) {
         const twice = await db.selectFrom("unit").select("project_id").where("lifecycle", "in", ["active", "candidate"]).groupBy(["project_id", "content_hash"]).having((eb) => eb.fn.countAll(), ">", 1).execute();
         if (twice.length)
           say2("warn", "Records", `${plural(twice.length, "set")} of live records hold the same words. Read them with Sphica's read and withdraw the extra ones with /sphica:glean`);
-        const { found } = localRoots();
+        const { found, ambiguous } = localRoots();
+        const homes = [os4.homedir()];
+        try {
+          homes.push(fs10.realpathSync.native(os4.homedir()));
+        } catch {}
+        const tilde = (p) => underHome(p, homes);
         const rows = await db.selectFrom("project as p").select((eb) => [
           "p.key",
           "p.name",
@@ -17150,7 +18509,8 @@ async function doctor(cwd) {
           console.log(section("Projects", true));
         const column = Math.max(...rows.map((x) => width(inline(x.name)))) + 2;
         for (const x of rows) {
-          const where = found.get(x.key) ? "" : " (not on this machine)";
+          const copies = ambiguous.get(x.key);
+          const where = copies ? ` (${copies.length} copies: ${copies.map((c) => inline(tilde(c))).sort().join(", ")})` : found.get(x.key) ? "" : ` (not found in ${inline(tilde(projectsDir()))} or the named projects)`;
           console.log(indent(`  ${mark("none")} ${pad(inline(x.name), column)}${plural(Number(x.records ?? 0), "record")}${x.extracted ? ` / last extraction ${new Date(x.extracted).toLocaleString("sv-SE")}` : ""}${where}`));
         }
       });
@@ -17195,7 +18555,7 @@ async function bindGitHub() {
 }
 async function init(flags) {
   const cwd = flags.cwd ?? process.cwd();
-  if (!fs9.statSync(cwd, { throwIfNoEntry: false })?.isDirectory())
+  if (!fs10.statSync(cwd, { throwIfNoEntry: false })?.isDirectory())
     throw new Error(`${cwd} is not a directory`);
   const found = identify(cwd);
   if (flags.name !== undefined) {
@@ -17234,7 +18594,7 @@ async function uninstall(yes) {
   await boxed("sphica uninstall", async () => {
     if (process.env.SPHICA_HOME)
       throw new Error("SPHICA_HOME is set; uninstall deletes only ~/.sphica. Unset SPHICA_HOME and run it again");
-    if (!fs9.existsSync(home))
+    if (!fs10.existsSync(home))
       console.log(indent(`${mark("none")} ${home} does not exist`));
     else {
       if (!yes) {
@@ -17246,7 +18606,7 @@ async function uninstall(yes) {
         if (isCancel(answer) || !answer)
           return "cancelled";
       }
-      fs9.rmSync(home, { recursive: true, force: true });
+      fs10.rmSync(home, { recursive: true, force: true });
       console.log(indent(`${mark("ok")} deleted ${home}`));
     }
     if (where.length > 1)