@wingsky-1/dsh-decision-gateway 0.2.6

package/lib/index.js

@@ -0,0 +1,3142 @@
+import { createRequire as __decisionGatewayRequire } from "node:module";
+const require = __decisionGatewayRequire(import.meta.url);
+
+// lib/shared/contract.js
+var PACKAGE_DIR = "@wingsky-1/dsh-decision-gateway";
+var CONFIG_VERSION = 1;
+var TEMPLATE_VERSION = 1;
+var JEV_BASE_URL = "https://api.typesafe.ai/v1/systemone";
+if (JEV_BASE_URL !== "https://api.typesafe.ai/v1/systemone") {
+  throw new Error("dsh-decision-gateway: JEV_BASE_URL 被篡改，拒绝加载");
+}
+var JEV_MODEL = "jev-latest";
+if (JEV_MODEL !== "jev-latest") {
+  throw new Error("dsh-decision-gateway: JEV_MODEL 被篡改，拒绝加载");
+}
+var CONFIG_FILE_NAME = "config.json";
+var PRESETS_FILE_NAME = "presets.json";
+var SECRETS_FILE_NAME = "secrets.json";
+var CUSTOM_PRESETS_FILE_NAME = "custom-presets.json";
+var VERSION_FILE_NAME = "VERSION";
+var ROUTES = {
+  health: "/api/dsh-decision-gateway/health",
+  config: "/api/dsh-decision-gateway/config",
+  presets: "/api/dsh-decision-gateway/presets",
+  history: "/api/dsh-decision-gateway/history",
+  testConnection: "/api/dsh-decision-gateway/test-connection"
+};
+var API_KEY_REF_RE = /^[A-Z][A-Z0-9_]{1,63}$/;
+var PRESET_ID_RE = /^[a-z0-9-]{1,64}$/;
+var QUESTION_ID_RE = /^[a-z0-9-]{1,64}$/;
+var SESSION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
+var CJK_RE = /[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/;
+var RETIRED_KEYS = ["baseUrl", "apiBaseUrl", "endpoint", "apiEndpoint", "url"];
+var MAX_QUESTION_TEXT = 255;
+var MAX_QUESTIONS = 20;
+var SNIPPET_MAX = 200;
+var FROZEN_PRESETS = [
+  {
+    id: "general",
+    label: "general",
+    description: "Goal: teach callers how to ask a 2-10-candidate choice question over comparable options. Dimensions: option completeness, comparability, single conclusion. Mutual exclusion: the verdict must be one of the caller-supplied candidates, never an outside candidate and never an abstention. Good asking: background in state.text plus reachable, comparable candidates via questions_override (unique ids, 2-10 options per choice question). Bad asking: listing phenomena with no candidates, which forces a restating non-answer. Prohibitions: no preset questions; no outside-candidate verdicts; no restating without deciding. How to call: state.text carries background, questions_override carries the candidates.",
+    defaultEnabled: true,
+    automationCap: 2
+  },
+  {
+    id: "secret-leak",
+    label: "secret-leak",
+    description: "Goal: teach callers how to ask whether a text contains a real secret that must not leave the device. Dimensions: secret-shape match, surrounding semantics, certainty grading. Mutual exclusion: a local shape hit goes straight to human review with no automated verdict. Good asking: put the text under review in state.text with leak/clean candidates; genuine key shapes yield leak and human handoff. Bad asking: asking about key-management concepts in general yields clean. Prohibitions: never store real secret examples in templates; never judge concept discussion as a leak; never let secret text leave the device. How to call: state.text carries the text under review (any language), candidates are leak/clean. Disabled by default.",
+    defaultEnabled: false,
+    automationCap: 0
+  },
+  {
+    id: "plan-review",
+    label: "plan-review",
+    description: "Goal: teach callers how to ask a 1-5 plan rating question. Dimensions: completeness, feasibility, risk exposure. Mutual exclusion: score only, no go/no-go decision; the score never substitutes for a proceed decision. Good asking: per-dimension sub-scores rolled up into a total, e.g. landing at 4/5. Bad asking: demanding a total with no dimensions. Prohibitions: no preset plans in templates. How to call: state.text carries the plan, questions_override carries one score question (no options allowed).",
+    defaultEnabled: true,
+    automationCap: 1
+  },
+  {
+    id: "risk-check",
+    label: "risk-check",
+    description: "Goal: teach callers how to ask a binary proceed-or-not question. Dimensions: safety, compliance, reversibility. Mutual exclusion: safe/risky only, no middle state. Good asking: all three dimensions pass, verdict safe. Bad asking: judging safe while one dimension is doubtful. Prohibitions: no preset checklists in templates; never substitute hand-waving for a dimension verdict. How to call: state.text carries the change, candidates safe/risky come from the caller.",
+    defaultEnabled: true,
+    automationCap: 1
+  },
+  {
+    id: "custom",
+    label: "custom",
+    description: "Goal: the caller brings the full question set (1-20 questions); the template presets nothing. Mutual exclusion: questions_override is required and must be non-empty. Good calling: the first question drives the verdict; extra questions travel as context. Bad calling: empty questions are rejected outright. Prohibitions: no execution without questions; never rewrite caller questions. How to call: preset_id custom plus a full questions_override (unique ids, choice carries options, score carries none).",
+    defaultEnabled: true,
+    automationCap: 2
+  }
+];
+var CUSTOM_PRESETS_VERSION = 1;
+var MAX_CUSTOM_PRESETS = 50;
+var MAX_CUSTOM_LABEL = 64;
+var MAX_CUSTOM_DESCRIPTION = 2e3;
+function frozenPresetOf(id) {
+  for (const preset of FROZEN_PRESETS) {
+    if (preset.id === id)
+      return preset;
+  }
+  return void 0;
+}
+var ALL_CAPS_REJECT_MIN_LEN = 20;
+var ALL_CAPS_RUN_RE = /^[A-Z0-9_]+$/;
+function hasExposedPrefix(key) {
+  return key.startsWith("AKIA") || key.startsWith("ASIA");
+}
+function rejectAllCapsLongRun(key) {
+  if (key.length < ALL_CAPS_REJECT_MIN_LEN)
+    return false;
+  if (!ALL_CAPS_RUN_RE.test(key))
+    return false;
+  if (hasExposedPrefix(key))
+    return true;
+  return /[A-Z]/.test(key) && /[0-9]/.test(key);
+}
+function keyShapeCategory(key) {
+  if (key.length === 0)
+    return "empty";
+  if (key.length < 16)
+    return "too-short";
+  if (key.length > 256 || !/^[A-Za-z0-9._~-]+$/.test(key))
+    return "charset";
+  if (!/[A-Za-z]/.test(key))
+    return "charset";
+  if (rejectAllCapsLongRun(key))
+    return "charset";
+  return null;
+}
+function truncateCodePoints(text, budget) {
+  const points = Array.from(text);
+  if (points.length <= budget)
+    return { text, truncated: false, originalLength: points.length };
+  return { text: points.slice(0, budget).join(""), truncated: true, originalLength: points.length };
+}
+function containsCjk(text) {
+  return CJK_RE.test(text);
+}
+
+// ../../shared/loopback.js
+function isLoopbackRequest(request, options = {}) {
+  const address = request.socket?.remoteAddress;
+  if (address !== "127.0.0.1" && address !== "::1" && address !== "::ffff:127.0.0.1") return false;
+  const host = request.headers.host;
+  if (typeof host !== "string") return false;
+  let hostUrl;
+  try {
+    hostUrl = new URL(`http://${host}`);
+  } catch {
+    return false;
+  }
+  if (hostUrl.hostname !== "127.0.0.1" && hostUrl.hostname !== "localhost" && hostUrl.hostname !== "[::1]")
+    return false;
+  if (request.headers["sec-fetch-site"] === "cross-site") {
+    if (!(options.allowCrossSiteNoCors === true && request.headers["sec-fetch-mode"] === "no-cors")) {
+      return false;
+    }
+  }
+  const origin = request.headers.origin;
+  if (origin === void 0) return true;
+  try {
+    return new URL(origin).host === hostUrl.host;
+  } catch {
+    return false;
+  }
+}
+
+// lib/server/api/impl/route.js
+function sendJson(res, status, body) {
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store"
+  });
+  res.end(JSON.stringify(body));
+}
+function sendFailure(res, status, errorCode, category, message) {
+  sendJson(res, status, { ok: false, error: { errorCode, category, message } });
+}
+function registerEndpoints(register, endpoints, logger) {
+  const disposers = [];
+  for (const endpoint of endpoints) {
+    disposers.push(register({
+      kind: "exact",
+      path: endpoint.path,
+      handler: (req, res) => {
+        if (!isLoopbackRequest(req)) {
+          sendFailure(res, 403, "FORBIDDEN_LOOPBACK", "loopback-only", "forbidden: loopback-only");
+          return;
+        }
+        const handle = endpoint.methods[req.method ?? ""];
+        if (handle === void 0) {
+          res.writeHead(405, {
+            "content-type": "application/json; charset=utf-8",
+            allow: Object.keys(endpoint.methods).join(", ")
+          });
+          res.end(JSON.stringify({
+            ok: false,
+            error: {
+              errorCode: "METHOD_NOT_ALLOWED",
+              category: "method-not-allowed",
+              message: "method not allowed"
+            }
+          }));
+          return;
+        }
+        try {
+          const done = handle(req, res);
+          if (done instanceof Promise) {
+            done.catch((cause) => reportFailure(res, logger, cause));
+          }
+        } catch (cause) {
+          reportFailure(res, logger, cause);
+        }
+      }
+    }));
+  }
+  return disposers;
+}
+function reportFailure(res, logger, cause) {
+  const reason = cause instanceof Error ? cause.message : String(cause);
+  logger.warn("dsh-decision-gateway: 端点处理失败 —— " + reason);
+  if (!res.headersSent)
+    sendFailure(res, 500, "INTERNAL", "internal", reason);
+}
+
+// lib/server/api/impl/handlers.js
+var MAX_BODY_BYTES = 64 * 1024;
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        reject(new Error("body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      const text = Buffer.concat(chunks).toString("utf8").trim();
+      if (text.length === 0) {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(text));
+      } catch {
+        reject(new Error("body not JSON"));
+      }
+    });
+    req.on("error", (cause) => reject(cause instanceof Error ? cause : new Error(String(cause))));
+  });
+}
+function queryOf(req) {
+  const raw = req.url ?? "/";
+  return new URL(raw, "http://127.0.0.1").searchParams;
+}
+function numParam(params, key) {
+  const raw = params.get(key);
+  if (raw === null || raw === "")
+    return void 0;
+  const num = Number(raw);
+  return Number.isFinite(num) ? num : void 0;
+}
+function buildEndpoints(ports) {
+  return [
+    {
+      path: ROUTES.health,
+      methods: {
+        GET: (_req, res) => {
+          sendJson(res, 200, {
+            ok: true,
+            version: ports.version(),
+            templateVersion: TEMPLATE_VERSION
+          });
+        }
+      }
+    },
+    {
+      path: ROUTES.config,
+      methods: {
+        GET: (_req, res) => {
+          sendJson(res, 200, ports.readConfig());
+        },
+        PUT: (req, res) => {
+          readJsonBody(req).then((body) => {
+            try {
+              sendJson(res, 200, ports.writeConfig(body));
+            } catch (cause) {
+              const failure = asFailure(cause);
+              sendFailure(res, failure.status, failure.errorCode, failure.category, failure.message);
+            }
+          }, () => sendFailure(res, 400, "INVALID_BODY", "bad-request", "body must be JSON <=64KB")).catch(() => sendFailure(res, 500, "INTERNAL", "internal", "unreachable"));
+        }
+      }
+    },
+    {
+      path: ROUTES.presets,
+      methods: {
+        GET: (_req, res) => {
+          sendJson(res, 200, { ok: true, presets: ports.readPresets() });
+        }
+      }
+    },
+    {
+      path: ROUTES.history,
+      methods: {
+        GET: (req, res) => {
+          try {
+            const params = queryOf(req);
+            const entries = ports.readHistory({
+              root: params.get("root") ?? void 0,
+              sessionId: params.get("sessionId") ?? void 0,
+              limit: numParam(params, "limit")
+            });
+            sendJson(res, 200, { ok: true, entries });
+          } catch (cause) {
+            const failure = asFailure(cause);
+            sendFailure(res, failure.status, failure.errorCode, failure.category, failure.message);
+          }
+        },
+        DELETE: (req, res) => {
+          try {
+            const params = queryOf(req);
+            const removed = ports.removeHistory({
+              root: params.get("root") ?? void 0,
+              sessionId: params.get("sessionId") ?? void 0
+            });
+            sendJson(res, 200, { ok: true, deleted: removed.deleted });
+          } catch (cause) {
+            const failure = asFailure(cause);
+            sendFailure(res, failure.status, failure.errorCode, failure.category, failure.message);
+          }
+        }
+      }
+    },
+    {
+      path: ROUTES.testConnection,
+      methods: {
+        POST: (req, res) => {
+          readJsonBody(req).then((body) => {
+            ports.probeConnection(body).then((probe) => {
+              if (probe.ok)
+                sendJson(res, 200, { ok: true, latencyMs: probe.latencyMs });
+              else
+                sendFailure(res, probeStatus(probe.errorCode), probe.errorCode, probe.category, probe.message);
+            }, (cause) => {
+              const failure = asFailure(cause);
+              sendFailure(res, failure.status, failure.errorCode, failure.category, failure.message);
+            }).catch(() => sendFailure(res, 500, "INTERNAL", "internal", "unreachable"));
+          }, () => sendFailure(res, 400, "INVALID_BODY", "bad-request", "body must be JSON <=64KB")).catch(() => sendFailure(res, 500, "INTERNAL", "internal", "unreachable"));
+        }
+      }
+    }
+  ];
+}
+function asFailure(cause) {
+  const message = cause instanceof Error ? cause.message : String(cause);
+  try {
+    const parsed = JSON.parse(message);
+    if (typeof parsed.status === "number" && typeof parsed.errorCode === "string" && typeof parsed.category === "string" && typeof parsed.message === "string") {
+      return {
+        status: parsed.status,
+        errorCode: parsed.errorCode,
+        category: parsed.category,
+        message: parsed.message
+      };
+    }
+  } catch {
+  }
+  const match = /\[(\d+)\]/.exec(message);
+  if (match !== null) {
+    const status = Number(match[1]);
+    return {
+      status,
+      errorCode: "BAD_REQUEST",
+      category: "bad-request",
+      message: message.replace(match[0], "").trim()
+    };
+  }
+  return { status: 500, errorCode: "INTERNAL", category: "internal", message };
+}
+function probeStatus(errorCode) {
+  if (errorCode === "NO_KEY" || errorCode === "UNAUTHORIZED")
+    return 401;
+  if (errorCode === "TIMEOUT")
+    return 504;
+  return 502;
+}
+
+// lib/server/api/impl/service.js
+function installApi(deps) {
+  return registerEndpoints(deps.register, buildEndpoints(deps), deps.logger);
+}
+
+// lib/server/config/impl/model.js
+var ALLOWED_PUT_KEYS = [
+  "apiKeyRef",
+  "apiKeyPlaintext",
+  "confirm",
+  "timeoutMs",
+  "maxConcurrency",
+  "truncBudget",
+  "presets",
+  "customPresets",
+  "history"
+];
+function buildDefaultConfig() {
+  return {
+    version: CONFIG_VERSION,
+    connection: { hasPlaintextKey: false, timeoutMs: 8e3, maxConcurrency: 4, truncBudget: 32e3 },
+    presets: FROZEN_PRESETS.map((preset) => ({
+      id: preset.id,
+      enabled: preset.defaultEnabled,
+      automationCap: preset.automationCap
+    })),
+    history: { perSession: 200, totalSessions: 50 }
+  };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asFinite(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function checkInt(value, min, max) {
+  const num = asFinite(value);
+  if (num === void 0 || !Number.isInteger(num) || num < min || num > max)
+    return void 0;
+  return num;
+}
+function normalizeLoadedConfig(raw) {
+  const fallback = buildDefaultConfig();
+  if (!isRecord(raw))
+    return { config: fallback, retired: [] };
+  const retired = [];
+  const scanScopes = [raw];
+  for (const scope of [raw["connection"], raw["history"]]) {
+    if (isRecord(scope))
+      scanScopes.push(scope);
+  }
+  for (const key of RETIRED_KEYS) {
+    if (scanScopes.some((scope) => key in scope) && !retired.includes(key))
+      retired.push(key);
+  }
+  const connRaw = isRecord(raw["connection"]) ? raw["connection"] : {};
+  const histRaw = isRecord(raw["history"]) ? raw["history"] : {};
+  const presetsRaw = Array.isArray(raw["presets"]) ? raw["presets"] : [];
+  const byId = new Map(fallback.presets.map((entry) => [entry.id, entry]));
+  for (const item of presetsRaw) {
+    if (!isRecord(item) || typeof item["id"] !== "string")
+      continue;
+    const prev = byId.get(item["id"]);
+    if (prev === void 0)
+      continue;
+    const enabled = typeof item["enabled"] === "boolean" ? item["enabled"] : prev.enabled;
+    const cap = item["automationCap"];
+    const automationCap = cap === 0 || cap === 1 || cap === 2 ? cap : prev.automationCap;
+    byId.set(item["id"], { id: prev.id, enabled, automationCap });
+  }
+  const refRaw = connRaw["apiKeyRef"];
+  const apiKeyRef = typeof refRaw === "string" && API_KEY_REF_RE.test(refRaw) ? refRaw : void 0;
+  const timeout = checkInt(connRaw["timeoutMs"], 1e3, 12e4) ?? fallback.connection.timeoutMs;
+  const concurrency = checkInt(connRaw["maxConcurrency"], 1, 16) ?? fallback.connection.maxConcurrency;
+  const budget = checkInt(connRaw["truncBudget"], 1e3, 2e5) ?? fallback.connection.truncBudget;
+  const perSession = checkInt(histRaw["perSession"], 10, 1e3) ?? fallback.history.perSession;
+  const totalSessions = checkInt(histRaw["totalSessions"], 1, 200) ?? fallback.history.totalSessions;
+  return {
+    config: {
+      version: CONFIG_VERSION,
+      connection: {
+        ...apiKeyRef !== void 0 ? { apiKeyRef } : {},
+        hasPlaintextKey: connRaw["hasPlaintextKey"] === true,
+        timeoutMs: timeout,
+        maxConcurrency: concurrency,
+        truncBudget: budget
+      },
+      presets: FROZEN_PRESETS.map((preset) => byId.get(preset.id) ?? {
+        id: preset.id,
+        enabled: preset.defaultEnabled,
+        automationCap: preset.automationCap
+      }),
+      history: { perSession, totalSessions }
+    },
+    retired
+  };
+}
+function validateCustomPresets(raw) {
+  const bad = (errorCode, message) => ({
+    ok: false,
+    failure: { errorCode, category: "bad-request", message }
+  });
+  if (!Array.isArray(raw))
+    return bad("INVALID_CUSTOM", "customPresets must be an array");
+  if (raw.length > MAX_CUSTOM_PRESETS) {
+    return bad("INVALID_CUSTOM", "customPresets holds <=" + MAX_CUSTOM_PRESETS + " entries");
+  }
+  const frozenIds = new Set(FROZEN_PRESETS.map((preset) => preset.id));
+  const seen = /* @__PURE__ */ new Set();
+  const list = [];
+  const now = Date.now();
+  for (const item of raw) {
+    if (!isRecord(item) || typeof item["id"] !== "string") {
+      return bad("INVALID_CUSTOM", "custom preset needs id");
+    }
+    const id = item["id"];
+    if (!PRESET_ID_RE.test(id) || containsCjk(id)) {
+      return bad("BAD_CUSTOM_ID", "custom id must be ASCII a-z0-9- 1..64");
+    }
+    if (frozenIds.has(id)) {
+      return bad("RESERVED_PRESET", "custom id collides with a frozen preset: " + id);
+    }
+    if (seen.has(id))
+      return bad("DUPLICATE_CUSTOM_ID", "custom ids must be unique");
+    seen.add(id);
+    const label = item["label"];
+    if (typeof label !== "string" || label.trim().length === 0 || Array.from(label).length > MAX_CUSTOM_LABEL) {
+      return bad("INVALID_CUSTOM", "custom label must be 1.." + MAX_CUSTOM_LABEL + " chars");
+    }
+    const description = item["description"];
+    if (typeof description !== "string" || description.trim().length === 0 || Array.from(description).length > MAX_CUSTOM_DESCRIPTION) {
+      return bad("INVALID_CUSTOM", "custom description must be 1.." + MAX_CUSTOM_DESCRIPTION + " chars");
+    }
+    if (typeof item["enabled"] !== "boolean") {
+      return bad("INVALID_CUSTOM", "custom entry needs boolean enabled");
+    }
+    const cap = item["automationCap"];
+    if (cap !== 0 && cap !== 1 && cap !== 2) {
+      return bad("INVALID_CUSTOM", "automationCap must be 0|1|2");
+    }
+    const stamp = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.floor(v) : now;
+    list.push({
+      id,
+      label,
+      description,
+      enabled: item["enabled"],
+      automationCap: cap,
+      createdAt: stamp(item["createdAt"]),
+      updatedAt: now
+    });
+  }
+  return { ok: true, list };
+}
+var PUT_INT_FIELDS = [
+  { key: "timeoutMs", min: 1e3, max: 12e4, message: "timeoutMs must be int 1000..120000" },
+  { key: "maxConcurrency", min: 1, max: 16, message: "maxConcurrency must be int 1..16" },
+  { key: "truncBudget", min: 1e3, max: 2e5, message: "truncBudget must be int 1000..200000" }
+];
+var HISTORY_INT_FIELDS = [
+  { key: "perSession", min: 10, max: 1e3, message: "perSession must be int 10..1000" },
+  { key: "totalSessions", min: 1, max: 200, message: "totalSessions must be int 1..200" }
+];
+function putRangedInt(source, field) {
+  const raw = source[field.key];
+  if (raw === void 0)
+    return { ok: true, value: void 0 };
+  const value = checkInt(raw, field.min, field.max);
+  if (value === void 0)
+    return {
+      ok: false,
+      failure: { errorCode: "INVALID_RANGE", category: "bad-request", message: field.message }
+    };
+  return { ok: true, value };
+}
+function checkApiKeyRef(ref) {
+  if (ref === void 0)
+    return { ok: true, value: void 0 };
+  if (ref === null)
+    return { ok: true, value: null };
+  if (typeof ref !== "string" || !API_KEY_REF_RE.test(ref)) {
+    return {
+      ok: false,
+      failure: {
+        errorCode: "INVALID_REF",
+        category: "shape",
+        message: "apiKeyRef must match ^[A-Z][A-Z0-9_]{1,63}$"
+      }
+    };
+  }
+  return { ok: true, value: ref };
+}
+function checkApiKeyPlaintext(plain) {
+  if (plain === void 0)
+    return { ok: true, value: void 0 };
+  if (typeof plain !== "string") {
+    return {
+      ok: false,
+      failure: {
+        errorCode: "INVALID_KEY_SHAPE",
+        category: "charset",
+        message: "apiKeyPlaintext must be a string"
+      }
+    };
+  }
+  const shape = keyShapeCategory(plain);
+  if (shape !== null) {
+    return {
+      ok: false,
+      failure: { errorCode: "INVALID_KEY_SHAPE", category: shape, message: "key shape rejected" }
+    };
+  }
+  return { ok: true, value: plain };
+}
+function isValidCap(cap) {
+  return cap === 0 || cap === 1 || cap === 2;
+}
+function checkPresetsField(value) {
+  if (value === void 0) {
+    return { ok: true, list: void 0 };
+  }
+  if (!Array.isArray(value)) {
+    return {
+      ok: false,
+      failure: {
+        errorCode: "INVALID_PRESETS",
+        category: "bad-request",
+        message: "presets must be an array"
+      }
+    };
+  }
+  const list = [];
+  for (const item of value) {
+    if (!isRecord(item) || typeof item["id"] !== "string") {
+      return {
+        ok: false,
+        failure: {
+          errorCode: "INVALID_PRESETS",
+          category: "bad-request",
+          message: "preset entry needs id"
+        }
+      };
+    }
+    const frozen = FROZEN_PRESETS.find((preset) => preset.id === item["id"]);
+    if (frozen === void 0) {
+      return {
+        ok: false,
+        failure: {
+          errorCode: "UNKNOWN_PRESET",
+          category: "bad-request",
+          message: "unknown preset"
+        }
+      };
+    }
+    if (typeof item["enabled"] !== "boolean") {
+      return {
+        ok: false,
+        failure: {
+          errorCode: "INVALID_PRESETS",
+          category: "bad-request",
+          message: "preset entry needs boolean enabled"
+        }
+      };
+    }
+    const cap = item["automationCap"];
+    if (!isValidCap(cap)) {
+      return {
+        ok: false,
+        failure: {
+          errorCode: "INVALID_PRESETS",
+          category: "bad-request",
+          message: "automationCap must be 0|1|2"
+        }
+      };
+    }
+    list.push({
+      id: item["id"],
+      enabled: item["enabled"],
+      automationCap: cap
+    });
+  }
+  return { ok: true, list };
+}
+function checkHistoryField(value) {
+  if (value === void 0) {
+    return { ok: true, history: void 0 };
+  }
+  if (!isRecord(value)) {
+    return {
+      ok: false,
+      failure: {
+        errorCode: "INVALID_HISTORY",
+        category: "bad-request",
+        message: "history must be an object"
+      }
+    };
+  }
+  const hist = value;
+  const histVals = {};
+  for (const field of HISTORY_INT_FIELDS) {
+    const checked = putRangedInt(hist, field);
+    if (!checked.ok)
+      return checked;
+    if (checked.value !== void 0)
+      histVals[field.key] = checked.value;
+  }
+  const perSession = histVals["perSession"];
+  const totalSessions = histVals["totalSessions"];
+  return {
+    ok: true,
+    history: {
+      ...perSession !== void 0 ? { perSession } : {},
+      ...totalSessions !== void 0 ? { totalSessions } : {}
+    }
+  };
+}
+function checkPutKeys(body) {
+  if (!isRecord(body)) {
+    return {
+      ok: false,
+      failure: {
+        errorCode: "INVALID_BODY",
+        category: "bad-request",
+        message: "body must be an object"
+      }
+    };
+  }
+  for (const key of Object.keys(body)) {
+    if (RETIRED_KEYS.includes(key)) {
+      return {
+        ok: false,
+        failure: {
+          errorCode: "RETIRED_KEY",
+          category: "retired-key",
+          message: "retired key: " + key
+        }
+      };
+    }
+    if (!ALLOWED_PUT_KEYS.includes(key)) {
+      return {
+        ok: false,
+        failure: {
+          errorCode: "UNKNOWN_KEY",
+          category: "unknown-key",
+          message: "unknown key: " + key
+        }
+      };
+    }
+  }
+  return null;
+}
+function checkPutApiKey(body) {
+  if (!isRecord(body))
+    return {
+      ok: false,
+      failure: {
+        errorCode: "INVALID_BODY",
+        category: "bad-request",
+        message: "body must be an object"
+      }
+    };
+  const ref = body["apiKeyRef"];
+  const plain = body["apiKeyPlaintext"];
+  const refChecked = checkApiKeyRef(ref);
+  if (!refChecked.ok)
+    return refChecked;
+  const apiKeyRef = refChecked.value;
+  const plainChecked = checkApiKeyPlaintext(plain);
+  if (!plainChecked.ok)
+    return plainChecked;
+  const apiKeyPlaintext = plainChecked.value;
+  if (apiKeyRef !== void 0 && apiKeyRef !== null && apiKeyPlaintext !== void 0) {
+    return {
+      ok: false,
+      failure: {
+        errorCode: "MUTUALLY_EXCLUSIVE",
+        category: "mutually-exclusive",
+        message: "apiKeyRef and apiKeyPlaintext are mutually exclusive"
+      }
+    };
+  }
+  return { ok: true, apiKeyRef, apiKeyPlaintext };
+}
+function checkPutInts(body) {
+  if (!isRecord(body))
+    return {
+      ok: false,
+      failure: {
+        errorCode: "INVALID_BODY",
+        category: "bad-request",
+        message: "body must be an object"
+      }
+    };
+  const intVals = {};
+  for (const field of PUT_INT_FIELDS) {
+    const checked = putRangedInt(body, field);
+    if (!checked.ok)
+      return checked;
+    if (checked.value !== void 0)
+      intVals[field.key] = checked.value;
+  }
+  return { ok: true, intVals };
+}
+function checkPutCustom(body) {
+  if (!isRecord(body))
+    return {
+      ok: false,
+      failure: {
+        errorCode: "INVALID_BODY",
+        category: "bad-request",
+        message: "body must be an object"
+      }
+    };
+  let customPresets;
+  if (body["customPresets"] !== void 0) {
+    const checked = validateCustomPresets(body["customPresets"]);
+    if (!checked.ok)
+      return checked;
+    customPresets = checked.list;
+  }
+  return { ok: true, customPresets };
+}
+function buildPutPatch(apiKeyRef, apiKeyPlaintext, timeoutMs, maxConcurrency, truncBudget, presets, history, customPresets) {
+  return {
+    ...apiKeyRef !== void 0 ? { apiKeyRef } : {},
+    ...apiKeyPlaintext !== void 0 ? { apiKeyPlaintext } : {},
+    ...timeoutMs !== void 0 ? { timeoutMs } : {},
+    ...maxConcurrency !== void 0 ? { maxConcurrency } : {},
+    ...truncBudget !== void 0 ? { truncBudget } : {},
+    ...presets !== void 0 ? { presets } : {},
+    ...history !== void 0 ? { history } : {},
+    ...customPresets !== void 0 ? { customPresets } : {}
+  };
+}
+function validatePutBody(body) {
+  const keysFailed = checkPutKeys(body);
+  if (keysFailed !== null)
+    return keysFailed;
+  const apiR = checkPutApiKey(body);
+  if (!apiR.ok)
+    return apiR;
+  const apiKeyRef = apiR.apiKeyRef;
+  const apiKeyPlaintext = apiR.apiKeyPlaintext;
+  const intsR = checkPutInts(body);
+  if (!intsR.ok)
+    return intsR;
+  const intVals = intsR.intVals;
+  const timeoutMs = intVals["timeoutMs"];
+  const maxConcurrency = intVals["maxConcurrency"];
+  const truncBudget = intVals["truncBudget"];
+  const checkedPresets = checkPresetsField(body["presets"]);
+  if (!checkedPresets.ok) {
+    return checkedPresets;
+  }
+  const presets = checkedPresets.list;
+  const checkedHistory = checkHistoryField(body["history"]);
+  if (!checkedHistory.ok) {
+    return checkedHistory;
+  }
+  const history = checkedHistory.history;
+  const customR = checkPutCustom(body);
+  if (!customR.ok)
+    return customR;
+  const customPresets = customR.customPresets;
+  return {
+    ok: true,
+    patch: buildPutPatch(apiKeyRef, apiKeyPlaintext, timeoutMs, maxConcurrency, truncBudget, presets, history, customPresets)
+  };
+}
+
+// lib/server/config/impl/envelope.js
+var ENVELOPE_TOP_KEYS = [
+  "version",
+  "connection",
+  "presets",
+  "history",
+  "apiKeyPlaintext",
+  "confirm"
+];
+var CONNECTION_INNER_KEYS = [
+  "apiKeyRef",
+  "timeoutMs",
+  "maxConcurrency",
+  "truncBudget",
+  "hasPlaintextKey"
+];
+function normalizePutEnvelope(body) {
+  if (!isRecord(body)) {
+    return {
+      ok: false,
+      failure: {
+        errorCode: "INVALID_BODY",
+        category: "bad-request",
+        message: "body must be an object"
+      }
+    };
+  }
+  const conn = body["connection"];
+  if (conn === void 0 && body["version"] === void 0)
+    return { ok: true, flat: body };
+  if (conn !== void 0 && !isRecord(conn)) {
+    return {
+      ok: false,
+      failure: {
+        errorCode: "INVALID_BODY",
+        category: "bad-request",
+        message: "connection must be an object"
+      }
+    };
+  }
+  if (body["version"] !== void 0 && body["version"] !== 1) {
+    return {
+      ok: false,
+      failure: {
+        errorCode: "INVALID_VERSION",
+        category: "bad-request",
+        message: "version must be 1"
+      }
+    };
+  }
+  for (const key of Object.keys(body)) {
+    if (RETIRED_KEYS.includes(key)) {
+      return {
+        ok: false,
+        failure: {
+          errorCode: "RETIRED_KEY",
+          category: "retired-key",
+          message: "retired key: " + key
+        }
+      };
+    }
+    if (!ENVELOPE_TOP_KEYS.includes(key) && !ALLOWED_PUT_KEYS.includes(key)) {
+      return {
+        ok: false,
+        failure: {
+          errorCode: "UNKNOWN_KEY",
+          category: "unknown-key",
+          message: "unknown key: " + key
+        }
+      };
+    }
+  }
+  const flat = {};
+  if (isRecord(conn)) {
+    for (const key of Object.keys(conn)) {
+      if (!CONNECTION_INNER_KEYS.includes(key)) {
+        return {
+          ok: false,
+          failure: {
+            errorCode: "UNKNOWN_KEY",
+            category: "unknown-key",
+            message: "unknown connection key: " + key
+          }
+        };
+      }
+      if (key === "hasPlaintextKey")
+        continue;
+      flat[key] = conn[key];
+    }
+  }
+  for (const key of ALLOWED_PUT_KEYS) {
+    if (body[key] !== void 0)
+      flat[key] = body[key];
+  }
+  return { ok: true, flat };
+}
+
+// lib/server/config/impl/service.js
+import { readFileSync } from "node:fs";
+import { dirname, join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// lib/server/config/impl/paths.js
+import { join as join3 } from "node:path";
+
+// ../../shared/dsh-home.js
+import { homedir } from "node:os";
+import { join } from "node:path";
+function userHome() {
+  const env = process.platform === "win32" ? process.env.USERPROFILE ?? process.env.HOME : process.env.HOME;
+  return env !== void 0 && env.trim().length > 0 ? env : homedir();
+}
+function dshHome() {
+  const env = process.env.DSH_HOME;
+  return env !== void 0 && env.trim().length > 0 ? env : join(userHome(), ".dsh");
+}
+
+// ../../shared/paths.js
+import { join as join2 } from "node:path";
+function pluginHome(base, ...segments) {
+  return join2(base, ...segments);
+}
+
+// lib/server/config/impl/paths.js
+function decisionGatewayHome(home) {
+  return pluginHome(home ?? dshHome(), PACKAGE_DIR);
+}
+function configFile(home) {
+  return join3(decisionGatewayHome(home), CONFIG_FILE_NAME);
+}
+function presetsFile(home) {
+  return join3(decisionGatewayHome(home), PRESETS_FILE_NAME);
+}
+function customPresetsFile(home) {
+  return join3(decisionGatewayHome(home), CUSTOM_PRESETS_FILE_NAME);
+}
+function secretsFile(home) {
+  return join3(decisionGatewayHome(home), SECRETS_FILE_NAME);
+}
+function versionFile(home) {
+  return join3(decisionGatewayHome(home), VERSION_FILE_NAME);
+}
+
+// lib/server/config/impl/service.js
+var BASELINE_VERSION = "0.0.0";
+var UNKNOWN_VERSION = "0.0.0";
+function readStoredVersion(home, deps) {
+  const read = deps.io.readTextSync(versionFile(home));
+  if (!read.ok)
+    return BASELINE_VERSION;
+  const text = read.text.trim();
+  return text === "" ? BASELINE_VERSION : text;
+}
+function writeStoredVersion(home, version, deps) {
+  deps.io.atomicWrite0600Sync(versionFile(home), version + "\n");
+}
+function compareVersions(left, right) {
+  const parse = (text) => text.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const a = parse(left);
+  const b = parse(right);
+  const length = Math.max(a.length, b.length);
+  for (let index = 0; index < length; index += 1) {
+    const difference = (a[index] || 0) - (b[index] || 0);
+    if (difference !== 0)
+      return difference > 0 ? 1 : -1;
+  }
+  return 0;
+}
+function pluginVersion() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const manifest = join4(here, "..", "..", "..", "..", "package.json");
+    const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+    return typeof parsed.version === "string" ? parsed.version : UNKNOWN_VERSION;
+  } catch {
+    return UNKNOWN_VERSION;
+  }
+}
+function loadCustomPresets(home, deps) {
+  const raw = deps.io.readJsonSync(customPresetsFile(home));
+  if (!raw.ok)
+    return [];
+  const value = raw.value;
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    deps.logger.warn("dsh-decision-gateway: custom-presets.json 形状非法，已按空列表读");
+    return [];
+  }
+  const list = value["customPresets"];
+  if (!Array.isArray(list)) {
+    deps.logger.warn("dsh-decision-gateway: custom-presets.json 缺 customPresets 数组，已按空列表读");
+    return [];
+  }
+  const checked = validateCustomPresets(list);
+  if (!checked.ok) {
+    deps.logger.warn("dsh-decision-gateway: custom-presets.json 条目非法，已按空列表读（" + checked.failure.errorCode + ")");
+    return [];
+  }
+  return checked.list;
+}
+function loadState(home, deps) {
+  const storedVersion = readStoredVersion(home, deps);
+  const raw = deps.io.readJsonSync(configFile(home));
+  const normalized = normalizeLoadedConfig(raw.ok ? raw.value : void 0);
+  const overlay = deps.io.readJsonSync(presetsFile(home));
+  let config = normalized.config;
+  if (overlay.ok && overlay.value !== null && typeof overlay.value === "object" && !Array.isArray(overlay.value)) {
+    const rec = overlay.value;
+    if (Array.isArray(rec["presets"])) {
+      const again = normalizeLoadedConfig({ connection: {}, presets: rec["presets"], history: {} });
+      const switches = new Map(again.config.presets.map((entry) => [entry.id, entry]));
+      config = {
+        ...config,
+        presets: config.presets.map((entry) => switches.get(entry.id) ?? entry)
+      };
+    }
+  }
+  const secrets = deps.io.readJsonSync(secretsFile(home));
+  let plaintext;
+  if (secrets.ok && secrets.value !== null && typeof secrets.value === "object" && !Array.isArray(secrets.value)) {
+    const rec = secrets.value;
+    if (typeof rec["apiKeyPlaintext"] === "string")
+      plaintext = rec["apiKeyPlaintext"];
+  }
+  const retired = [...normalized.retired];
+  if (retired.length > 0)
+    deps.logger.warn("dsh-decision-gateway: 退役键已剥离 —— " + retired.join(", "));
+  const synced = {
+    ...config,
+    connection: {
+      ...config.connection,
+      hasPlaintextKey: plaintext !== void 0 && plaintext.length > 0
+    }
+  };
+  const customPresets = loadCustomPresets(home, deps);
+  return { config: synced, plaintext, retired, storedVersion, customPresets };
+}
+function mergePresetSwitches(current, patch) {
+  const switches = new Map(current.map((entry) => [entry.id, entry]));
+  for (const entry of patch)
+    switches.set(entry.id, { ...entry });
+  return current.map((entry) => switches.get(entry.id) ?? entry);
+}
+function savePatch(home, patch, deps) {
+  const current = loadState(home, deps);
+  const next = {
+    ...current.config,
+    connection: {
+      ...current.config.connection,
+      ...patch.apiKeyRef !== void 0 ? patch.apiKeyRef === null ? { apiKeyRef: void 0 } : { apiKeyRef: patch.apiKeyRef } : {},
+      ...patch.timeoutMs !== void 0 ? { timeoutMs: patch.timeoutMs } : {},
+      ...patch.maxConcurrency !== void 0 ? { maxConcurrency: patch.maxConcurrency } : {},
+      ...patch.truncBudget !== void 0 ? { truncBudget: patch.truncBudget } : {}
+    },
+    ...patch.presets !== void 0 ? { presets: mergePresetSwitches(current.config.presets, patch.presets) } : {},
+    ...patch.history !== void 0 ? { history: { ...current.config.history, ...patch.history } } : {}
+  };
+  let plaintext = current.plaintext;
+  if (patch.apiKeyPlaintext !== void 0) {
+    plaintext = patch.apiKeyPlaintext;
+    deps.io.atomicWrite0600Sync(secretsFile(home), JSON.stringify({ apiKeyPlaintext: plaintext }, null, 2) + "\n");
+  } else if (patch.apiKeyRef !== void 0 && patch.apiKeyRef !== null) {
+    plaintext = void 0;
+    deps.io.atomicWrite0600Sync(secretsFile(home), JSON.stringify({}, null, 2) + "\n");
+  }
+  const synced = {
+    ...next,
+    connection: {
+      ...next.connection,
+      hasPlaintextKey: plaintext !== void 0 && plaintext.length > 0
+    }
+  };
+  deps.io.atomicWrite0600Sync(configFile(home), JSON.stringify(synced, null, 2) + "\n");
+  if (patch.presets !== void 0) {
+    deps.io.atomicWrite0600Sync(presetsFile(home), JSON.stringify({ presets: synced.presets }, null, 2) + "\n");
+  }
+  let customPresets = current.customPresets;
+  if (patch.customPresets !== void 0) {
+    const born = new Map(current.customPresets.map((entry) => [entry.id, entry.createdAt]));
+    customPresets = patch.customPresets.map((entry) => ({
+      ...entry,
+      createdAt: born.get(entry.id) ?? entry.createdAt
+    }));
+    deps.io.atomicWrite0600Sync(customPresetsFile(home), JSON.stringify({ version: CUSTOM_PRESETS_VERSION, customPresets }, null, 2) + "\n");
+  }
+  return {
+    config: synced,
+    plaintext,
+    retired: [],
+    storedVersion: current.storedVersion,
+    customPresets
+  };
+}
+function toMaskedConfig(state) {
+  return {
+    version: state.config.version,
+    connection: {
+      ...state.config.connection.apiKeyRef !== void 0 ? { apiKeyRef: state.config.connection.apiKeyRef } : {},
+      hasPlaintextKey: state.config.connection.hasPlaintextKey,
+      timeoutMs: state.config.connection.timeoutMs,
+      maxConcurrency: state.config.connection.maxConcurrency,
+      truncBudget: state.config.connection.truncBudget
+    },
+    presets: state.config.presets.map((entry) => ({ ...entry })),
+    history: { ...state.config.history }
+  };
+}
+function resolveApiKey(state, env, deps) {
+  const ref = state.config.connection.apiKeyRef;
+  if (ref !== void 0) {
+    const value = env[ref];
+    if (value !== void 0 && value.length > 0)
+      return { key: value, source: "env" };
+  }
+  const plain = state.plaintext;
+  if (plain !== void 0 && plain.length > 0) {
+    if (keyShapeCategory(plain) === null)
+      return { key: plain, source: "plaintext" };
+    deps.logger.warn("dsh-decision-gateway: 明文密钥形状非法，已视同无 key");
+  }
+  return { key: void 0, source: "none" };
+}
+
+// lib/server/history/impl/service.js
+import { basename as basename2, dirname as dirname2, join as join5 } from "node:path";
+
+// lib/server/history/impl/paths.js
+function historyRoot(home) {
+  return pluginHome(home ?? dshHome(), PACKAGE_DIR, "history");
+}
+
+// lib/server/history/impl/hash.js
+import { createHash } from "node:crypto";
+import { basename } from "node:path";
+function rootHashOf(root) {
+  return createHash("sha256").update(root, "utf8").digest("hex").slice(0, 32);
+}
+function stateHashOf(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex").slice(0, 32);
+}
+function rootDisplayOf(root) {
+  const base = basename(root);
+  return base === "" ? root.slice(-32) : base;
+}
+function resolveRootHash(root) {
+  if (/^[0-9a-f]{16,64}$/.test(root))
+    return root;
+  return rootHashOf(root);
+}
+
+// lib/server/history/impl/service.js
+function historyFile(home, rootHash, sessionId) {
+  assertSessionId(sessionId);
+  if (!/^[0-9a-f]{16,64}$/.test(rootHash))
+    throw new Error("history[400]: rootHash 非法");
+  return join5(historyRoot(home), rootHash, sessionId + ".jsonl");
+}
+function assertSessionId(sessionId) {
+  if (typeof sessionId !== "string" || !SESSION_ID_RE.test(sessionId)) {
+    throw new Error("history[400]: sessionId 非法");
+  }
+}
+function listSessionFiles(home, deps) {
+  const out = [];
+  const dir = historyRoot(home);
+  for (const root of deps.io.listFilesSync(dir)) {
+    if (root === "" || root.startsWith("."))
+      continue;
+    const sub = join5(dir, root);
+    for (const name2 of deps.io.listFilesSync(sub)) {
+      if (!name2.endsWith(".jsonl"))
+        continue;
+      out.push(join5(sub, name2));
+    }
+  }
+  return out;
+}
+function appendEntry(home, entry, limits, deps) {
+  const file = historyFile(home, entry.rootHash, entry.sessionId);
+  deps.io.ensureDir0700(join5(historyRoot(home), entry.rootHash));
+  const prev = deps.io.readTextSync(file);
+  const line = JSON.stringify(entry) + "\n";
+  const merged = (prev.ok ? prev.text : "") + line;
+  const lines = merged.split("\n").filter((item) => item.length > 0);
+  const kept = lines.slice(Math.max(0, lines.length - limits.perSession));
+  deps.io.atomicWrite0600Sync(file, kept.join("\n") + "\n");
+  enforceTotalSessions(home, limits.totalSessions, deps);
+  return file;
+}
+function enforceTotalSessions(home, totalSessions, deps) {
+  const files = listSessionFiles(home, deps);
+  if (files.length <= totalSessions)
+    return;
+  const ranked = files.map((file) => ({ file, mtime: deps.io.mtimeMs(file) }));
+  ranked.sort((a, b) => a.mtime - b.mtime);
+  for (const victim of ranked.slice(0, ranked.length - totalSessions)) {
+    deps.io.removeFileSync(victim.file);
+  }
+}
+function queryEntries(home, query, deps) {
+  const limit = query.limit === void 0 ? 100 : Math.min(Math.max(1, Math.floor(query.limit)), 500);
+  const rootParam = query.root === void 0 || query.root === "" ? void 0 : query.root;
+  const wantRoot = rootParam === void 0 ? void 0 : /^[0-9a-f]{16,64}$/.test(rootParam) || rootParam.includes("/") || rootParam.includes("\\") ? resolveRootHash(rootParam) : void 0;
+  const wantDisplay = rootParam !== void 0 && wantRoot === void 0 ? rootParam : void 0;
+  if (query.sessionId !== void 0 && query.sessionId !== "")
+    assertSessionId(query.sessionId);
+  const files = listSessionFiles(home, deps);
+  const out = [];
+  for (const file of files) {
+    const name2 = basename2(file);
+    const dirName = basename2(dirname2(file));
+    const sid = name2.endsWith(".jsonl") ? name2.slice(0, -6) : name2;
+    if (wantRoot !== void 0 && dirName !== wantRoot)
+      continue;
+    if (query.sessionId !== void 0 && query.sessionId !== "" && sid !== query.sessionId)
+      continue;
+    const raw = deps.io.readTextSync(file);
+    if (!raw.ok)
+      continue;
+    for (const line of raw.text.split("\n")) {
+      if (line.trim() === "")
+        continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (wantDisplay !== void 0 && parsed.rootDisplay !== wantDisplay)
+          continue;
+        out.push(parsed);
+      } catch {
+      }
+    }
+  }
+  out.sort((a, b) => b.ts - a.ts);
+  return out.slice(0, limit);
+}
+function deleteSession(home, query, deps) {
+  if (query.root === void 0 || query.root === "" || query.sessionId === void 0 || query.sessionId === "") {
+    throw new Error("history[400]: 仅支持单会话删除（root 与 sessionId 双必填）");
+  }
+  const rootParam = query.root;
+  const direct = /^[0-9a-f]{16,64}$/.test(rootParam) || rootParam.includes("/") || rootParam.includes("\\");
+  if (direct) {
+    const file = historyFile(home, resolveRootHash(rootParam), query.sessionId);
+    const prev = deps.io.readTextSync(file);
+    if (!prev.ok)
+      return { deleted: false };
+    deps.io.removeFileSync(file);
+    return { deleted: true };
+  }
+  const hits = [];
+  for (const file of listSessionFiles(home, deps)) {
+    const raw = deps.io.readTextSync(file);
+    if (!raw.ok)
+      continue;
+    for (const line of raw.text.split("\n")) {
+      if (line.trim() === "")
+        continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed.rootDisplay === rootParam && parsed.sessionId === query.sessionId) {
+          hits.push(file);
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  if (hits.length === 0)
+    return { deleted: false };
+  if (hits.length > 1) {
+    throw new Error("history[400]: basename 命中多个会话目录，请传完整路径或 rootHash");
+  }
+  deps.io.removeFileSync(hits[0]);
+  return { deleted: true };
+}
+
+// lib/server/history/impl/redact.js
+var REDACT_PATTERNS = [
+  /sk-[A-Za-z0-9]{8,}/g,
+  /AKIA[0-9A-Z]{16}/g,
+  /ghp_[A-Za-z0-9]{8,}/g,
+  /xox[bpas]-[A-Za-z0-9-]+/g,
+  // S2：头到尾非贪婪不限长——200 字窗口会把长 PEM 切成“掩码半截+密钥体残留”，截断后再存约 170 字原文。
+  /-----BEGIN (?:RSA )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA )?PRIVATE KEY-----/g,
+  /api[_-]?key\s*[:=]\s*[^\s,}]+/gi,
+  /password\s*[:=]\s*[^\s,}]+/gi,
+  /secret\s*[:=]\s*[^\s,}]+/gi
+];
+function redactSnippet(text) {
+  let out = text;
+  for (const pattern of REDACT_PATTERNS) {
+    pattern.lastIndex = 0;
+    out = out.replace(pattern, "***");
+  }
+  const points = Array.from(out);
+  if (points.length <= SNIPPET_MAX)
+    return out;
+  return points.slice(0, SNIPPET_MAX).join("");
+}
+
+// lib/server/history/impl/entry.js
+function assembleEntry(root, sessionId, event, now) {
+  return {
+    ts: now,
+    rootHash: rootHashOf(root),
+    rootDisplay: rootDisplayOf(root),
+    sessionId,
+    presetId: event.presetId,
+    templateVersion: TEMPLATE_VERSION,
+    stateHash: stateHashOf(event.text),
+    snippetRedacted: event.precheckHit ? "***" : redactSnippet(event.text),
+    lang: event.lang,
+    truncated: event.truncated,
+    originalLength: event.originalLength,
+    resultKind: event.resultKind,
+    ...event.choice !== void 0 ? { choice: event.choice } : {},
+    ...event.score !== void 0 ? { score: event.score } : {},
+    confidence: event.confidence,
+    tier: event.tier,
+    automation: event.automation,
+    provider: "official",
+    latencyMs: event.latencyMs,
+    ...event.errorCode !== void 0 ? { errorCode: event.errorCode } : {},
+    questions: snapshotQuestions(event)
+  };
+}
+function snapshotQuestions(event) {
+  return event.questions.map((q) => ({
+    id: q.id,
+    text: redactSnippet(q.text),
+    kind: q.kind,
+    ...q.options !== void 0 ? { options: q.options.map((opt) => redactSnippet(opt)) } : {},
+    ...q.levels !== void 0 ? { levels: q.levels.map((lv) => redactSnippet(lv)) } : {}
+  }));
+}
+
+// lib/server/store/impl/io.js
+import { chmodSync, mkdirSync, readdirSync, readFileSync as readFileSync2, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+function ensureDir0700(dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    chmodSync(dir, 448);
+  } catch {
+  }
+}
+function atomicWrite0600Sync(file, text) {
+  ensureDir0700(dirname3(file));
+  const nonce = Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0");
+  const tmp = file + ".tmp-" + String(process.pid) + "-" + nonce;
+  writeFileSync(tmp, text, { mode: 384 });
+  try {
+    chmodSync(tmp, 384);
+  } catch {
+  }
+  renameSync(tmp, file);
+  try {
+    chmodSync(file, 384);
+  } catch {
+  }
+}
+function readTextSync(file) {
+  try {
+    return { ok: true, text: readFileSync2(file, "utf8") };
+  } catch {
+    return { ok: false };
+  }
+}
+function readJsonSync(file) {
+  const raw = readTextSync(file);
+  if (!raw.ok)
+    return { ok: false };
+  try {
+    return { ok: true, value: JSON.parse(raw.text) };
+  } catch {
+    return { ok: false };
+  }
+}
+function mtimeMs(file) {
+  try {
+    return statSync(file).mtimeMs;
+  } catch {
+    return -1;
+  }
+}
+function listFilesSync(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function removeFileSync(file) {
+  try {
+    unlinkSync(file);
+  } catch {
+  }
+}
+
+// ../../node_modules/.pnpm/@typesafe-ai+sdk@0.6.0/node_modules/@typesafe-ai/sdk/dist/index.mjs
+var requestIdFrom = (headers) => headers.get("x-typesafe-request-id") ?? void 0;
+var APIPromise = class APIPromise2 extends Promise {
+  #responsePromise;
+  #parseResponse;
+  #parsed;
+  constructor(responsePromise, parseResponse) {
+    super((resolve) => resolve(void 0));
+    this.#responsePromise = responsePromise;
+    this.#parseResponse = parseResponse;
+  }
+  /**
+  * Resolves to the raw `Response` without parsing the body. SDK requests buffer the full
+  * body under the request timeout before handoff; reading it afterwards is caller-owned.
+  * The caller owns the body; don't also `await` the parsed result on the same promise.
+  */
+  asResponse() {
+    return this.#responsePromise;
+  }
+  /** Return the parsed result, HTTP response, and request ID. */
+  async withResponse() {
+    const [data, response] = await Promise.all([this.#parse(), this.#responsePromise]);
+    return {
+      data,
+      response,
+      requestId: requestIdFrom(response.headers)
+    };
+  }
+  /** Transform the parsed result, sharing the HTTP response and a single body parse. */
+  map(fn) {
+    return new APIPromise2(this.#responsePromise, () => this.#parse().then(fn));
+  }
+  #parse() {
+    this.#parsed ??= this.#responsePromise.then(this.#parseResponse);
+    return this.#parsed;
+  }
+  then(onfulfilled, onrejected) {
+    return this.#parse().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.#parse().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.#parse().finally(onfinally);
+  }
+};
+var ENV = {
+  /** Required API key; used when `apiKey` is omitted. */
+  apiKey: "TYPESAFE_API_KEY",
+  /** API root; defaults to `https://api.typesafe.ai`. */
+  baseURL: "TYPESAFE_BASE_URL",
+  /** Default model name; defaults to `jev-latest`. */
+  defaultModel: "TYPESAFE_DEFAULT_MODEL",
+  /** Log level; defaults to `warn`. */
+  logLevel: "TYPESAFE_LOG_LEVEL"
+};
+var readEnv = (name2) => {
+  if (typeof process === "undefined" || !process.env) return void 0;
+  return process.env[name2]?.trim() || void 0;
+};
+var fromCodeOrEnv = (fromCode, envVar) => fromCode ?? readEnv(envVar);
+var range = (from, to) => Array.from({ length: to - from }, (_, i) => from + i);
+var DEFAULT_RETRY_POLICY = {
+  maxRetries: 2,
+  backoffInitialMs: 500,
+  backoffMaxMs: 5e3,
+  backoffJitter: 0.25,
+  /** HTTP 408, 429, and 5xx responses. */
+  httpStatuses: /* @__PURE__ */ new Set([
+    408,
+    429,
+    ...range(500, 600)
+  ]),
+  respectRetryAfter: true,
+  /** Maximum server retry delay before falling back to backoff. */
+  maxRetryAfterMs: 6e4,
+  apiConnectionError: true,
+  apiTimeoutError: true
+};
+DEFAULT_RETRY_POLICY.maxRetries;
+var isRetryableStatus = (status, policy = DEFAULT_RETRY_POLICY) => policy.httpStatuses.has(status);
+var parseRetryAfter = (headers, now = Date.now()) => {
+  const ms = Number(headers.get("retry-after-ms"));
+  if (headers.has("retry-after-ms") && Number.isFinite(ms) && ms >= 0) return ms;
+  const raw = headers.get("retry-after");
+  if (raw === null) return void 0;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return seconds >= 0 ? seconds * 1e3 : void 0;
+  const date = Date.parse(raw);
+  if (!Number.isNaN(date)) return Math.max(0, date - now);
+};
+var retryDelayMs = (attempt, headers, policy = DEFAULT_RETRY_POLICY, random = Math.random) => {
+  if (policy.respectRetryAfter && headers !== void 0) {
+    const retryAfter = parseRetryAfter(headers);
+    if (retryAfter !== void 0 && retryAfter <= policy.maxRetryAfterMs) return retryAfter;
+  }
+  const exponential = Math.min(policy.backoffInitialMs * 2 ** attempt, policy.backoffMaxMs);
+  return Math.round(exponential * (1 - random() * policy.backoffJitter));
+};
+var sleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) return reject(signal.reason);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(signal?.reason);
+  };
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var TypeSafeError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var extractMessage = (body) => {
+  if (typeof body === "string") return body || void 0;
+  if (!isRecord2(body)) return void 0;
+  const { error, message, detail } = body;
+  if (typeof error === "string") return error;
+  if (isRecord2(error) && typeof error.message === "string") return error.message;
+  if (typeof message === "string") return message;
+  if (typeof detail === "string") return detail;
+  if (isRecord2(detail) && typeof detail.message === "string") return detail.message;
+  if (Array.isArray(detail)) return describeValidationErrors(detail);
+};
+var describeValidationErrors = (errors) => {
+  const parts = errors.flatMap((e) => {
+    if (!isRecord2(e) || typeof e.msg !== "string") return [];
+    const loc = Array.isArray(e.loc) ? e.loc.filter((x) => x !== "body").join(".") : "";
+    return [loc ? `${loc}: ${e.msg}` : e.msg];
+  });
+  return parts.length > 0 ? parts.join("; ") : void 0;
+};
+var MAX_RAW_BODY_IN_MESSAGE = 200;
+var APIError = class APIError2 extends TypeSafeError {
+  /** HTTP response status code. */
+  status;
+  /** HTTP response headers. */
+  headers;
+  /** Parsed JSON, response text, or `undefined` for an empty body. */
+  body;
+  /** Request ID from `x-typesafe-request-id`, or `undefined` when absent. */
+  requestId;
+  constructor(status, body, headers, message) {
+    super(message ?? APIError2.describe(status, body));
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+    this.requestId = requestIdFrom(headers);
+  }
+  static describe(status, body) {
+    const detail = extractMessage(body);
+    if (detail) return `${status} ${detail}`;
+    if (body === void 0) return `${status} status code (no body)`;
+    const raw = typeof body === "string" ? body : JSON.stringify(body);
+    return `${status} ${raw.length > MAX_RAW_BODY_IN_MESSAGE ? `${raw.slice(0, MAX_RAW_BODY_IN_MESSAGE)}…` : raw}`;
+  }
+  /** Create the error subclass for an HTTP status code. */
+  static fromResponse(status, body, headers) {
+    if (status === 400) return new BadRequestError(status, body, headers);
+    if (status === 401) return new AuthenticationError(status, body, headers);
+    if (status === 403) return new PermissionDeniedError(status, body, headers);
+    if (status === 404) return new NotFoundError(status, body, headers);
+    if (status === 422) return new UnprocessableEntityError(status, body, headers);
+    if (status === 429) return new RateLimitError(status, body, headers);
+    if (status >= 500) return new InternalServerError(status, body, headers);
+    return new APIError2(status, body, headers);
+  }
+};
+var BadRequestError = class extends APIError {
+};
+var AuthenticationError = class extends APIError {
+};
+var PermissionDeniedError = class extends APIError {
+};
+var NotFoundError = class extends APIError {
+};
+var UnprocessableEntityError = class extends APIError {
+};
+var RateLimitError = class extends APIError {
+  /** Server retry delay in milliseconds, or `undefined` when absent or invalid. */
+  retryAfterMs = parseRetryAfter(this.headers);
+};
+var InternalServerError = class extends APIError {
+};
+var APIConnectionError = class extends TypeSafeError {
+  constructor(message = "Connection error.", options) {
+    super(message, options);
+  }
+};
+var APITimeoutError = class extends APIConnectionError {
+  /** Configured timeout in milliseconds. */
+  timeoutMs;
+  constructor(timeoutMs, options) {
+    super(`Request timed out after ${timeoutMs}ms.`, options);
+    this.timeoutMs = timeoutMs;
+  }
+};
+var APIUserAbortError = class extends TypeSafeError {
+  constructor(message = "Request was aborted.", options) {
+    super(message, options);
+  }
+};
+var LOG_LEVELS = [
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "off"
+];
+var DEFAULT_LOG_LEVEL = "warn";
+var isLogLevel = (value) => LOG_LEVELS.includes(value);
+var parseLogLevel = (value, source) => {
+  if (isLogLevel(value)) return value;
+  throw new TypeSafeError(`Invalid log level "${value}" from ${source}. Expected one of: ${LOG_LEVELS.join(", ")}.`);
+};
+var PREFIX = "[typesafe-sdk]";
+var consoleLogger = {
+  debug: (message, ...args) => console.debug(`${PREFIX} ${message}`, ...args),
+  info: (message, ...args) => console.info(`${PREFIX} ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`${PREFIX} ${message}`, ...args),
+  error: (message, ...args) => console.error(`${PREFIX} ${message}`, ...args)
+};
+var RANK = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  off: 4
+};
+var drop = () => {
+};
+var withLevel = (sink, level) => {
+  const enabled = (at) => RANK[at] >= RANK[level];
+  return {
+    debug: enabled("debug") ? (message, ...args) => sink.debug(message, ...args) : drop,
+    info: enabled("info") ? (message, ...args) => sink.info(message, ...args) : drop,
+    warn: enabled("warn") ? (message, ...args) => sink.warn(message, ...args) : drop,
+    error: enabled("error") ? (message, ...args) => sink.error(message, ...args) : drop
+  };
+};
+var KEY_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "proxy-authorization",
+  "x-api-key"
+]);
+var OPAQUE_HEADERS = /* @__PURE__ */ new Set(["cookie", "set-cookie"]);
+var redactKey = (value) => {
+  const [scheme, secret] = value.includes(" ") ? value.split(/\s+/, 2) : [void 0, value];
+  const tail = secret && secret.length > 8 ? secret.slice(-4) : "";
+  return `${scheme ? `${scheme} ` : ""}***${tail}`;
+};
+var redact = (name2, value) => {
+  const lower = name2.toLowerCase();
+  if (KEY_HEADERS.has(lower)) return redactKey(value);
+  if (OPAQUE_HEADERS.has(lower)) return "***";
+  return value;
+};
+var redactHeaders = (headers) => Object.fromEntries(Object.entries(headers).map(([name2, value]) => [name2, redact(name2, value)]));
+var validateQuestions = (questions) => {
+  if (Object.keys(questions).length === 0) throw new TypeSafeError("At least one question is required.");
+  for (const [name2, question] of Object.entries(questions)) {
+    if (question.type !== "score") continue;
+    if (!Array.isArray(question.criteria)) throw new TypeSafeError(`Score question "${name2}" has criteria that are not a list; score criteria must be a list of descriptions indexed by score from zero.`);
+    if (question.criteria.length < 2) throw new TypeSafeError(`Score question "${name2}" has ${question.criteria.length} criteria; at least two scores are required.`);
+  }
+};
+var Models = class {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  /** List the models available to the account. */
+  list(options = {}) {
+    return this.#transport.request("GET", "/v1/models", options).map(unwrapModels);
+  }
+};
+var unwrapModels = (wire) => {
+  if (Array.isArray(wire?.models)) return wire.models;
+  throw new TypeSafeError("Unexpected response shape from GET /v1/models; expected { models: [...] }.");
+};
+var g = globalThis;
+var isBrowser = () => typeof g.window !== "undefined" && typeof g.window.document !== "undefined" && typeof g.navigator !== "undefined";
+var describeRuntime = () => {
+  const platform = g.process?.platform && g.process?.arch ? ` (${g.process.platform}; ${g.process.arch})` : "";
+  if (g.Bun?.version) return `bun/${g.Bun.version}${platform}`;
+  if (g.Deno?.version?.deno) return `deno/${g.Deno.version.deno}${platform}`;
+  if (g.EdgeRuntime !== void 0) return "vercel-edge";
+  if (g.navigator?.userAgent === "Cloudflare-Workers") return "cloudflare-workers";
+  if (g.process?.versions?.node) return `node/${g.process.versions.node}${platform}`;
+  if (isBrowser()) return "browser";
+  return "unknown";
+};
+var VERSION = "0.6.0";
+var missingApiKey = () => {
+  throw new TypeSafeError(`No API key was provided. Pass \`apiKey\` to the TypeSafeClient constructor or set the ${ENV.apiKey} environment variable.`);
+};
+var missingFetch = () => {
+  throw new TypeSafeError("No global `fetch` is available in this runtime. Pass a `fetch` implementation to the TypeSafeClient constructor.");
+};
+var refuseBrowser = () => {
+  throw new TypeSafeError("TypeSafeClient is running in a browser, which would expose your API key to anyone using the page. Call the API from a server instead, or pass `dangerouslyAllowBrowser: true` if you understand the risk.");
+};
+var defaultFetch = (input, init) => globalThis.fetch(input, init);
+var assertNonNegativeInteger = (name2, value) => {
+  if (!Number.isInteger(value) || value < 0) throw new TypeSafeError(`\`${name2}\` must be a non-negative integer, got ${String(value)}.`);
+  return value;
+};
+var assertPositiveMs = (name2, value) => {
+  if (!Number.isFinite(value) || value <= 0) throw new TypeSafeError(`\`${name2}\` must be a positive number of milliseconds, got ${String(value)}.`);
+  return value;
+};
+var assertNonNegativeMs = (name2, value) => {
+  if (!Number.isFinite(value) || value < 0) throw new TypeSafeError(`\`${name2}\` must be a non-negative number of milliseconds, got ${String(value)}.`);
+  return value;
+};
+var assertFraction = (name2, value) => {
+  if (!Number.isFinite(value) || value < 0 || value > 1) throw new TypeSafeError(`\`${name2}\` must be between 0 and 1, got ${String(value)}.`);
+  return value;
+};
+var assertStatusSet = (name2, statuses) => {
+  for (const status of statuses) if (!Number.isInteger(status) || status < 100 || status > 999) throw new TypeSafeError(`\`${name2}\` must contain HTTP status codes, got ${String(status)}.`);
+  return statuses;
+};
+var resolveRetryPolicy = (base, overrides) => {
+  const o = overrides ?? {};
+  return {
+    maxRetries: o.maxRetries === void 0 ? base.maxRetries : assertNonNegativeInteger("retry.maxRetries", o.maxRetries),
+    backoffInitialMs: o.backoffInitialMs === void 0 ? base.backoffInitialMs : assertNonNegativeMs("retry.backoffInitialMs", o.backoffInitialMs),
+    backoffMaxMs: o.backoffMaxMs === void 0 ? base.backoffMaxMs : assertNonNegativeMs("retry.backoffMaxMs", o.backoffMaxMs),
+    backoffJitter: o.backoffJitter === void 0 ? base.backoffJitter : assertFraction("retry.backoffJitter", o.backoffJitter),
+    httpStatuses: new Set(o.httpStatuses === void 0 ? base.httpStatuses : assertStatusSet("retry.httpStatuses", o.httpStatuses)),
+    respectRetryAfter: o.respectRetryAfter ?? base.respectRetryAfter,
+    maxRetryAfterMs: o.maxRetryAfterMs === void 0 ? base.maxRetryAfterMs : assertNonNegativeMs("retry.maxRetryAfterMs", o.maxRetryAfterMs),
+    apiConnectionError: o.apiConnectionError ?? base.apiConnectionError,
+    apiTimeoutError: o.apiTimeoutError ?? base.apiTimeoutError
+  };
+};
+var isRetryableError = (err, policy) => {
+  if (err instanceof APITimeoutError) return policy.apiTimeoutError;
+  if (err instanceof APIConnectionError) return policy.apiConnectionError;
+  return false;
+};
+var resolveLogLevel = (fromCode) => {
+  if (fromCode !== void 0) return parseLogLevel(fromCode, "the `logLevel` option");
+  const fromEnv = readEnv(ENV.logLevel);
+  if (fromEnv !== void 0) return parseLogLevel(fromEnv, ENV.logLevel);
+  return DEFAULT_LOG_LEVEL;
+};
+var stripTrailingSlashes = (url) => url.replace(/\/+$/, "");
+var mergeHeaders = (...sources) => {
+  const entries = /* @__PURE__ */ new Map();
+  for (const source of sources) for (const [name2, value] of Object.entries(source)) if (value === void 0) entries.delete(name2.toLowerCase());
+  else entries.set(name2.toLowerCase(), [name2, value]);
+  return Object.fromEntries(entries.values());
+};
+var bufferResponse = async (response, signal) => {
+  const reader = response.clone().body?.getReader();
+  if (!reader) return;
+  const cancel = () => {
+    reader.cancel(signal.reason).catch(() => {
+    });
+    response.body?.cancel(signal.reason).catch(() => {
+    });
+  };
+  signal.addEventListener("abort", cancel, { once: true });
+  try {
+    if (signal.aborted) cancel();
+    signal.throwIfAborted();
+    while (!(await reader.read()).done) signal.throwIfAborted();
+    signal.throwIfAborted();
+  } finally {
+    signal.removeEventListener("abort", cancel);
+    reader.releaseLock();
+  }
+};
+var RUNTIME = describeRuntime();
+var TypeSafeClient = class {
+  /** API key excluded from serialization and public properties. */
+  #apiKey;
+  /** API root with trailing slashes removed. */
+  baseURL;
+  /** Model used when a request omits `model`. */
+  defaultModel;
+  /** Configured log verbosity. */
+  logLevel;
+  /** The configured logger, filtered to `logLevel`. */
+  logger;
+  /** Retry settings with constructor overrides applied. */
+  retry;
+  /** Timeout per attempt in milliseconds. */
+  timeout;
+  /** Additional headers sent with each request. */
+  defaultHeaders;
+  /** HTTP fetch implementation. */
+  fetch;
+  /** The models available to the account. */
+  models;
+  #requestCount = 0;
+  /**
+  * Create a client for the TypeSafe AI API.
+  *
+  * Explicit options take precedence over environment variables, then SDK defaults.
+  * Empty or whitespace-only environment values are ignored.
+  *
+  * @throws {TypeSafeError} The API key is missing, configuration is invalid, or the runtime is unsupported.
+  */
+  constructor(config = {}) {
+    if (isBrowser() && !config.dangerouslyAllowBrowser) refuseBrowser();
+    this.#apiKey = fromCodeOrEnv(config.apiKey, ENV.apiKey) ?? missingApiKey();
+    this.baseURL = stripTrailingSlashes(fromCodeOrEnv(config.baseURL, ENV.baseURL) ?? "https://api.typesafe.ai");
+    this.defaultModel = fromCodeOrEnv(config.defaultModel, ENV.defaultModel) ?? "jev-latest";
+    this.logLevel = resolveLogLevel(config.logLevel);
+    this.logger = withLevel(config.logger ?? consoleLogger, this.logLevel);
+    this.retry = resolveRetryPolicy(DEFAULT_RETRY_POLICY, config.retry);
+    this.timeout = assertPositiveMs("timeout", config.timeout ?? 1e4);
+    this.defaultHeaders = { ...config.defaultHeaders };
+    if (config.fetch === void 0 && typeof globalThis.fetch !== "function") missingFetch();
+    this.fetch = config.fetch ?? defaultFetch;
+    const transport = {
+      request: (method, path, options) => this.#request(method, path, options),
+      defaultModel: this.defaultModel
+    };
+    this.models = new Models(transport);
+  }
+  /**
+  * Answer named questions about text or structured state.
+  *
+  * @param request - State, questions, and an optional model override.
+  * @param options - Per-call timeout, retry, headers, and cancellation settings.
+  * @returns Answers typed by question name and criteria, with model and token usage.
+  * @throws {TypeSafeError} Questions are empty, or score criteria are not a list of at least two entries.
+  * @throws {APIError} The server returns a non-2xx response after retries.
+  * @throws {APIConnectionError} The request cannot connect or times out after retries.
+  * @throws {APIUserAbortError} The caller aborts the request.
+  *
+  * @example
+  * ```ts
+  * const { answers } = await client.systemOne({
+  *   state: "I was charged twice. Please help.",
+  *   questions: { billing: noul("Is this about billing?") },
+  * });
+  * console.log(answers.billing.noul);
+  * ```
+  */
+  systemOne(request, options = {}) {
+    validateQuestions(request.questions);
+    const body = {
+      ...request,
+      model: request.model ?? this.defaultModel
+    };
+    return this.#request("POST", "/v1/systemone", {
+      ...options,
+      body
+    });
+  }
+  /** Send a request and parse its response body. */
+  #request(method, path, options = {}) {
+    const resolved = {
+      method,
+      path,
+      body: options.body,
+      headers: mergeHeaders(this.defaultHeaders, options.headers ?? {}),
+      signal: options.signal,
+      timeout: options.timeout === void 0 ? this.timeout : assertPositiveMs("timeout", options.timeout),
+      retry: resolveRetryPolicy(this.retry, options.retry)
+    };
+    const tag = `#${++this.#requestCount} ${method} ${path}`;
+    return new APIPromise(this.fetchWithRetries(tag, resolved), async (res) => {
+      const parsed = await parseBody(res);
+      this.logger.debug(`${tag} <- body`, parsed);
+      return parsed;
+    });
+  }
+  /** Retry eligible failures, logging attempt summaries at `info` and headers and bodies at `debug`. */
+  async fetchWithRetries(tag, req) {
+    const url = `${this.baseURL}${req.path}`;
+    const headers = mergeHeaders(req.headers, {
+      Authorization: `Bearer ${this.#apiKey}`,
+      Accept: "application/json",
+      "User-Agent": `typesafe-sdk/${VERSION}`,
+      "X-TypeSafe-SDK": `typesafe-sdk/${VERSION}`,
+      "X-TypeSafe-Runtime": RUNTIME,
+      "Content-Type": req.body === void 0 ? void 0 : "application/json",
+      "X-TypeSafe-Retry-Count": void 0
+    });
+    const body = req.body === void 0 ? void 0 : JSON.stringify(req.body);
+    for (let attempt = 0; ; attempt++) {
+      const retriesLeft = req.retry.maxRetries - attempt;
+      const attemptHeaders = attempt === 0 ? headers : {
+        ...headers,
+        "X-TypeSafe-Retry-Count": String(attempt)
+      };
+      this.logger.debug(`${tag} -> ${url}`, {
+        headers: redactHeaders(attemptHeaders),
+        body: req.body
+      });
+      const started = Date.now();
+      let res;
+      try {
+        res = await this.attempt(tag, url, {
+          method: req.method,
+          headers: attemptHeaders,
+          body
+        }, req);
+      } catch (err) {
+        if (err instanceof APIUserAbortError || retriesLeft <= 0) throw err;
+        if (!isRetryableError(err, req.retry)) throw err;
+        await this.backOff(tag, attempt, retriesLeft, err.message, void 0, req);
+        continue;
+      }
+      const requestId = requestIdFrom(res.headers);
+      this.logger.info(`${tag} <- ${res.status} in ${Date.now() - started}ms${requestId ? ` (request ${requestId})` : ""}`);
+      if (res.ok) return res;
+      const errorBody = await parseBody(res);
+      this.logger.debug(`${tag} <- error body`, errorBody);
+      const error = APIError.fromResponse(res.status, errorBody, res.headers);
+      if (retriesLeft <= 0 || !isRetryableStatus(res.status, req.retry)) throw error;
+      await this.backOff(tag, attempt, retriesLeft, `${res.status}`, res.headers, req);
+    }
+  }
+  /**
+  * One HTTP round trip, including body delivery, with a timeout. The caller's signal and our
+  * timer both abort the same controller; we check which fired to choose the error class.
+  */
+  async attempt(tag, url, init, { signal, timeout }) {
+    const controller = new AbortController();
+    const abortFromCaller = () => controller.abort(signal?.reason);
+    if (signal?.aborted) abortFromCaller();
+    signal?.addEventListener("abort", abortFromCaller, { once: true });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeout);
+    const started = Date.now();
+    const elapsed = () => `${Date.now() - started}ms`;
+    try {
+      const response = await this.fetch(url, {
+        ...init,
+        signal: controller.signal
+      });
+      await bufferResponse(response, controller.signal);
+      return response;
+    } catch (err) {
+      if (signal?.aborted) {
+        this.logger.info(`${tag} aborted by caller after ${elapsed()}`);
+        throw new APIUserAbortError(void 0, { cause: err });
+      }
+      if (timedOut) {
+        this.logger.info(`${tag} timed out after ${elapsed()}`);
+        throw new APITimeoutError(timeout, { cause: err });
+      }
+      this.logger.info(`${tag} connection error after ${elapsed()}`, err);
+      throw new APIConnectionError(err instanceof Error ? `Connection error: ${err.message}` : void 0, { cause: err });
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abortFromCaller);
+    }
+  }
+  /** Wait before retrying; caller cancellation throws `APIUserAbortError`. */
+  async backOff(tag, attempt, retriesLeft, reason, headers, { retry, signal }) {
+    const delay = retryDelayMs(attempt, headers, retry);
+    const nth = attempt + 1;
+    const total = attempt + retriesLeft;
+    this.logger.info(`${tag} retrying in ${delay}ms (retry ${nth}/${total}) after ${reason}`);
+    try {
+      await sleep(delay, signal);
+    } catch (err) {
+      this.logger.info(`${tag} aborted by caller while waiting to retry`);
+      throw new APIUserAbortError(void 0, { cause: err });
+    }
+  }
+};
+var parseBody = async (res) => {
+  const text = await res.text();
+  if (text.length === 0) return void 0;
+  if ((res.headers.get("content-type") ?? "").includes("application/json")) try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+
+// lib/server/tools/impl/client.js
+function defaultFetchImpl() {
+  return async (url, init) => {
+    const impl = globalThis.fetch;
+    if (typeof impl !== "function")
+      throw new Error("decision-gateway[500]: global fetch unavailable");
+    const res = await impl(url, {
+      method: init.method,
+      headers: init.headers,
+      body: init.body,
+      signal: init.signal
+    });
+    return { status: res.status, text: await res.text() };
+  };
+}
+var SDK_PATH = "/v1/systemone";
+if (!JEV_BASE_URL.endsWith(SDK_PATH)) {
+  throw new Error("dsh-decision-gateway: JEV_BASE_URL 须以 /v1/systemone 结尾");
+}
+var JEV_API_ROOT = JEV_BASE_URL.slice(0, -SDK_PATH.length);
+var SCORE_LEVELS = ["1", "2", "3", "4", "5"];
+function confidenceTier(confidence) {
+  if (confidence >= 0.8)
+    return 2;
+  if (confidence >= 0.5)
+    return 1;
+  return 0;
+}
+function clamp01(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 0;
+}
+function toWireQuestions(questions) {
+  const out = {};
+  for (const q of questions) {
+    out[q.id] = q.kind === "choice" ? {
+      type: "choice",
+      instructions: q.text,
+      criteria: Object.fromEntries((q.options ?? []).map((o) => [o, null]))
+    } : {
+      type: "score",
+      instructions: q.text,
+      // 校验已保证 2-10 档；tuple 形状经 unknown 中转（string[] 无法直接断言为定长元组）。
+      criteria: [...q.levels ?? SCORE_LEVELS]
+    };
+  }
+  return out;
+}
+function callerAbortedFailure() {
+  return {
+    code: "ABORTED",
+    category: "aborted",
+    message: "caller aborted",
+    retryable: false
+  };
+}
+function isCallerAborted(callerSignal) {
+  return callerSignal?.aborted === true;
+}
+function combineSignals(callerSignal, innerSignal) {
+  if (callerSignal === void 0)
+    return innerSignal;
+  if (callerSignal.aborted)
+    return callerSignal;
+  if (innerSignal.aborted)
+    return innerSignal;
+  const anyFn = AbortSignal.any;
+  if (typeof anyFn === "function")
+    return anyFn([callerSignal, innerSignal]);
+  const relay = new AbortController();
+  const onAbort = () => {
+    callerSignal.removeEventListener("abort", onAbort);
+    innerSignal.removeEventListener("abort", onAbort);
+    relay.abort();
+  };
+  callerSignal.addEventListener("abort", onAbort, { once: true });
+  innerSignal.addEventListener("abort", onAbort, { once: true });
+  return relay.signal;
+}
+function toSdkFetch(fetchImpl, callerSignal) {
+  return async (input, init) => {
+    const headers = Object.fromEntries(new Headers(init?.headers ?? {}).entries());
+    const inner = init?.signal ?? new AbortController().signal;
+    const res = await fetchImpl(input, {
+      method: init?.method ?? "POST",
+      headers,
+      body: typeof init?.body === "string" ? init.body : "",
+      signal: combineSignals(callerSignal, inner)
+    });
+    return new Response(res.text, {
+      status: res.status,
+      headers: { "content-type": "application/json" }
+    });
+  };
+}
+function mapFirstAnswer(body, result) {
+  const bad = (message) => ({
+    ok: false,
+    failure: { code: "UPSTREAM", category: "bad-payload", message, retryable: false }
+  });
+  const ids = Object.keys(body.questions);
+  const first = ids[0];
+  const answers = result.answers;
+  if (answers === null || typeof answers !== "object" || Array.isArray(answers)) {
+    return bad("answers shape");
+  }
+  const ans = first === void 0 ? void 0 : answers[first];
+  if (ans === null || typeof ans !== "object" || Array.isArray(ans)) {
+    return bad("answer shape");
+  }
+  const rec = ans;
+  if (rec["type"] === "choice") {
+    const choice = rec["choice"];
+    if (typeof choice !== "string" || choice.length === 0) {
+      return bad("choice must be non-empty");
+    }
+    const confidence = clamp01(rec["confidence"]);
+    const level = confidenceTier(confidence);
+    return {
+      ok: true,
+      verdict: {
+        resultKind: "choice",
+        choice,
+        confidence,
+        tier: level,
+        automation: level,
+        codepoints: 0
+      }
+    };
+  }
+  if (rec["type"] === "score") {
+    const raw = rec["score"];
+    if (typeof raw !== "number" || !Number.isFinite(raw)) {
+      return bad("score must be a number");
+    }
+    const sent = body.questions[first];
+    const levels = Array.isArray(sent?.criteria) && sent.criteria.length >= 2 ? sent.criteria.length : SCORE_LEVELS.length;
+    const score = Math.min(5, Math.max(1, Math.round(raw / (levels - 1) * 4) + 1));
+    const confidence = clamp01(rec["confidence"]);
+    const level = confidenceTier(confidence);
+    return {
+      ok: true,
+      verdict: {
+        resultKind: "score",
+        score,
+        confidence,
+        tier: level,
+        automation: level,
+        codepoints: 0
+      }
+    };
+  }
+  return bad("answer type must be choice|score");
+}
+function sdkErrorToFailure(cause) {
+  if (cause instanceof APIUserAbortError) {
+    return callerAbortedFailure();
+  }
+  if (cause instanceof APITimeoutError) {
+    return { code: "TIMEOUT", category: "timeout", message: "request timed out", retryable: true };
+  }
+  if (cause instanceof APIConnectionError) {
+    return {
+      code: "NETWORK",
+      category: "network",
+      message: "fetch failed: " + (cause instanceof Error ? cause.message : String(cause)),
+      retryable: true
+    };
+  }
+  if (cause instanceof APIError) {
+    const status = cause.status;
+    if (status === 401 || status === 403) {
+      return {
+        code: "UNAUTHORIZED",
+        category: "unauthorized",
+        message: "upstream rejected credentials",
+        retryable: false,
+        status
+      };
+    }
+    if (status === 429) {
+      return {
+        code: "RATE_LIMITED",
+        category: "rate-limited",
+        message: "upstream rate limited",
+        retryable: true,
+        status
+      };
+    }
+    if (status >= 500 && status <= 599) {
+      return {
+        code: "UPSTREAM",
+        category: "upstream",
+        message: "upstream status " + String(status),
+        retryable: true,
+        status
+      };
+    }
+    return {
+      code: "UPSTREAM",
+      category: "upstream",
+      message: "upstream status " + String(status),
+      retryable: false,
+      status
+    };
+  }
+  if (cause instanceof Error && cause.name === "AbortError") {
+    return { code: "TIMEOUT", category: "timeout", message: "request timed out", retryable: true };
+  }
+  if (cause instanceof TypeSafeError) {
+    return {
+      code: "UPSTREAM",
+      category: "bad-payload",
+      message: "client-side SDK error",
+      retryable: false
+    };
+  }
+  if (cause instanceof Error) {
+    return {
+      code: "NETWORK",
+      category: "network",
+      message: "fetch failed: " + cause.message,
+      retryable: true
+    };
+  }
+  return { code: "UPSTREAM", category: "upstream", message: "unknown", retryable: false };
+}
+async function attemptOnce(body, key, timeoutMs, fetchImpl, callerSignal) {
+  if (isCallerAborted(callerSignal)) {
+    return { ok: false, failure: callerAbortedFailure() };
+  }
+  if (!(timeoutMs > 0)) {
+    return {
+      ok: false,
+      failure: {
+        code: "TIMEOUT",
+        category: "timeout",
+        message: "request timed out",
+        retryable: true
+      }
+    };
+  }
+  const client = new TypeSafeClient({
+    apiKey: key,
+    baseURL: JEV_API_ROOT,
+    fetch: toSdkFetch(fetchImpl, callerSignal),
+    logLevel: "warn",
+    retry: { maxRetries: 0 }
+  });
+  try {
+    const result = await client.systemOne({ model: body.model, state: body.state, questions: body.questions }, callerSignal === void 0 ? { timeout: timeoutMs } : { timeout: timeoutMs, signal: callerSignal });
+    return mapFirstAnswer(body, result);
+  } catch (cause) {
+    if (isCallerAborted(callerSignal)) {
+      return { ok: false, failure: callerAbortedFailure() };
+    }
+    return { ok: false, failure: sdkErrorToFailure(cause) };
+  }
+}
+async function callWithRetry(body, key, timeoutMs, fetchImpl, callerSignal) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  const budgetLeft = () => Math.max(0, deadline - Date.now());
+  const first = await attemptOnce(body, key, budgetLeft(), fetchImpl, callerSignal);
+  if (first.ok)
+    return { verdict: first.verdict, retries: 0 };
+  if (!first.failure.retryable)
+    return { failure: first.failure, retries: 0 };
+  if (first.failure.code === "TIMEOUT")
+    return { failure: first.failure, retries: 0 };
+  if (isCallerAborted(callerSignal))
+    return { failure: callerAbortedFailure(), retries: 0 };
+  if (budgetLeft() <= 0)
+    return { failure: first.failure, retries: 0 };
+  const second = await attemptOnce(body, key, budgetLeft(), fetchImpl, callerSignal);
+  if (second.ok)
+    return { verdict: second.verdict, retries: 1 };
+  if (!second.failure.retryable)
+    return { failure: second.failure, retries: 1 };
+  if (isCallerAborted(callerSignal))
+    return { failure: callerAbortedFailure(), retries: 1 };
+  if (budgetLeft() <= 0)
+    return { failure: second.failure, retries: 1 };
+  const third = await attemptOnce(body, key, budgetLeft(), fetchImpl, callerSignal);
+  if (third.ok)
+    return { verdict: third.verdict, retries: 2 };
+  return { failure: third.failure, retries: 2 };
+}
+
+// lib/server/tools/impl/semaphore.js
+function createSemaphore(max) {
+  const limit = Number.isInteger(max) && max > 0 ? max : 1;
+  let active = 0;
+  const queue = [];
+  const pump = () => {
+    while (active < limit && queue.length > 0) {
+      const next = queue.shift();
+      if (next === void 0)
+        return;
+      next.start();
+    }
+  };
+  const abortError = () => {
+    const error = new Error("operation aborted");
+    error.name = "AbortError";
+    return error;
+  };
+  const run = (task, signal) => {
+    if (signal?.aborted === true)
+      return Promise.reject(abortError());
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const waiter = {
+        start: () => {
+          if (settled)
+            return;
+          settled = true;
+          signal?.removeEventListener("abort", onAbort);
+          active += 1;
+          try {
+            void task().then(resolve, reject).finally(() => {
+              active -= 1;
+              pump();
+            });
+          } catch (cause) {
+            active -= 1;
+            pump();
+            reject(cause);
+          }
+        }
+      };
+      const onAbort = () => {
+        if (settled)
+          return;
+        const index = queue.indexOf(waiter);
+        if (index >= 0)
+          queue.splice(index, 1);
+        settled = true;
+        signal?.removeEventListener("abort", onAbort);
+        reject(abortError());
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      queue.push(waiter);
+      pump();
+    });
+  };
+  return { run };
+}
+
+// lib/server/tools/impl/precheck.js
+var SECRET_HIT_PATTERNS = [
+  /sk-[A-Za-z0-9]{8,}/,
+  /AKIA[0-9A-Z]{16}/,
+  /ghp_[A-Za-z0-9]{8,}/,
+  /xox[bpas]-[A-Za-z0-9-]+/,
+  /-----BEGIN (?:RSA )?PRIVATE KEY-----/,
+  /api[_-]?key\s*[:=]\s*\S+/i,
+  /password\s*[:=]\s*\S+/i,
+  /secret\s*[:=]\s*\S+/i
+];
+function localPrecheckHit(text) {
+  for (const pattern of SECRET_HIT_PATTERNS) {
+    pattern.lastIndex = 0;
+    if (pattern.test(text))
+      return true;
+  }
+  return false;
+}
+
+// lib/server/tools/impl/validate.js
+function fail(errorCode, message) {
+  return { ok: false, failure: { errorCode, message } };
+}
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function checkQuestion(item) {
+  if (!isRecord3(item))
+    return fail("BAD_QUESTION", "question must be an object");
+  const id = item["id"];
+  const text = item["text"];
+  const kind = item["kind"];
+  if (typeof id !== "string" || id.length === 0 || !QUESTION_ID_RE.test(id) || containsCjk(id)) {
+    return fail("BAD_QUESTION_ID", "question id must be ASCII a-z0-9- 1..64");
+  }
+  if (typeof text !== "string" || Array.from(text).length === 0 || Array.from(text).length > MAX_QUESTION_TEXT || text.trim().length === 0) {
+    return fail("BAD_QUESTION_TEXT", "question text must be 1..255 codepoints and non-blank");
+  }
+  if (kind !== "choice" && kind !== "score") {
+    return fail("BAD_QUESTION_KIND", "question kind must be choice|score");
+  }
+  const options = item["options"];
+  if (kind === "choice") {
+    if (!Array.isArray(options) || options.length < 2 || options.length > 10) {
+      return fail("BAD_OPTIONS", "choice question needs 2..10 options");
+    }
+    for (const opt of options) {
+      if (typeof opt !== "string" || opt.length === 0 || Array.from(opt).length > 64 || opt.trim().length === 0) {
+        return fail("BAD_OPTIONS", "option must be non-empty string <=64 codepoints");
+      }
+    }
+    if (item["levels"] !== void 0) {
+      return fail("BAD_LEVELS", "choice question must not carry levels");
+    }
+    const opts = options.map((opt) => opt);
+    return { ok: true, question: { id, text, kind, options: opts } };
+  }
+  if (options !== void 0) {
+    return fail("BAD_OPTIONS", "score question must not carry options");
+  }
+  const levels = item["levels"];
+  if (levels === void 0)
+    return { ok: true, question: { id, text, kind } };
+  if (!Array.isArray(levels) || levels.length < 2 || levels.length > 10) {
+    return fail("BAD_LEVELS", "score levels must be 2..10 rubric strings (or omit for default 1-5)");
+  }
+  for (const lv of levels) {
+    if (typeof lv !== "string" || lv.length === 0 || Array.from(lv).length > 64 || lv.trim().length === 0) {
+      return fail("BAD_LEVELS", "level must be non-empty string <=64 codepoints");
+    }
+  }
+  return {
+    ok: true,
+    question: { id, text, kind, levels: levels.map((lv) => lv) }
+  };
+}
+function checkOverrideList(raw) {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return fail("EMPTY_OVERRIDE", "questions_override must be a non-empty array");
+  }
+  if (raw.length > MAX_QUESTIONS) {
+    return fail("TOO_MANY_QUESTIONS", "questions_override must hold <=20 questions");
+  }
+  const questions = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    const checked = checkQuestion(item);
+    if (!checked.ok)
+      return checked;
+    if (seen.has(checked.question.id)) {
+      return fail("DUPLICATE_QUESTION_ID", "question ids must be unique");
+    }
+    seen.add(checked.question.id);
+    questions.push(checked.question);
+  }
+  return { ok: true, questions };
+}
+function validateDecideArgs(args, custom) {
+  if (!isRecord3(args))
+    return fail("BAD_ARGS", "args must be an object");
+  const presetRaw = args["preset_id"];
+  if (typeof presetRaw !== "string" || presetRaw.length === 0) {
+    return fail("MISSING_PRESET", "preset_id is required");
+  }
+  if (!PRESET_ID_RE.test(presetRaw) || containsCjk(presetRaw)) {
+    return fail("BAD_PRESET_ID", "preset_id must be ASCII a-z0-9- 1..64");
+  }
+  const template = frozenPresetOf(presetRaw);
+  const customPreset = template === void 0 ? custom?.get(presetRaw) : void 0;
+  if (template === void 0 && customPreset === void 0) {
+    return fail("UNKNOWN_PRESET", "unknown preset");
+  }
+  const state = args["state"];
+  if (!isRecord3(state))
+    return fail("MISSING_STATE", "state is required");
+  const text = state["text"];
+  if (typeof text !== "string" || text.length === 0 || text.trim().length === 0) {
+    return fail("EMPTY_TEXT", "state.text must be a non-blank string");
+  }
+  const langRaw = state["lang"];
+  const lang = langRaw === void 0 ? "unknown" : langRaw;
+  if (lang !== "en" && lang !== "zh" && lang !== "unknown") {
+    return fail("BAD_LANG", "state.lang must be en|zh|unknown");
+  }
+  const override = args["questions_override"];
+  if (override === void 0) {
+    return fail("MISSING_OVERRIDE", "questions_override is required (templates hold no questions)");
+  }
+  const checked = checkOverrideList(override);
+  if (!checked.ok)
+    return checked;
+  return {
+    ok: true,
+    valid: {
+      presetId: presetRaw,
+      text,
+      lang,
+      questions: checked.questions,
+      appliedSource: presetRaw === "custom" || customPreset !== void 0 ? "custom" : "override"
+    }
+  };
+}
+
+// lib/server/tools/impl/service.js
+function envelope(errorCode, category, message) {
+  return { ok: false, error: { errorCode, category, message } };
+}
+function tierOf(index) {
+  return index === 2 ? "high" : index === 1 ? "low" : "none";
+}
+function automationOf(tier, index) {
+  if (tier === "none")
+    return "manual";
+  return index >= 2 ? "auto" : index === 1 ? "assisted" : "manual";
+}
+function isAbortError(cause) {
+  return typeof cause === "object" && cause !== null && "name" in cause && cause.name === "AbortError";
+}
+function safeSessionId(sessionId) {
+  return SESSION_ID_RE.test(sessionId) ? sessionId : "unknown";
+}
+function safeRecord(deps, event) {
+  try {
+    deps.recordEvent?.({ ...event, sessionId: safeSessionId(event.sessionId) });
+  } catch (cause) {
+    deps.logger.warn("dsh-decision-gateway: 历史记录失败 —— " + (cause instanceof Error ? cause.message : String(cause)));
+  }
+}
+async function decide(args, deps) {
+  const customMap = deps.customPresets;
+  const checked = validateDecideArgs(args, customMap);
+  if (!checked.ok)
+    return envelope(checked.failure.errorCode, "bad-request", checked.failure.message);
+  const valid = checked.valid;
+  if (!deps.isEnabled(valid.presetId)) {
+    return envelope("PRESET_DISABLED", "preset-disabled", "preset disabled");
+  }
+  if (deps.signal.aborted) {
+    return envelope("ABORTED", "aborted", "caller aborted");
+  }
+  const direct = (task) => task();
+  const limit = deps.limit ?? direct;
+  const execute = async (runRemote) => {
+    const trunc = truncateCodePoints(valid.text, deps.connection.truncBudget);
+    const now = deps.now ?? Date.now;
+    const cap = deps.capOf(valid.presetId);
+    const started = now();
+    const hit = localPrecheckHit(valid.text);
+    if (hit) {
+      safeRecord(deps, {
+        sessionId: deps.sessionId,
+        precheckHit: true,
+        presetId: valid.presetId,
+        text: valid.text,
+        lang: valid.lang,
+        truncated: trunc.truncated,
+        originalLength: trunc.originalLength,
+        resultKind: "local-precheck",
+        questions: valid.questions,
+        choice: "human",
+        confidence: 1,
+        tier: "none",
+        automation: "manual",
+        latencyMs: 0
+      });
+      return {
+        ok: true,
+        provider: "official",
+        appliedSource: "local-precheck",
+        truncated: trunc.truncated,
+        originalLength: trunc.originalLength,
+        tier: "none",
+        automation: "manual",
+        codepoints: 0,
+        retries: 0,
+        latencyMs: 0,
+        resultKind: "local-precheck",
+        choice: "human",
+        confidence: 1
+      };
+    }
+    const resolved = deps.resolveKey();
+    if (resolved.key === void 0) {
+      safeRecord(deps, {
+        sessionId: deps.sessionId,
+        presetId: valid.presetId,
+        text: valid.text,
+        lang: valid.lang,
+        truncated: trunc.truncated,
+        originalLength: trunc.originalLength,
+        resultKind: "not-executed",
+        questions: valid.questions,
+        precheckHit: hit,
+        confidence: 0,
+        tier: "none",
+        automation: "manual",
+        latencyMs: 0,
+        errorCode: "NO_KEY"
+      });
+      return envelope("NO_KEY", "no-key", "no api key (set apiKeyRef or plaintext)");
+    }
+    const fetchImpl = deps.fetchImpl ?? defaultFetchImpl();
+    const body = {
+      model: JEV_MODEL,
+      state: trunc.text,
+      questions: toWireQuestions(valid.questions)
+    };
+    const outcome = await runRemote(() => callWithRetry(body, resolved.key, deps.connection.timeoutMs, fetchImpl, deps.signal));
+    const latencyMs = now() - started;
+    if (outcome.failure !== void 0 || outcome.verdict === void 0) {
+      const failure = outcome.failure ?? {
+        code: "UPSTREAM",
+        category: "upstream",
+        message: "unknown"
+      };
+      safeRecord(deps, {
+        sessionId: deps.sessionId,
+        presetId: valid.presetId,
+        text: valid.text,
+        lang: valid.lang,
+        truncated: trunc.truncated,
+        originalLength: trunc.originalLength,
+        resultKind: "upstream-error",
+        questions: valid.questions,
+        precheckHit: hit,
+        confidence: 0,
+        tier: "none",
+        automation: "manual",
+        latencyMs,
+        errorCode: failure.code
+      });
+      return envelope(failure.code, failure.category, failure.message);
+    }
+    const verdict = outcome.verdict;
+    const tierIndex = verdict.resultKind === "choice" && verdict.choice === "Noul" ? 0 : Math.min(verdict.tier, cap);
+    const autoIndex = Math.min(verdict.automation, cap);
+    const tier = tierOf(tierIndex);
+    const automation = trunc.truncated ? "suggest-only" : automationOf(tier, autoIndex);
+    const codepoints = verdict.codepoints > 0 ? verdict.codepoints : trunc.originalLength;
+    safeRecord(deps, {
+      sessionId: deps.sessionId,
+      presetId: valid.presetId,
+      text: valid.text,
+      lang: valid.lang,
+      truncated: trunc.truncated,
+      originalLength: trunc.originalLength,
+      resultKind: verdict.resultKind,
+      questions: valid.questions,
+      precheckHit: hit,
+      ...verdict.choice !== void 0 ? { choice: verdict.choice } : {},
+      ...verdict.score !== void 0 ? { score: verdict.score } : {},
+      confidence: verdict.confidence,
+      tier,
+      automation,
+      latencyMs
+    });
+    return {
+      ok: true,
+      provider: "official",
+      appliedSource: valid.appliedSource,
+      truncated: trunc.truncated,
+      originalLength: trunc.originalLength,
+      tier,
+      automation,
+      codepoints,
+      retries: outcome.retries,
+      latencyMs,
+      resultKind: verdict.resultKind,
+      ...verdict.choice !== void 0 ? { choice: verdict.choice } : {},
+      ...verdict.score !== void 0 ? { score: verdict.score } : {},
+      confidence: verdict.confidence
+    };
+  };
+  try {
+    return await limit(() => execute(direct), deps.signal);
+  } catch (cause) {
+    if (isAbortError(cause)) {
+      return envelope("ABORTED", "aborted", "caller aborted");
+    }
+    throw cause;
+  }
+}
+function listPresets(deps) {
+  const frozen = FROZEN_PRESETS.map((preset) => ({
+    id: preset.id,
+    enabled: deps.isEnabled(preset.id),
+    templateVersion: TEMPLATE_VERSION,
+    automationCap: deps.capOf(preset.id),
+    label: preset.label,
+    description: preset.description,
+    custom: false
+  }));
+  const customs = (deps.customs ?? []).map((preset) => ({
+    id: preset.id,
+    enabled: deps.isEnabled(preset.id),
+    templateVersion: TEMPLATE_VERSION,
+    automationCap: deps.capOf(preset.id),
+    label: preset.label,
+    description: preset.description,
+    custom: true
+  }));
+  return [...frozen, ...customs];
+}
+
+// lib/server/tools/impl/define.js
+function sessionOf(exec) {
+  if (exec !== null && typeof exec === "object") {
+    const rec = exec;
+    const direct = rec["sessionId"];
+    if (typeof direct === "string" && direct.length > 0)
+      return direct;
+    for (const key of ["session", "agent"]) {
+      const nested = rec[key];
+      if (nested !== null && typeof nested === "object") {
+        const id = nested["id"];
+        if (typeof id === "string" && id.length > 0)
+          return id;
+      }
+    }
+  }
+  return "unknown";
+}
+function rootOf(exec) {
+  if (exec !== null && typeof exec === "object") {
+    const rec = exec;
+    for (const key of ["cwd", "root", "workdir"]) {
+      const value = rec[key];
+      if (typeof value === "string" && value.length > 0)
+        return value;
+    }
+  }
+  return process.cwd();
+}
+function renderJson(_args, value) {
+  return [{ type: "text", text: JSON.stringify(value) }];
+}
+function buildToolDefinitions(assembly) {
+  const decideTool = {
+    name: "ws_request_verdict",
+    description: "WHEN you must decide rather than generate text, call this after ws_list_verdict_guides: the list tells you which preset is enabled and how to shape questions_override, this tool returns the verdict your code branches on. Ask the JEV SystemOne model for a calibrated judgment over text you supply. Ask in English when you can: state, instructions and options calibrate best in English; Chinese is fully supported (lang zh) but may return slightly lower confidence. USE for three kinds: pick one option from 2-10 candidates (general for a frozen choice, custom for your own choice), rate a plan 1-5 (plan-review for a frozen score, custom for your own score with 2-10 levels), or gate a risky change as safe or risky (risk-check), check text for leaked secrets (secret-leak), or ask any custom question set (custom). DO NOT use for open-ended reasoning, writing, or performing actions: this tool only judges and returns a verdict, acting on it is always your decision. You MUST supply questions_override on every call (1-20 questions; templates store no questions): choice questions need 2-10 options, score questions must not carry options but may carry levels (2-10 rubric strings, default 1-5, e.g. five levels 1-5 or two levels low-high rescaled to 1-5), question ids and preset_id must be lowercase ASCII letters, digits or hyphens; preset_id is one of the 5 frozen ids or a custom id from ws_list_verdict_guides; lang is en, zh, or unknown and defaults to unknown. Texts matching secret shapes (API keys, tokens, private-key blocks, password assignments) never leave the device and return choice human for a person to review; choice Noul likewise means abstention and forces tier none for a person to review. A disabled preset fails with PRESET_DISABLED: check availability first with ws_list_verdict_guides. Success returns choice or score plus confidence 0-1, tier (none/low/high, derived as confidence ≥0.8 high, ≥0.5 low, else none) and automation (manual/assisted/auto/suggest-only, advisory only: truncated inputs force suggest-only, except local-precheck routing which stays manual). Failures carry errorCode and category (for example NO_KEY, UPSTREAM, RATE_LIMITED, TIMEOUT). Without a configured key every call fails NO_KEY: ask the user to configure one in settings. Enable secret-leak only when you must check untrusted text for real secrets; it stays disabled by default and still runs local precheck first.",
+    parameters: {
+      type: "object",
+      properties: {
+        preset_id: {
+          type: "string",
+          description: "Which decision template to apply: one of the 5 frozen ids (general, secret-leak, plan-review, risk-check, custom) or a user-created custom preset id. Frozen ids are fixed; custom ids are the custom:true entries returned by ws_list_verdict_guides. general takes a 2-10-candidate choice; plan-review takes score questions with no options; risk-check takes a proceed-or-not choice (options like safe/risky); secret-leak takes a leaked-or-clean check and is disabled by default; custom takes any 1-20 questions you supply, with the first question driving the verdict."
+        },
+        state: {
+          type: "object",
+          description: "The content under review.",
+          properties: {
+            text: {
+              type: "string",
+              description: "The text to judge; must be non-blank. Over-long text is truncated (see truncated/originalLength in the verdict)."
+            },
+            lang: {
+              type: "string",
+              enum: ["en", "zh", "unknown"],
+              default: "unknown",
+              description: "Language of text (optional, defaults to unknown; en or zh when known)."
+            }
+          },
+          required: ["text"]
+        },
+        questions_override: {
+          type: "array",
+          description: "Full question set for this call, 1-20 questions (required; templates store no questions). ids must be unique.",
+          items: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string",
+                description: "Question id: ASCII lowercase letters, digits or hyphens, 1-64 chars."
+              },
+              text: {
+                type: "string",
+                description: "Question text: 1-255 chars, must be non-blank."
+              },
+              kind: {
+                type: "string",
+                enum: ["choice", "score"],
+                description: "choice picks one option; score rates 1-5."
+              },
+              options: {
+                type: "array",
+                items: { type: "string" },
+                description: "Choice only: 2-10 non-empty options (each 64 chars max). Forbidden on score questions."
+              },
+              levels: {
+                type: "array",
+                items: { type: "string" },
+                description: "Score only: 2-10 rubric level descriptions (default 1-5 when omitted). Forbidden on choice questions."
+              }
+            },
+            required: ["id", "text", "kind"]
+          }
+        }
+      },
+      required: ["preset_id", "state", "questions_override"]
+    },
+    output: {
+      schema: { type: "object" },
+      render: renderJson
+    },
+    isConcurrencySafe: () => true,
+    execute: (args, exec) => {
+      const base = assembly.depsFor(exec);
+      return decide(args, base);
+    }
+  };
+  const listTool = {
+    name: "ws_list_verdict_guides",
+    description: "WHEN you need to know which preset to use or how to shape questions_override, call this first; WHEN NOT to call it is when you already know the enabled preset and its asking conventions. List the frozen JEV preset catalogue with live enabled state (read-only: no network, no history). Each entry carries its English asking guide (how to shape questions_override for it), templateVersion (always 1) and automationCap (0 manual-only, 1 low, 2 high). Call this before ws_request_verdict to check a preset is enabled and to copy its asking conventions; custom:true entries are user-created presets you can also use as preset_id.",
+    parameters: { type: "object", properties: {} },
+    output: {
+      schema: { type: "array" },
+      render: renderJson
+    },
+    isConcurrencySafe: () => true,
+    execute: () => Promise.resolve(listPresets(assembly.snapshot()))
+  };
+  return [decideTool, listTool];
+}
+
+// lib/server/tools/impl/probe.js
+async function probeConnection(input) {
+  if (input.key === void 0) {
+    return { ok: false, errorCode: "NO_KEY", category: "no-key", message: "no api key" };
+  }
+  const started = Date.now();
+  const outcome = await callWithRetry({
+    model: JEV_MODEL,
+    state: "connection probe",
+    questions: toWireQuestions([
+      { id: "probe", text: "Reply ok.", kind: "choice", options: ["ok", "fail"] }
+    ])
+  }, input.key, input.timeoutMs, input.fetchImpl ?? defaultFetchImpl());
+  if (outcome.failure !== void 0 || outcome.verdict === void 0) {
+    const failure = outcome.failure ?? {
+      code: "UPSTREAM",
+      category: "upstream",
+      message: "unknown"
+    };
+    return {
+      ok: false,
+      errorCode: failure.code,
+      category: failure.category,
+      message: failure.message
+    };
+  }
+  return { ok: true, latencyMs: Date.now() - started };
+}
+
+// lib/server/upgrade/impl/steps.js
+function ensureSeeded(home, seed, io) {
+  const created = [];
+  const targets = [
+    [configFile(home), seed.configJson],
+    [presetsFile(home), seed.presetsJson],
+    [secretsFile(home), seed.secretsJson]
+  ];
+  for (const [file, content] of targets) {
+    if (!io.readTextSync(file).ok) {
+      io.atomicWrite0600Sync(file, content);
+      created.push(file);
+    }
+  }
+  return created;
+}
+
+// lib/server/upgrade/impl/service.js
+var STORAGE_TARGET = "0.2.6";
+function configPorts(deps) {
+  return { io: deps.io, logger: deps.logger };
+}
+function migrate(deps) {
+  const target = deps.targetOverride ?? STORAGE_TARGET;
+  const raw = readStoredVersion(deps.home, configPorts(deps));
+  const stored = raw === BASELINE_VERSION ? "0" : raw;
+  const order = compareVersions(stored, target);
+  if (order > 0) {
+    throw new Error("upgrade[500]: unknown future storage version " + stored + " (target " + target + "): refusing to start — 请升级插件后再试");
+  }
+  if (order === 0)
+    return { from: stored, to: target, seeded: [] };
+  const seeded = ensureSeeded(deps.home, deps.seedDefaults(), deps.io);
+  writeStoredVersion(deps.home, target, configPorts(deps));
+  if (deps.logger.info !== void 0)
+    deps.logger.info("dsh-decision-gateway: 存储已锚定 " + stored + " → " + target);
+  return { from: stored, to: target, seeded };
+}
+function installUpgrade(deps) {
+  return migrate(deps);
+}
+
+// lib/index.js
+var name = "decision-gateway";
+var inject = ["webServer", "tools", "sessions", "sessionTitle"];
+function bindHost(ctx) {
+  return {
+    logger: ctx.logger,
+    register: (route) => ctx.webServer.register(route),
+    registerTool: (tool) => ctx.tools.register(tool),
+    sessions: ctx.sessions,
+    sessionTitle: ctx.sessionTitle
+  };
+}
+function assemble(host, options) {
+  const disposers = [];
+  const home = options.home;
+  const env = options.env ?? process.env;
+  installUpgrade({
+    io: {
+      readJsonSync,
+      readTextSync,
+      atomicWrite0600Sync,
+      listFilesSync
+    },
+    logger: host.logger,
+    home,
+    seedDefaults: () => {
+      const defaults = buildDefaultConfig();
+      return {
+        configJson: JSON.stringify(defaults, null, 2) + "\n",
+        presetsJson: JSON.stringify({ presets: defaults.presets }, null, 2) + "\n",
+        secretsJson: JSON.stringify({}, null, 2) + "\n"
+      };
+    }
+  });
+  const storeIo = {
+    readJsonSync,
+    readTextSync,
+    atomicWrite0600Sync
+  };
+  const configDeps = { io: storeIo, logger: host.logger };
+  const historyDeps = {
+    io: {
+      readTextSync,
+      atomicWrite0600Sync,
+      listFilesSync,
+      mtimeMs,
+      removeFileSync,
+      ensureDir0700
+    },
+    logger: host.logger
+  };
+  const live = () => loadState(home, configDeps);
+  const customOf = (state, presetId) => state.customPresets.find((entry) => entry.id === presetId);
+  const enabledOf = (state, presetId) => state.config.presets.find((entry) => entry.id === presetId)?.enabled ?? customOf(state, presetId)?.enabled ?? false;
+  const capOfState = (state, presetId) => {
+    const cap = state.config.presets.find((entry) => entry.id === presetId)?.automationCap ?? customOf(state, presetId)?.automationCap;
+    return cap === 1 || cap === 2 ? cap : 0;
+  };
+  const customMapOf = (state) => new Map(state.customPresets.map((entry) => [entry.id, entry]));
+  const titleOf = (state, presetId) => state.config.presets.find((entry) => entry.id === presetId) !== void 0 ? frozenPresetOf(presetId)?.label ?? presetId : customOf(state, presetId)?.label ?? presetId;
+  const sessionTitleOf = (sessionId) => {
+    try {
+      const session = host.sessions?.get(sessionId);
+      if (session === void 0)
+        return {};
+      const snapshot = host.sessionTitle?.get(session);
+      const title = snapshot?.title;
+      if (typeof title !== "string" || title.length === 0)
+        return {};
+      return { sessionTitle: title };
+    } catch {
+      return {};
+    }
+  };
+  let gate = createSemaphore(live().config.connection.maxConcurrency);
+  const gateFor = (maxConcurrency) => {
+    gate = createSemaphore(maxConcurrency);
+    return gate.run;
+  };
+  let lastConcurrency = live().config.connection.maxConcurrency;
+  const resolveRoot = (exec, sessionId) => {
+    try {
+      const cwd = host.sessions?.get(sessionId)?.header.cwd;
+      if (typeof cwd === "string" && cwd.length > 0)
+        return cwd;
+    } catch {
+    }
+    return rootOf(exec);
+  };
+  const depsFor = (exec) => {
+    const state = live();
+    const sessionId = sessionOf(exec);
+    const root = resolveRoot(exec, sessionId);
+    if (state.config.connection.maxConcurrency !== lastConcurrency) {
+      lastConcurrency = state.config.connection.maxConcurrency;
+      gateFor(lastConcurrency);
+    }
+    return {
+      logger: host.logger,
+      signal: exec.signal,
+      connection: state.config.connection,
+      isEnabled: (presetId) => enabledOf(state, presetId),
+      capOf: (presetId) => capOfState(state, presetId),
+      customPresets: customMapOf(state),
+      resolveKey: () => resolveApiKey(state, env, configDeps),
+      recordEvent: (event) => {
+        const entry = assembleEntry(root, event.sessionId, event, Date.now());
+        appendEntry(home, entry, state.config.history, historyDeps);
+      },
+      fetchImpl: options.fetchImpl,
+      limit: gate.run,
+      root,
+      sessionId
+    };
+  };
+  const apiDeps = {
+    logger: host.logger,
+    register: (route) => host.register(route),
+    version: () => pluginVersion(),
+    readConfig: () => toMaskedConfig(live()),
+    writeConfig: (body) => {
+      const flat = normalizePutEnvelope(body);
+      if (!flat.ok) {
+        throw new Error(JSON.stringify({
+          status: 400,
+          errorCode: flat.failure.errorCode,
+          category: flat.failure.category,
+          message: flat.failure.message
+        }));
+      }
+      const checked = validatePutBody(flat.flat);
+      if (!checked.ok) {
+        throw new Error(JSON.stringify({
+          status: 400,
+          errorCode: checked.failure.errorCode,
+          category: checked.failure.category,
+          message: checked.failure.message
+        }));
+      }
+      const current = live();
+      const effectiveRef = checked.patch.apiKeyRef !== void 0 ? checked.patch.apiKeyRef : current.config.connection.apiKeyRef;
+      if (checked.patch.apiKeyPlaintext !== void 0 && effectiveRef !== void 0 && effectiveRef !== null) {
+        throw new Error(JSON.stringify({
+          status: 400,
+          errorCode: "MUTUALLY_EXCLUSIVE",
+          category: "mutually-exclusive",
+          message: "clear apiKeyRef (null) before setting plaintext"
+        }));
+      }
+      return toMaskedConfig(savePatch(home, checked.patch, configDeps));
+    },
+    readPresets: () => {
+      const state = live();
+      return listPresets({
+        isEnabled: (id) => enabledOf(state, id),
+        capOf: (id) => capOfState(state, id),
+        customs: state.customPresets
+      }).map((item) => ({ ...item }));
+    },
+    readHistory: (query) => {
+      const state = live();
+      return queryEntries(home, query, historyDeps).map((entry) => ({
+        ...entry,
+        presetTitle: titleOf(state, entry.presetId),
+        ...sessionTitleOf(entry.sessionId)
+      }));
+    },
+    removeHistory: (query) => deleteSession(home, query, historyDeps),
+    probeConnection: async () => {
+      const state = live();
+      const resolved = resolveApiKey(state, env, configDeps);
+      return probeConnection({
+        key: resolved.key,
+        timeoutMs: state.config.connection.timeoutMs,
+        fetchImpl: options.fetchImpl
+      });
+    }
+  };
+  for (const tool of buildToolDefinitions({
+    depsFor,
+    snapshot: () => {
+      const state = live();
+      return {
+        isEnabled: (id) => enabledOf(state, id),
+        capOf: (id) => capOfState(state, id),
+        customs: state.customPresets
+      };
+    }
+  })) {
+    disposers.push(host.registerTool(tool));
+  }
+  for (const dispose of installApi(apiDeps))
+    disposers.push(dispose);
+  return disposers;
+}
+function apply(ctx, config = {}) {
+  if (config.enabled === false)
+    return;
+  const host = bindHost(ctx);
+  let disposers = [];
+  try {
+    disposers = assemble(host, config);
+  } catch (cause) {
+    for (const dispose of disposers.reverse()) {
+      try {
+        dispose();
+      } catch {
+      }
+    }
+    throw cause;
+  }
+  ctx.effect(() => () => {
+    for (const dispose of disposers.reverse()) {
+      try {
+        dispose();
+      } catch (cause) {
+        host.logger.warn("dsh-decision-gateway: 卸载失败 —— " + (cause instanceof Error ? cause.message : String(cause)));
+      }
+    }
+  }, "dsh-decision-gateway");
+}
+export {
+  ROUTES,
+  apply,
+  inject,
+  name
+};