@morehao/dsh-github-trending 0.0.1 → 0.1.2

package/lib/chunk-RXYA5WFW.js

@@ -0,0 +1,2909 @@
+import {
+  __export,
+  execCapture,
+  sanitizedEnv
+} from "./chunk-XLIFTAVL.js";
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  CORE_PROVIDERS: () => CORE_PROVIDERS,
+  DEFAULT_SETTINGS: () => DEFAULT_SETTINGS,
+  PROVIDER_BASE_URLS: () => PROVIDER_BASE_URLS,
+  effectiveBaseURL: () => effectiveBaseURL,
+  isValidTimezone: () => isValidTimezone,
+  normalizeSettings: () => normalizeSettings,
+  toCoreConfig: () => toCoreConfig,
+  toYaml: () => toYaml,
+  validateSettings: () => validateSettings
+});
+import path from "path";
+var DEFAULT_SETTINGS = {
+  model: {
+    provider: "deepseek",
+    mode: "direct",
+    hostProvider: "",
+    baseURL: "",
+    model: "",
+    apiKeyRef: "TRENDING_MODEL_KEY",
+    temperature: 0.2,
+    maxTokens: 2048,
+    allowDegraded: true
+  },
+  repo: {
+    path: "",
+    baseBranch: "main",
+    remote: "origin",
+    commitMode: "branch",
+    authorName: "",
+    authorEmail: ""
+  },
+  pr: {
+    enabled: true,
+    titleTemplate: "chore(trending): add {date} digest",
+    autoMerge: true,
+    labels: []
+  },
+  github: { authMode: "device", tokenRef: "GITHUB_TOKEN" },
+  trending: { since: "daily", languages: ["all", "typescript", "python", "go", "rust"], topN: 25 },
+  output: { dir: "trending" },
+  schedule: { enabled: true, time: "08:30:00", timezone: "Asia/Shanghai" },
+  corePath: "",
+  coreAutoDownload: true
+};
+var PROVIDER_BASE_URLS = {
+  deepseek: "https://api.deepseek.com/v1",
+  "openai-compatible": "",
+  anthropic: ""
+};
+var CORE_PROVIDERS = ["deepseek", "openai-compatible"];
+function str(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+function bool(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function num(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function strArray(value, fallback) {
+  if (!Array.isArray(value)) return fallback;
+  const items = value.filter((item) => typeof item === "string" && item.trim() !== "");
+  return items.length > 0 ? items.map((item) => item.trim()) : fallback;
+}
+function normalizeSettings(input) {
+  const raw = typeof input === "object" && input !== null ? input : {};
+  const model = raw.model ?? {};
+  const repo = raw.repo ?? {};
+  const pr = raw.pr ?? {};
+  const github = raw.github ?? {};
+  const trending = raw.trending ?? {};
+  const output = raw.output ?? {};
+  const schedule = raw.schedule ?? {};
+  const commitMode = str(repo.commitMode, DEFAULT_SETTINGS.repo.commitMode);
+  const authMode = str(github.authMode, DEFAULT_SETTINGS.github.authMode);
+  const since = str(trending.since, DEFAULT_SETTINGS.trending.since);
+  return {
+    model: {
+      provider: str(model.provider, DEFAULT_SETTINGS.model.provider),
+      mode: str(model.mode, DEFAULT_SETTINGS.model.mode) === "proxy" ? "proxy" : "direct",
+      hostProvider: str(model.hostProvider, DEFAULT_SETTINGS.model.hostProvider).trim(),
+      baseURL: str(model.baseURL, DEFAULT_SETTINGS.model.baseURL).trim(),
+      model: str(model.model, DEFAULT_SETTINGS.model.model).trim(),
+      apiKeyRef: str(model.apiKeyRef, DEFAULT_SETTINGS.model.apiKeyRef).trim() || DEFAULT_SETTINGS.model.apiKeyRef,
+      temperature: num(model.temperature, DEFAULT_SETTINGS.model.temperature),
+      maxTokens: num(model.maxTokens, DEFAULT_SETTINGS.model.maxTokens),
+      allowDegraded: bool(model.allowDegraded, DEFAULT_SETTINGS.model.allowDegraded)
+    },
+    repo: {
+      path: str(repo.path, DEFAULT_SETTINGS.repo.path).trim(),
+      baseBranch: str(repo.baseBranch, DEFAULT_SETTINGS.repo.baseBranch).trim() || "main",
+      remote: str(repo.remote, DEFAULT_SETTINGS.repo.remote).trim() || "origin",
+      commitMode: commitMode === "direct" ? "direct" : "branch",
+      authorName: str(repo.authorName, DEFAULT_SETTINGS.repo.authorName).trim(),
+      authorEmail: str(repo.authorEmail, DEFAULT_SETTINGS.repo.authorEmail).trim()
+    },
+    pr: {
+      enabled: bool(pr.enabled, DEFAULT_SETTINGS.pr.enabled),
+      titleTemplate: str(pr.titleTemplate, DEFAULT_SETTINGS.pr.titleTemplate),
+      autoMerge: bool(pr.autoMerge, DEFAULT_SETTINGS.pr.autoMerge),
+      labels: strArray(pr.labels, DEFAULT_SETTINGS.pr.labels)
+    },
+    github: {
+      authMode: authMode === "pat" || authMode === "gh" ? authMode : "device",
+      tokenRef: str(github.tokenRef, DEFAULT_SETTINGS.github.tokenRef).trim() || DEFAULT_SETTINGS.github.tokenRef
+    },
+    trending: {
+      since: since === "weekly" ? "weekly" : "daily",
+      languages: strArray(trending.languages, DEFAULT_SETTINGS.trending.languages),
+      topN: Math.round(num(trending.topN, DEFAULT_SETTINGS.trending.topN))
+    },
+    output: {
+      dir: str(output.dir, DEFAULT_SETTINGS.output.dir).trim() || DEFAULT_SETTINGS.output.dir
+    },
+    schedule: {
+      enabled: bool(schedule.enabled, DEFAULT_SETTINGS.schedule.enabled),
+      time: str(schedule.time, DEFAULT_SETTINGS.schedule.time),
+      timezone: str(schedule.timezone, DEFAULT_SETTINGS.schedule.timezone)
+    },
+    corePath: str(raw.corePath, DEFAULT_SETTINGS.corePath).trim(),
+    coreAutoDownload: bool(raw.coreAutoDownload, DEFAULT_SETTINGS.coreAutoDownload)
+  };
+}
+var TIME_RE = /^([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d))?$/;
+function isValidTimezone(timezone) {
+  if (timezone.trim() === "") return false;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: timezone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateSettings(settings, providers = CORE_PROVIDERS) {
+  const problems = [];
+  const { model, repo, trending, output, schedule } = settings;
+  if (model.provider.trim() === "") {
+    problems.push({ field: "model.provider", code: "CONFIG_INVALID", message: "\u7F3A\u5C11 provider" });
+  } else if (!providers.includes(model.provider)) {
+    problems.push({
+      field: "model.provider",
+      code: "MODEL_PROVIDER_UNSUPPORTED",
+      message: `\u6838\u5FC3\u4E0D\u652F\u6301 provider\u300C${model.provider}\u300D\uFF1B\u53EF\u7528\uFF1A${providers.join(" / ")}`
+    });
+  }
+  if (model.model.trim() === "") {
+    problems.push({ field: "model.model", code: "CONFIG_INVALID", message: "\u5FC5\u987B\u586B\u6A21\u578B ID\uFF08\u63D2\u4EF6\u4E0D\u8BBE\u9690\u5F0F\u9ED8\u8BA4\u6A21\u578B\uFF09" });
+  }
+  const baseURL = model.baseURL || PROVIDER_BASE_URLS[model.provider] || "";
+  if (baseURL === "") {
+    problems.push({ field: "model.baseURL", code: "CONFIG_INVALID", message: "\u8BE5 provider \u9700\u8981\u663E\u5F0F baseURL" });
+  } else if (!/^https?:\/\//.test(baseURL)) {
+    problems.push({ field: "model.baseURL", code: "CONFIG_INVALID", message: "baseURL \u5FC5\u987B\u662F http(s) \u5730\u5740" });
+  }
+  if (model.temperature < 0 || model.temperature > 2) {
+    problems.push({ field: "model.temperature", code: "CONFIG_INVALID", message: "temperature \u5FC5\u987B\u5728 0\u20132 \u4E4B\u95F4" });
+  }
+  if (!Number.isInteger(model.maxTokens) || model.maxTokens <= 0) {
+    problems.push({ field: "model.maxTokens", code: "CONFIG_INVALID", message: "maxTokens \u5FC5\u987B\u662F\u6B63\u6574\u6570" });
+  }
+  if (repo.path.trim() === "") {
+    problems.push({ field: "repo.path", code: "CONFIG_INVALID", message: "\u5FC5\u987B\u9009\u62E9\u5F52\u6863\u4ED3\u5E93\u76EE\u5F55" });
+  } else if (!path.isAbsolute(repo.path)) {
+    problems.push({ field: "repo.path", code: "CONFIG_INVALID", message: "\u4ED3\u5E93\u8DEF\u5F84\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84" });
+  }
+  if (!Number.isInteger(trending.topN) || trending.topN <= 0) {
+    problems.push({ field: "trending.topN", code: "CONFIG_INVALID", message: "\u6BCF\u8BED\u8A00\u6761\u6570\u5FC5\u987B\u662F\u6B63\u6574\u6570" });
+  }
+  if (output.dir.trim() === "" || path.isAbsolute(output.dir) || output.dir.split(/[\\/]/).includes("..")) {
+    problems.push({ field: "output.dir", code: "CONFIG_INVALID", message: "\u8F93\u51FA\u76EE\u5F55\u5FC5\u987B\u662F\u4ED3\u5E93\u5185\u7684\u76F8\u5BF9\u8DEF\u5F84\uFF0C\u4E14\u4E0D\u542B .." });
+  }
+  if (!TIME_RE.test(schedule.time)) {
+    problems.push({ field: "schedule.time", code: "CONFIG_INVALID", message: "\u65F6\u95F4\u683C\u5F0F\u5FC5\u987B\u662F HH:MM \u6216 HH:MM:SS" });
+  }
+  if (!isValidTimezone(schedule.timezone)) {
+    problems.push({ field: "schedule.timezone", code: "CONFIG_INVALID", message: "\u65F6\u533A\u5FC5\u987B\u662F IANA \u540D\u79F0\uFF08\u5982 Asia/Shanghai\uFF09" });
+  }
+  return problems;
+}
+function effectiveBaseURL(model) {
+  return model.baseURL !== "" ? model.baseURL : PROVIDER_BASE_URLS[model.provider] ?? "";
+}
+function toCoreConfig(settings, apiKey, baseURLOverride) {
+  const config = {
+    model: {
+      provider: settings.model.provider,
+      name: settings.model.model,
+      baseURL: baseURLOverride ?? effectiveBaseURL(settings.model),
+      apiKey,
+      temperature: settings.model.temperature,
+      maxTokens: settings.model.maxTokens,
+      allowDegraded: settings.model.allowDegraded
+    },
+    repo: {
+      path: settings.repo.path,
+      remote: settings.repo.remote,
+      baseBranch: settings.repo.baseBranch,
+      ...settings.repo.authorName !== "" ? { authorName: settings.repo.authorName } : {},
+      ...settings.repo.authorEmail !== "" ? { authorEmail: settings.repo.authorEmail } : {}
+    },
+    pr: {
+      enabled: settings.repo.commitMode === "branch" && settings.pr.enabled,
+      titleTemplate: settings.pr.titleTemplate,
+      labels: settings.pr.labels,
+      autoMerge: settings.pr.autoMerge
+    },
+    trending: {
+      languages: settings.trending.languages,
+      since: settings.trending.since,
+      perLanguage: settings.trending.topN
+    },
+    output: {
+      dir: settings.output.dir,
+      branchPrefix: "trending/",
+      retentionDays: 90
+    }
+  };
+  return config;
+}
+function toYaml(value, depth = 0) {
+  const pad = "  ".repeat(depth);
+  if (Array.isArray(value)) return toYamlScalar(value);
+  if (typeof value === "object" && value !== null) {
+    const lines = [];
+    for (const [key, item] of Object.entries(value)) {
+      if (item === void 0) continue;
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        lines.push(`${pad}${key}:
+${toYaml(item, depth + 1)}`);
+      } else {
+        lines.push(`${pad}${key}: ${toYamlScalar(item)}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  return `${pad}${toYamlScalar(value)}`;
+}
+function toYamlScalar(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => toYamlScalar(item)).join(", ")}]`;
+  if (typeof value === "object" && value !== null) return JSON.stringify(value);
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "0";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return "null";
+}
+
+// src/paths.ts
+var paths_exports = {};
+__export(paths_exports, {
+  HISTORY_FILE: () => HISTORY_FILE,
+  PLUGIN_DIR_NAME: () => PLUGIN_DIR_NAME,
+  SETTINGS_FILE: () => SETTINGS_FILE,
+  STATE_FILE: () => STATE_FILE,
+  dataDir: () => dataDir,
+  dshHome: () => dshHome,
+  homeDir: () => homeDir,
+  runsDir: () => runsDir
+});
+import os from "os";
+import path2 from "path";
+var PLUGIN_DIR_NAME = "github-trending";
+function homeDir(env = process.env) {
+  const raw = env.HOME?.trim();
+  return raw !== void 0 && raw !== "" ? path2.resolve(raw) : os.homedir();
+}
+function dshHome(env = process.env) {
+  const raw = env.DSH_HOME?.trim();
+  return raw !== void 0 && raw !== "" ? path2.resolve(raw) : path2.join(homeDir(env), ".dsh");
+}
+function dataDir(env = process.env) {
+  const raw = env.TRENDING_DIGEST_HOME?.trim();
+  if (raw !== void 0 && raw !== "") return path2.resolve(raw);
+  return path2.join(dshHome(env), PLUGIN_DIR_NAME);
+}
+function runsDir(env = process.env) {
+  return path2.join(dataDir(env), "runs");
+}
+var SETTINGS_FILE = "settings.json";
+var STATE_FILE = "state.json";
+var HISTORY_FILE = "history.json";
+
+// src/state.ts
+var state_exports = {};
+__export(state_exports, {
+  HISTORY_LIMIT: () => HISTORY_LIMIT,
+  Store: () => Store,
+  newRunId: () => newRunId,
+  writeJsonAtomic: () => writeJsonAtomic
+});
+import { mkdirSync, readFileSync, renameSync, writeFileSync, appendFileSync, existsSync } from "fs";
+import path3 from "path";
+var HISTORY_LIMIT = 30;
+function readJson(file, fallback) {
+  try {
+    const text = readFileSync(file, "utf8");
+    const value = JSON.parse(text);
+    if (typeof value === "object" && value !== null) return value;
+    return fallback;
+  } catch {
+    return fallback;
+  }
+}
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+}
+function writeJsonAtomic(file, value) {
+  ensureDir(path3.dirname(file));
+  const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(temp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  renameSync(temp, file);
+}
+var Store = class {
+  dir;
+  env;
+  constructor(options = {}) {
+    this.env = options.env ?? process.env;
+    this.dir = options.dir ?? dataDir(this.env);
+  }
+  get settingsPath() {
+    return path3.join(this.dir, SETTINGS_FILE);
+  }
+  get statePath() {
+    return path3.join(this.dir, STATE_FILE);
+  }
+  get historyPath() {
+    return path3.join(this.dir, HISTORY_FILE);
+  }
+  get logsPath() {
+    return runsDir(this.env);
+  }
+  readSettings() {
+    return normalizeSettings(readJson(this.settingsPath, {}));
+  }
+  writeSettings(settings) {
+    writeJsonAtomic(this.settingsPath, settings);
+  }
+  readState() {
+    return readJson(this.statePath, {});
+  }
+  writeState(state) {
+    writeJsonAtomic(this.statePath, state);
+  }
+  readHistory() {
+    const file = readJson(this.historyPath, { records: [] });
+    return Array.isArray(file.records) ? file.records : [];
+  }
+  /** 记录一次运行：历史裁剪到 30 条，state 同步更新。 */
+  recordRun(record, next = {}) {
+    const records = [record, ...this.readHistory()].slice(0, HISTORY_LIMIT);
+    writeJsonAtomic(this.historyPath, { records });
+    const state = this.readState();
+    this.writeState({ ...state, ...next, lastResult: record });
+  }
+  newLogPath(id) {
+    ensureDir(this.logsPath);
+    return path3.join(this.logsPath, `${id}.log`);
+  }
+  appendLog(file, line) {
+    ensureDir(path3.dirname(file));
+    appendFileSync(file, `${line}
+`, { mode: 384 });
+  }
+  hasLog(file) {
+    return existsSync(file);
+  }
+  readLog(file, maxBytes = 64 * 1024) {
+    try {
+      const text = readFileSync(file, "utf8");
+      return text.length > maxBytes ? text.slice(text.length - maxBytes) : text;
+    } catch {
+      return "";
+    }
+  }
+};
+function newRunId(now = /* @__PURE__ */ new Date()) {
+  const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\..+$/, "").replace("T", "-");
+  const random = Math.random().toString(36).slice(2, 8);
+  return `${stamp}-${random}`;
+}
+
+// src/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  PLUGIN_CODES: () => PLUGIN_CODES,
+  areaOf: () => areaOf,
+  classifyStderr: () => classifyStderr,
+  hintOf: () => hintOf,
+  isRetriable: () => isRetriable,
+  redact: () => redact
+});
+var PLUGIN_CODES = [
+  "CORE_UNAVAILABLE",
+  "CORE_INCOMPATIBLE",
+  "CORE_SPAWN_FAILED",
+  "CORE_TIMEOUT",
+  "CORE_CANCELLED",
+  "CORE_CONFIG_CHANNEL_FAILED",
+  "CORE_NOT_DOWNLOADED",
+  "CORE_CHECKSUM_MISMATCH",
+  "IPC_INVALID",
+  "MODEL_KEY_MISSING",
+  "MODEL_NOT_FOUND",
+  "MODEL_PROVIDER_UNSUPPORTED",
+  "GITHUB_AUTH",
+  "PUSH_FAILED",
+  "REPO_DIRTY"
+];
+var RETRIABLE = {
+  INTERNAL: true,
+  CONFIG_INVALID: false,
+  PAYLOAD_TOO_LARGE: false,
+  FETCH_FAILED: false,
+  FETCH_RATE_LIMITED: true,
+  PARSE_FAILED: false,
+  MODEL_UNAUTHORIZED: false,
+  MODEL_RATE_LIMITED: true,
+  MODEL_TIMEOUT: true,
+  MODEL_FAILED: true,
+  MODEL_BAD_OUTPUT: false,
+  GIT_NOT_INSTALLED: false,
+  REPO_NOT_GIT: false,
+  REPO_DIRTY: false,
+  GIT_OPERATION_FAILED: true,
+  PR_FAILED: true,
+  NOT_MERGEABLE: false,
+  CORE_UNAVAILABLE: false,
+  CORE_INCOMPATIBLE: false,
+  CORE_SPAWN_FAILED: true,
+  CORE_TIMEOUT: true,
+  CORE_CANCELLED: false,
+  CORE_CONFIG_CHANNEL_FAILED: true,
+  CORE_NOT_DOWNLOADED: false,
+  CORE_CHECKSUM_MISMATCH: true,
+  IPC_INVALID: false,
+  MODEL_KEY_MISSING: false,
+  MODEL_NOT_FOUND: false,
+  MODEL_PROVIDER_UNSUPPORTED: false,
+  GITHUB_AUTH: false,
+  PUSH_FAILED: true
+};
+function isRetriable(code) {
+  return RETRIABLE[code] === true;
+}
+function areaOf(code) {
+  if (code.startsWith("CORE_") || code === "IPC_INVALID") return "core";
+  if (code.startsWith("MODEL_")) return "model";
+  if (code.startsWith("REPO_") || code === "GIT_NOT_INSTALLED" || code === "GIT_OPERATION_FAILED") return "repo";
+  if (code === "GITHUB_AUTH") return "auth";
+  return "run";
+}
+function hintOf(code) {
+  switch (code) {
+    case "CORE_UNAVAILABLE":
+      return "\u6838\u5FC3\u4E8C\u8FDB\u5236\u6CA1\u627E\u5230\uFF1A\u786E\u8BA4\u63D2\u4EF6\u5B89\u88C5\u5B8C\u6574\uFF08\u542B\u5E73\u53F0\u5305\uFF09\uFF0C\u6216\u7528 TRENDING_DIGEST_CORE \u6307\u5411\u4E00\u4E2A\u53EF\u6267\u884C\u7684 trendradar\u3002";
+    case "CORE_INCOMPATIBLE":
+      return "\u6838\u5FC3\u534F\u8BAE\u7248\u672C\u4E0D\u5339\u914D\uFF1A\u5347\u7EA7\u63D2\u4EF6\uFF08\u6216\u5347\u7EA7\u6838\u5FC3\uFF09\uFF0C\u4E0D\u8981\u6DF7\u642D\u7248\u672C\u3002";
+    case "CORE_TIMEOUT":
+      return "\u6838\u5FC3\u8D85\u65F6\u672A\u8FD4\u56DE\uFF1A\u68C0\u67E5\u7F51\u7EDC\u4E0E\u6A21\u578B\u7AEF\u70B9\uFF1B\u8D85\u65F6\u540E\u4E0D\u4F1A\u63D0\u4EA4\u4EFB\u4F55\u72B6\u6001\u3002";
+    case "CORE_CANCELLED":
+      return "\u8FD0\u884C\u5DF2\u53D6\u6D88\uFF1A\u6838\u5FC3\u5DF2\u7EC8\u6B62\uFF0C\u672A\u63D0\u4EA4\u72B6\u6001\uFF0C\u4E5F\u672A\u7559\u534A\u6210\u54C1\u3002";
+    case "CORE_CONFIG_CHANNEL_FAILED":
+      return "\u914D\u7F6E\u901A\u9053\u5EFA\u7ACB\u5931\u8D25\uFF08FIFO \u4E0D\u53EF\u7528\uFF09\uFF1A\u6539\u7528\u4E34\u65F6\u6587\u4EF6\u6A21\u5F0F\u91CD\u8BD5\uFF0C\u6216\u68C0\u67E5\u76EE\u6807\u6587\u4EF6\u7CFB\u7EDF\u3002";
+    case "CORE_NOT_DOWNLOADED":
+      return "\u6838\u5FC3\u8FD8\u6CA1\u4E0B\u8F7D\uFF1A\u5728\u8BBE\u7F6E\u9875\u70B9\u300C\u4E0B\u8F7D\u6838\u5FC3\u300D\uFF08\u6216\u7528 TRENDING_DIGEST_CORE \u6307\u5411\u672C\u5730\u6838\u5FC3\uFF09\u3002\u9996\u6B21\u8FD0\u884C\u9700\u8981\u8054\u7F51\u3002";
+    case "CORE_CHECKSUM_MISMATCH":
+      return "\u6838\u5FC3\u4E8C\u8FDB\u5236\u6821\u9A8C\u5931\u8D25\u4E14\u5DF2\u4E22\u5F03\uFF1A\u7F51\u7EDC\u4EE3\u7406\u53EF\u80FD\u6539\u5199\u4E86\u5185\u5BB9\uFF0C\u91CD\u8BD5\u4E00\u6B21\uFF1B\u4ECD\u5931\u8D25\u8BF7\u624B\u52A8\u4E0B\u8F7D\u540E\u653E\u5230\u7F13\u5B58\u76EE\u5F55\u3002";
+    case "IPC_INVALID":
+      return "\u6838\u5FC3\u8F93\u51FA\u4E0D\u662F\u7EA6\u5B9A\u7684\u7ED3\u679C\u4FE1\u5C01\uFF1A\u5347\u7EA7\u63D2\u4EF6\u4E0E\u6838\u5FC3\u5230\u540C\u4E00\u7248\u672C\u3002";
+    case "MODEL_KEY_MISSING":
+      return "\u6CA1\u6709\u53EF\u7528\u7684\u6A21\u578B\u5BC6\u94A5\uFF1A\u5728\u8BBE\u7F6E\u9875\u5FEB\u901F\u586B\u5145\u6216\u624B\u52A8\u586B\u5199\u3002";
+    case "MODEL_UNAUTHORIZED":
+      return "\u5BC6\u94A5\u88AB\u6A21\u578B\u7AEF\u70B9\u62D2\u7EDD\uFF1A\u91CD\u65B0\u9009\u62E9\u6A21\u578B\u6216\u66F4\u65B0\u5BC6\u94A5\u3002";
+    case "MODEL_NOT_FOUND":
+      return "\u7AEF\u70B9\u4E0D\u8BA4\u8BC6\u8FD9\u4E2A\u6A21\u578B ID\uFF1A\u6838\u5BF9\u6A21\u578B\u540D\uFF0C\u6216\u6362\u4E00\u4E2A\u6A21\u578B\u3002";
+    case "MODEL_PROVIDER_UNSUPPORTED":
+      return "\u5F53\u524D\u6838\u5FC3\u4E0D\u652F\u6301\u8FD9\u4E2A provider\uFF1A\u6309\u6838\u5FC3 version --json \u7684 supportedProviders \u9009\u62E9\u3002";
+    case "MODEL_RATE_LIMITED":
+      return "\u6A21\u578B\u9650\u6D41\uFF1A\u7A0D\u540E\u91CD\u8BD5\uFF1B\u7ED3\u679C\u672A\u5199\u5165\u4EFB\u4F55\u6587\u4EF6\u3002";
+    case "GIT_NOT_INSTALLED":
+      return "\u672C\u673A\u6CA1\u6709\u53EF\u7528\u7684 git\uFF1A\u5B89\u88C5 git \u2265 2.30 \u540E\u91CD\u8BD5\u3002";
+    case "REPO_NOT_GIT":
+      return "\u76EE\u6807\u76EE\u5F55\u4E0D\u662F git \u4ED3\u5E93\uFF1A\u63D2\u4EF6\u4E0D\u4F1A\u66FF\u4F60 git init\uFF0C\u8BF7\u5148\u5EFA\u5E93\u6216\u6362\u76EE\u5F55\u3002";
+    case "REPO_DIRTY":
+      return "\u4ED3\u5E93\u6709\u672A\u63D0\u4EA4\u6539\u52A8\uFF1A\u63D2\u4EF6\u4E0D stash\u3001\u4E0D reset\uFF0C\u8BF7\u5148\u5904\u7406\u3002";
+    case "GITHUB_AUTH":
+      return "GitHub \u8BA4\u8BC1\u5931\u6548\uFF1A\u91CD\u65B0\u8FDE\u63A5\u6216\u66F4\u65B0 PAT\uFF1B\u672C\u5730 commit \u4F1A\u4FDD\u7559\uFF0C\u53EF\u76F4\u63A5\u91CD\u8BD5\u3002";
+    case "NOT_MERGEABLE":
+      return "PR \u65E0\u6CD5\u81EA\u52A8\u5408\u5E76\uFF08\u5E38\u89C1\u4E8E\u5206\u652F\u4FDD\u62A4\uFF09\uFF1APR \u5DF2\u4FDD\u7559\uFF0C\u9700\u4EBA\u5DE5\u5904\u7406\u3002";
+    case "PUSH_FAILED":
+      return "\u63A8\u9001\u5931\u8D25\uFF1A\u672C\u5730 commit \u5DF2\u4FDD\u7559\uFF0C\u4FEE\u590D\u6743\u9650/\u7F51\u7EDC\u540E\u91CD\u8BD5\u5373\u53EF\u590D\u7528\u3002";
+    case "PR_FAILED":
+      return "\u521B\u5EFA PR \u5931\u8D25\uFF1A\u672C\u5730 commit \u4E0E\u5206\u652F\u5DF2\u4FDD\u7559\u3002";
+    case "FETCH_FAILED":
+      return "\u6293\u53D6\u5931\u8D25\uFF1A\u68C0\u67E5\u7F51\u7EDC\u6216\u4EE3\u7406\uFF1B\u6838\u5FC3\u4F1A\u5728\u5185\u90E8\u91CD\u8BD5\u4E00\u6B21\u3002";
+    case "FETCH_RATE_LIMITED":
+      return "GitHub \u533F\u540D\u9650\u6D41\uFF1A\u914D\u4E00\u4E2A GitHub token \u6216\u7A0D\u540E\u91CD\u8BD5\u3002";
+    default:
+      return "\u67E5\u770B\u6838\u5FC3\u65E5\u5FD7\uFF08\u6309\u8FD0\u884C id \u5F52\u6863\uFF09\u5B9A\u4F4D\u5931\u8D25\u539F\u56E0\u3002";
+  }
+}
+var CORE_CODES = /* @__PURE__ */ new Set([
+  "INTERNAL",
+  "CONFIG_INVALID",
+  "PAYLOAD_TOO_LARGE",
+  "FETCH_FAILED",
+  "FETCH_RATE_LIMITED",
+  "PARSE_FAILED",
+  "MODEL_UNAUTHORIZED",
+  "MODEL_RATE_LIMITED",
+  "MODEL_TIMEOUT",
+  "MODEL_FAILED",
+  "MODEL_BAD_OUTPUT",
+  "GIT_NOT_INSTALLED",
+  "REPO_NOT_GIT",
+  "REPO_DIRTY",
+  "GIT_OPERATION_FAILED",
+  "PR_FAILED",
+  "NOT_MERGEABLE"
+]);
+var TEXT_RULES = [
+  { pattern: /\b401\b|unauthori[sz]ed|invalid api[ -]?key|incorrect api key|authentication (failed|error)/i, code: "MODEL_UNAUTHORIZED" },
+  { pattern: /\b404\b|model[^\n]*not found|no such model/i, code: "MODEL_NOT_FOUND" },
+  { pattern: /\b429\b|rate[ _-]?limit/i, code: "MODEL_RATE_LIMITED" },
+  { pattern: /timeout|timed out|deadline exceeded|context deadline/i, code: "MODEL_TIMEOUT" },
+  { pattern: /git not found|exec: "git"|git: command not found/i, code: "GIT_NOT_INSTALLED" },
+  { pattern: /not a git (repository|repo)|does not have any commits|bad revision/i, code: "REPO_NOT_GIT" },
+  { pattern: /working tree has tracked changes|dirty working tree/i, code: "REPO_DIRTY" },
+  { pattern: /dial tcp|no such host|connection refused|fetch trending|get "https:/i, code: "FETCH_FAILED" },
+  { pattern: /low level fetch|server misbehaving/i, code: "FETCH_FAILED" }
+];
+function classifyStderr(stderr) {
+  const text = stderr.trim();
+  const lines = text.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  const explicit = /^(?:error:\s*)?([A-Z][A-Z0-9_]+):\s*(.*)$/;
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index] ?? "";
+    const match = explicit.exec(line);
+    if (match !== null && CORE_CODES.has(match[1] ?? "")) {
+      const code = match[1];
+      return { code, message: (match[2] ?? "").trim() || line, retriable: isRetriable(code), inferred: false };
+    }
+  }
+  const message = lines[lines.length - 1] ?? "\u6838\u5FC3\u672A\u8F93\u51FA\u9519\u8BEF\u4FE1\u606F";
+  for (const rule of TEXT_RULES) {
+    if (rule.pattern.test(text)) {
+      return { code: rule.code, message, retriable: isRetriable(rule.code), inferred: true };
+    }
+  }
+  return { code: "INTERNAL", message, retriable: isRetriable("INTERNAL"), inferred: true };
+}
+var SECRET_PATTERNS = [
+  /sk-[A-Za-z0-9_-]{8,}/g,
+  /gh[pousr]_[A-Za-z0-9]{16,}/g,
+  /github_pat_[A-Za-z0-9_]{20,}/g,
+  /(authorization\s*:\s*bearer\s+)\S+/gi,
+  /("?(?:apiKey|api_key|token|access_token|secret)"?\s*[:=]\s*)"[^"]*"/gi
+];
+function redact(input, secrets = []) {
+  let output = input;
+  for (const secret of secrets) {
+    if (typeof secret !== "string" || secret.length < 8) continue;
+    output = output.split(secret).join("***");
+  }
+  for (const pattern of SECRET_PATTERNS) {
+    output = output.replace(
+      pattern,
+      (match, prefix) => typeof prefix === "string" ? `${prefix}"***"` : "***"
+    );
+  }
+  return output;
+}
+
+// src/ipc.ts
+var ipc_exports = {};
+__export(ipc_exports, {
+  IPC_SCHEMA_VERSION: () => IPC_SCHEMA_VERSION,
+  IpcError: () => IpcError,
+  SUPPORTED_DIGEST_SCHEMA: () => SUPPORTED_DIGEST_SCHEMA,
+  isVersionInfo: () => isVersionInfo,
+  parseJsonObject: () => parseJsonObject,
+  parseRunResult: () => parseRunResult,
+  parseVersionInfo: () => parseVersionInfo
+});
+
+// src/ipc.gen.ts
+var IPC_SCHEMA_VERSION = 1;
+
+// src/ipc.ts
+var SUPPORTED_DIGEST_SCHEMA = 1;
+var IpcError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "IpcError";
+    this.code = code;
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonObject(text) {
+  const trimmed = text.trim();
+  if (trimmed === "") throw new IpcError("IPC_INVALID", "\u6838\u5FC3 stdout \u4E3A\u7A7A");
+  let value;
+  try {
+    value = JSON.parse(trimmed);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new IpcError("IPC_INVALID", `\u6838\u5FC3 stdout \u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${detail}`);
+  }
+  if (!isRecord(value)) throw new IpcError("IPC_INVALID", "\u6838\u5FC3 stdout \u4E0D\u662F JSON \u5BF9\u8C61");
+  return value;
+}
+function isVersionInfo(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.version === "string" && typeof value.ipcSchema === "number" && typeof value.digestSchema === "number";
+}
+function parseVersionInfo(text) {
+  const value = parseJsonObject(text);
+  if (!isVersionInfo(value)) {
+    throw new IpcError("IPC_INVALID", "\u6838\u5FC3 version --json \u7F3A\u5C11 version/ipcSchema/digestSchema");
+  }
+  return value;
+}
+function normalizeFiles(value) {
+  if (!Array.isArray(value)) return [];
+  const files = [];
+  for (const item of value) {
+    if (!isRecord(item) || typeof item.path !== "string") continue;
+    files.push({
+      path: item.path,
+      bytes: typeof item.bytes === "number" ? item.bytes : 0,
+      sha256: typeof item.sha256 === "string" ? item.sha256 : ""
+    });
+  }
+  return files;
+}
+function normalizeError(value) {
+  if (!isRecord(value)) return void 0;
+  if (typeof value.code !== "string" || typeof value.message !== "string") return void 0;
+  return {
+    code: value.code,
+    message: value.message,
+    retriable: value.retriable === true,
+    ...isRecord(value.details) ? { details: value.details } : {}
+  };
+}
+function parseRunResult(text, options) {
+  const value = parseJsonObject(text);
+  const contractShaped = value.ipcSchema === IPC_SCHEMA_VERSION && typeof value.ok === "boolean" && value.command === "run";
+  if (contractShaped) {
+    const result = value;
+    return {
+      ok: result.ok,
+      skipped: result.skipped === true,
+      dryRun: options.dryRun,
+      files: normalizeFiles(result.files),
+      contentHash: typeof value.contentHash === "string" ? value.contentHash : void 0,
+      branch: typeof value.branch === "string" ? value.branch : void 0,
+      commit: typeof value.commit === "string" ? value.commit : void 0,
+      prUrl: typeof value.prUrl === "string" ? value.prUrl : void 0,
+      error: normalizeError(result.error),
+      warnings: Array.isArray(result.warnings) ? result.warnings.filter((item) => typeof item === "string") : [],
+      ...timing(options),
+      coreVersion: options.coreVersion
+    };
+  }
+  if (!Array.isArray(value.files)) {
+    throw new IpcError("IPC_INVALID", "\u6838\u5FC3 run --json \u65E2\u4E0D\u662F\u5951\u7EA6 RunResult\uFF0C\u4E5F\u4E0D\u542B files \u6570\u7EC4");
+  }
+  const digest = isRecord(value.digest) ? value.digest : void 0;
+  return {
+    ok: true,
+    skipped: value.skipped === true,
+    dryRun: options.dryRun,
+    files: normalizeFiles(value.files),
+    contentHash: typeof digest?.contentHash === "string" ? digest.contentHash : void 0,
+    branch: typeof value.branch === "string" ? value.branch : void 0,
+    prUrl: typeof value.prUrl === "string" ? value.prUrl : void 0,
+    warnings: [],
+    ...timing(options),
+    coreVersion: options.coreVersion
+  };
+}
+function timing(options) {
+  return { startedAt: options.startedAt, finishedAt: options.finishedAt, durationMs: options.durationMs };
+}
+
+// src/core/handshake.ts
+var handshake_exports = {};
+__export(handshake_exports, {
+  DEFAULT_PROVIDERS: () => DEFAULT_PROVIDERS,
+  handshake: () => handshake
+});
+var DEFAULT_PROVIDERS = ["deepseek", "openai-compatible"];
+async function handshake(core, options = {}) {
+  let result;
+  try {
+    result = await execCapture(core.path, ["version", "--json"], {
+      timeoutMs: options.timeoutMs ?? 5e3,
+      signal: options.signal
+    });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new IpcError("CORE_SPAWN_FAILED", `\u65E0\u6CD5\u6267\u884C\u6838\u5FC3 ${core.path}\uFF1A${detail}`);
+  }
+  if (result.aborted || options.signal?.aborted === true) {
+    throw new IpcError("CORE_CANCELLED", "\u8FD0\u884C\u5DF2\u53D6\u6D88\uFF08\u63E1\u624B\u9636\u6BB5\uFF09\uFF1A\u6838\u5FC3\u8FDB\u7A0B\u5DF2\u7EC8\u6B62\uFF0C\u672A\u63D0\u4EA4\u4EFB\u4F55\u72B6\u6001");
+  }
+  if (result.timedOut) {
+    throw new IpcError("CORE_TIMEOUT", `\u6838\u5FC3 ${core.path} version --json \u8D85\u65F6\uFF085 s\uFF09\u672A\u8FD4\u56DE`);
+  }
+  if (result.code !== 0) {
+    const tail = result.stderr.trim().split("\n").slice(-3).join(" / ");
+    throw new IpcError("CORE_INCOMPATIBLE", `\u6838\u5FC3 version --json \u9000\u51FA\u7801 ${result.code ?? "null"}\uFF1A${tail}`);
+  }
+  let version;
+  try {
+    version = parseVersionInfo(result.stdout);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new IpcError("CORE_INCOMPATIBLE", `\u6838\u5FC3 version --json \u8F93\u51FA\u65E0\u6CD5\u8BC6\u522B\uFF1A${detail}`);
+  }
+  if (version.ipcSchema !== IPC_SCHEMA_VERSION || version.digestSchema !== SUPPORTED_DIGEST_SCHEMA) {
+    throw new IpcError(
+      "CORE_INCOMPATIBLE",
+      `\u6838\u5FC3\u534F\u8BAE\u4E0D\u5339\u914D\uFF1A\u6838\u5FC3 ipcSchema=${version.ipcSchema} digestSchema=${version.digestSchema}\uFF0C\u63D2\u4EF6\u652F\u6301 ipcSchema=${IPC_SCHEMA_VERSION} digestSchema=${SUPPORTED_DIGEST_SCHEMA}\u3002\u8BF7\u628A\u63D2\u4EF6\u4E0E\u6838\u5FC3\u5347\u7EA7\u5230\u540C\u4E00\u7248\u672C\uFF08\u63D2\u4EF6\u5E26\u5E73\u53F0\u5305\uFF0C\u5347\u7EA7\u63D2\u4EF6\u5373\u53EF\uFF09\u3002`
+    );
+  }
+  const supportedProviders = Array.isArray(version.supportedProviders) && version.supportedProviders.length > 0 ? version.supportedProviders : [...DEFAULT_PROVIDERS];
+  return { version, corePath: core.path, durationMs: result.durationMs, supportedProviders };
+}
+
+// src/core/release.ts
+var release_exports = {};
+__export(release_exports, {
+  assetName: () => assetName,
+  describeRelease: () => describeRelease,
+  ensureCore: () => ensureCore,
+  goTarget: () => goTarget,
+  readCoreRelease: () => readCoreRelease,
+  verifyCached: () => verifyCached
+});
+import { createHash } from "crypto";
+import { chmodSync, createWriteStream, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, rmSync, statSync, unlinkSync } from "fs";
+import { createRequire } from "module";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+import path4 from "path";
+var DOWNLOAD_TIMEOUT_MS = 18e4;
+function requireJson() {
+  const require2 = createRequire(import.meta.url);
+  return require2("../package.json");
+}
+function readCoreRelease(pkg) {
+  const source = pkg ?? requireJson();
+  const repo = source.dsh?.core?.repo;
+  const version = source.dsh?.core?.version;
+  if (typeof repo !== "string" || !/^[\w.-]+\/[\w.-]+$/.test(repo)) {
+    throw new IpcError("CORE_UNAVAILABLE", "package.json \u7F3A\u5C11 dsh.core.repo\uFF08owner/repo\uFF09\uFF0C\u65E0\u6CD5\u5B9A\u4F4D\u6838\u5FC3 Release");
+  }
+  if (typeof version !== "string" || !/^\d+\.\d+\.\d+(?:-[\w.]+)?$/.test(version)) {
+    throw new IpcError("CORE_UNAVAILABLE", "package.json \u7F3A\u5C11 dsh.core.version\uFF08\u5F62\u5982 0.1.0\uFF09\uFF0C\u65E0\u6CD5\u5B9A\u4F4D\u6838\u5FC3 Release");
+  }
+  return { repo, version };
+}
+function goTarget(platform = process.platform, arch = process.arch) {
+  const goos = platform === "win32" ? "windows" : platform === "darwin" ? "darwin" : platform === "linux" ? "linux" : platform;
+  const goarch = arch === "x64" ? "amd64" : arch === "arm64" ? "arm64" : arch === "ia32" ? "386" : arch;
+  return { goos, goarch };
+}
+function assetName(platform = process.platform, arch = process.arch) {
+  const { goos, goarch } = goTarget(platform, arch);
+  const suffix = platform === "win32" ? ".exe" : "";
+  return `trendradar_${goos}_${goarch}${suffix}`;
+}
+function binaryName(platform = process.platform) {
+  return platform === "win32" ? "trendradar.exe" : "trendradar";
+}
+function describeRelease(release, options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const { goos, goarch } = goTarget(platform, arch);
+  const asset = assetName(platform, arch);
+  const tag = `v${release.version}`;
+  const base = `https://github.com/${release.repo}/releases/download/${tag}`;
+  const cacheDir = path4.join(dataDir(env), "core", tag);
+  const binaryPath = path4.join(cacheDir, binaryName(platform));
+  return {
+    ...release,
+    tag,
+    goos,
+    goarch,
+    asset,
+    url: `${base}/${asset}`,
+    checksumsUrl: `${base}/checksums.txt`,
+    cacheDir,
+    binaryPath,
+    cached: existsSync2(binaryPath)
+  };
+}
+function sha256File(file) {
+  return createHash("sha256").update(readFileSync2(file)).digest("hex");
+}
+function markerPath(binaryPath) {
+  return `${binaryPath}.sha256`;
+}
+function verifyCached(binaryPath) {
+  let info;
+  try {
+    info = statSync(binaryPath);
+  } catch {
+    return { ok: false, reason: "missing" };
+  }
+  if (!info.isFile()) return { ok: false, reason: "not-a-file" };
+  if (process.platform !== "win32" && (info.mode & 73) === 0) return { ok: false, reason: "not-executable" };
+  const marker = markerPath(binaryPath);
+  if (!existsSync2(marker)) return { ok: true };
+  const expected = readFileSync2(marker, "utf8").trim();
+  if (expected === "") return { ok: true };
+  try {
+    return sha256File(binaryPath) === expected ? { ok: true } : { ok: false, reason: "checksum-mismatch" };
+  } catch {
+    return { ok: false, reason: "unreadable" };
+  }
+}
+function fetchOf(options) {
+  if (options.fetchImpl !== void 0) return options.fetchImpl;
+  if (typeof fetch !== "function") {
+    throw new IpcError("CORE_UNAVAILABLE", "\u5F53\u524D Node \u6CA1\u6709\u5168\u5C40 fetch\uFF08\u9700\u8981 Node \u2265 18\uFF09\uFF0C\u65E0\u6CD5\u4E0B\u8F7D\u6838\u5FC3");
+  }
+  return fetch;
+}
+async function fetchChecksum(descriptor, options) {
+  options.onProgress?.({ phase: "checksums" });
+  const response = await fetchOf(options)(descriptor.checksumsUrl, { signal: AbortSignal.timeout(3e4) }).catch((error) => {
+    throw new IpcError(
+      "CORE_UNAVAILABLE",
+      `\u65E0\u6CD5\u83B7\u53D6\u6838\u5FC3\u6821\u9A8C\u6587\u4EF6\uFF1A${descriptor.checksumsUrl}\uFF08${error instanceof Error ? error.message : String(error)}\uFF09\u3002\u82E5\u5728\u516C\u53F8\u7F51\u7EDC\u5185\uFF0C\u8BF7\u786E\u8BA4\u4EE3\u7406\u53EF\u7528\uFF1B\u4E5F\u53EF\u7528 TRENDING_DIGEST_CORE \u6307\u5411\u672C\u5730\u5DF2\u7F16\u8BD1\u7684\u6838\u5FC3\u3002`
+    );
+  });
+  if (!response.ok) {
+    throw new IpcError(
+      "CORE_UNAVAILABLE",
+      `\u6838\u5FC3 ${descriptor.tag} \u8FD8\u6CA1\u6709\u53D1\u5E03\uFF08${descriptor.checksumsUrl} \u8FD4\u56DE HTTP ${response.status}\uFF09\u3002\u53D1\u5E03\u987A\u5E8F\u662F\u5148\u5728 trendradar \u6253 tag \u5E76\u4E0A\u4F20 Release \u8D44\u4EA7\uFF0C\u63D2\u4EF6\u968F\u540E\u624D\u80FD\u4E0B\u8F7D\u3002`
+    );
+  }
+  const text = await response.text();
+  for (const line of text.split("\n")) {
+    const match = /^([0-9a-f]{64})\s+\*?(.+)$/.exec(line.trim());
+    if (match !== null && match[2] === descriptor.asset) return match[1];
+  }
+  throw new IpcError(
+    "CORE_UNAVAILABLE",
+    `checksums.txt \u91CC\u6CA1\u6709 ${descriptor.asset}\uFF08\u5F53\u524D\u5E73\u53F0 ${descriptor.goos}/${descriptor.goarch} \u53EF\u80FD\u4E0D\u5728\u53D1\u5E03\u77E9\u9635\u5185\uFF09`
+  );
+}
+async function download(descriptor, options) {
+  const expected = await fetchChecksum(descriptor, options);
+  options.onProgress?.({ phase: "download" });
+  const response = await fetchOf(options)(descriptor.url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) }).catch((error) => {
+    throw new IpcError(
+      "CORE_UNAVAILABLE",
+      `\u4E0B\u8F7D\u6838\u5FC3\u5931\u8D25\uFF1A${descriptor.url}\uFF08${error instanceof Error ? error.message : String(error)}\uFF09\u3002\u53EF\u624B\u52A8\u4E0B\u8F7D\u540E\u653E\u5230 ${descriptor.binaryPath}\uFF0C\u6216\u7528 TRENDING_DIGEST_CORE \u6307\u5B9A\u8DEF\u5F84\u3002`
+    );
+  });
+  if (!response.ok || response.body === null) {
+    throw new IpcError(
+      "CORE_UNAVAILABLE",
+      `\u4E0B\u8F7D\u6838\u5FC3\u5931\u8D25\uFF1A${descriptor.url} \u8FD4\u56DE HTTP ${response.status}\uFF08\u7248\u672C ${descriptor.tag} / ${descriptor.asset}\uFF09`
+    );
+  }
+  mkdirSync2(descriptor.cacheDir, { recursive: true, mode: 448 });
+  const temp = `${descriptor.binaryPath}.${process.pid}.${Date.now()}.part`;
+  const hash = createHash("sha256");
+  const total = Number(response.headers.get("content-length") ?? "0") || void 0;
+  let bytes = 0;
+  try {
+    await pipeline(
+      Readable.fromWeb(response.body),
+      async function* (source) {
+        for await (const chunk of source) {
+          const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          hash.update(buf);
+          bytes += buf.length;
+          yield buf;
+        }
+      },
+      createWriteStream(temp, { mode: 384 })
+    );
+    const actual = hash.digest("hex");
+    options.onProgress?.({ phase: "verify", bytes, total });
+    if (actual !== expected) {
+      throw new IpcError(
+        "CORE_CHECKSUM_MISMATCH",
+        `\u6838\u5FC3\u4E8C\u8FDB\u5236\u6821\u9A8C\u5931\u8D25\uFF1A\u671F\u671B ${expected}\uFF0C\u5B9E\u9645 ${actual}\uFF08${descriptor.url}\uFF09\u3002\u5DF2\u4E22\u5F03\u4E0B\u8F7D\u7ED3\u679C\u3002`
+      );
+    }
+    chmodSync(temp, 493);
+    renameSync2(temp, descriptor.binaryPath);
+    const fs = await import("fs");
+    fs.writeFileSync(markerPath(descriptor.binaryPath), `${actual}
+`, { mode: 384 });
+    return { path: descriptor.binaryPath, sha256: actual };
+  } catch (error) {
+    rmSync(temp, { force: true });
+    throw error;
+  }
+}
+async function ensureCore(options = {}) {
+  const release = options.release ?? readCoreRelease();
+  const descriptor = describeRelease(release, options);
+  if (!options.force && existsSync2(descriptor.binaryPath)) {
+    const verified = verifyCached(descriptor.binaryPath);
+    if (verified.ok) {
+      return { path: descriptor.binaryPath, source: "cache", descriptor };
+    }
+    if (options.allowDownload === false) {
+      throw new IpcError(
+        "CORE_UNAVAILABLE",
+        `\u672C\u5730\u6838\u5FC3\u7F13\u5B58\u4E0D\u53EF\u7528\uFF08${verified.reason ?? "unknown"}\uFF09\uFF1A${descriptor.binaryPath}\u3002\u5220\u9664\u8BE5\u6587\u4EF6\u540E\u91CD\u8BD5\uFF0C\u6216\u5728\u8BBE\u7F6E\u9875\u70B9\u300C\u91CD\u65B0\u4E0B\u8F7D\u6838\u5FC3\u300D\u3002`
+      );
+    }
+    try {
+      unlinkSync(descriptor.binaryPath);
+    } catch {
+    }
+  }
+  if (options.allowDownload === false) {
+    throw new IpcError(
+      "CORE_NOT_DOWNLOADED",
+      `\u6838\u5FC3 ${descriptor.tag} \u5C1A\u672A\u4E0B\u8F7D\uFF08\u7F13\u5B58\u76EE\u5F55 ${descriptor.cacheDir}\uFF09\u3002\u4E0B\u8F7D\u5730\u5740\uFF1A${descriptor.url}\uFF1B\u6216\u5728\u8BBE\u7F6E\u9875\u70B9\u300C\u4E0B\u8F7D\u6838\u5FC3\u300D\uFF0C\u6216\u8BBE\u7F6E TRENDING_DIGEST_CORE \u6307\u5411\u672C\u5730\u6838\u5FC3\u3002`
+    );
+  }
+  const downloaded = await download(descriptor, options);
+  return { path: downloaded.path, source: "download", descriptor, sha256: downloaded.sha256 };
+}
+
+// src/core/locate.ts
+var locate_exports = {};
+__export(locate_exports, {
+  inspectRelease: () => inspectRelease,
+  locateCore: () => locateCore,
+  overridePath: () => overridePath
+});
+import { accessSync, constants, existsSync as existsSync3, statSync as statSync2 } from "fs";
+import path5 from "path";
+function executable(file) {
+  try {
+    if (!statSync2(file).isFile()) return false;
+    accessSync(file, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function overridePath(settings, env = process.env) {
+  const fromSettings = settings.corePath.trim();
+  if (fromSettings !== "") {
+    return { path: path5.isAbsolute(fromSettings) ? fromSettings : path5.resolve(fromSettings), source: "settings" };
+  }
+  const fromEnv2 = env.TRENDING_DIGEST_CORE?.trim() ?? "";
+  if (fromEnv2 !== "") return { path: path5.isAbsolute(fromEnv2) ? fromEnv2 : path5.resolve(fromEnv2), source: "env" };
+  return void 0;
+}
+async function locateCore(options) {
+  const env = options.env ?? process.env;
+  const override = overridePath(options.settings, env);
+  if (override !== void 0) {
+    if (!existsSync3(override.path)) {
+      throw new IpcError(
+        "CORE_UNAVAILABLE",
+        `${override.source === "settings" ? "\u8BBE\u7F6E\u91CC\u7684 corePath" : "TRENDING_DIGEST_CORE"} \u6307\u5411\u7684\u8DEF\u5F84\u4E0D\u5B58\u5728\uFF1A${override.path}\u3002\u8BE5\u8986\u76D6\u53EA\u7528\u4E8E\u5F00\u53D1/\u6392\u969C\uFF0C\u6B63\u5E38\u4F7F\u7528\u8BF7\u6E05\u7A7A\u5B83\u3002`
+      );
+    }
+    if (!executable(override.path)) {
+      throw new IpcError("CORE_UNAVAILABLE", `${override.path} \u4E0D\u53EF\u6267\u884C\uFF08\u7F3A\u6267\u884C\u4F4D\u6216\u4E0D\u662F\u6587\u4EF6\uFF09`);
+    }
+    return { path: override.path, source: override.source };
+  }
+  const result = await ensureCore({
+    ...options.release === void 0 ? {} : { release: options.release },
+    env,
+    ...options.platform === void 0 ? {} : { platform: options.platform },
+    ...options.arch === void 0 ? {} : { arch: options.arch },
+    ...options.allowDownload === void 0 ? {} : { allowDownload: options.allowDownload },
+    ...options.forceDownload === void 0 ? {} : { force: options.forceDownload },
+    ...options.fetchImpl === void 0 ? {} : { fetchImpl: options.fetchImpl }
+  });
+  return {
+    path: result.path,
+    source: result.source,
+    release: { repo: result.descriptor.repo, version: result.descriptor.version },
+    tag: result.descriptor.tag,
+    downloaded: result.source === "download",
+    ...result.sha256 === void 0 ? {} : { sha256: result.sha256 }
+  };
+}
+function inspectRelease(settings, options = {}) {
+  const env = options.env ?? process.env;
+  const override = overridePath(settings, env);
+  if (override !== void 0) return { override };
+  try {
+    const release = options.release ?? readCoreRelease();
+    return {
+      descriptor: describeRelease(release, {
+        env,
+        ...options.platform === void 0 ? {} : { platform: options.platform },
+        ...options.arch === void 0 ? {} : { arch: options.arch }
+      })
+    };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/core/channel.ts
+var channel_exports = {};
+__export(channel_exports, {
+  WRITE_TIMEOUT_MS: () => WRITE_TIMEOUT_MS,
+  openConfigChannel: () => openConfigChannel,
+  removeChannelDir: () => removeChannelDir
+});
+import { spawn } from "child_process";
+import { constants as constants2 } from "fs";
+import { open, rm, stat, unlink, writeFile } from "fs/promises";
+import { mkdtempSync } from "fs";
+import os2 from "os";
+import path6 from "path";
+var WRITE_TIMEOUT_MS = 15e3;
+function tempDir() {
+  return mkdtempSync(path6.join(os2.tmpdir(), "dsh-trending-"));
+}
+async function mkfifo(file) {
+  await new Promise((resolve, reject) => {
+    const child = spawn("mkfifo", ["-m", "600", file], { stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+    let stderr = "";
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`mkfifo \u9000\u51FA\u7801 ${code ?? "null"}\uFF1A${stderr.trim()}`));
+    });
+  });
+}
+async function createFifoChannel(dir, writeTimeoutMs) {
+  const file = path6.join(dir, "core.yml");
+  await mkfifo(file);
+  let disposed = false;
+  return {
+    kind: "fifo",
+    path: file,
+    /**
+     * 用 `O_NONBLOCK` 轮询打开写端：没有读端时 open 会返回 ENXIO 而不是**永久阻塞**。
+     * 阻塞式 open 会把 libuv 的请求挂在事件循环上，超时后进程都退不掉——这正是
+     * 「先轮询、再写」的理由。配置只有几 KB，写进管道缓冲区不会出现 EAGAIN。
+     */
+    async publish(content) {
+      const deadline = Date.now() + writeTimeoutMs;
+      let handle;
+      for (; ; ) {
+        try {
+          handle = await open(file, constants2.O_WRONLY | constants2.O_NONBLOCK);
+          break;
+        } catch (error) {
+          const code = error.code;
+          if (code !== "ENXIO" && code !== "ENOENT") throw error;
+          if (Date.now() >= deadline) {
+            throw new Error(`FIFO \u5199\u8D85\u65F6\uFF08${writeTimeoutMs} ms\uFF09\uFF1A\u6838\u5FC3\u672A\u8BFB\u53D6\u914D\u7F6E`);
+          }
+          await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+      }
+      try {
+        await handle.writeFile(content, "utf8");
+      } finally {
+        await handle.close();
+      }
+    },
+    async dispose() {
+      if (disposed) return;
+      disposed = true;
+      await unlink(file).catch(() => void 0);
+    }
+  };
+}
+async function createTmpfileChannel(dir) {
+  const file = path6.join(dir, "core.yml");
+  let disposed = false;
+  return {
+    kind: "tmpfile",
+    path: file,
+    async publish(content) {
+      await writeFile(file, content, { mode: 384 });
+    },
+    async dispose() {
+      if (disposed) return;
+      disposed = true;
+      await unlink(file).catch(() => void 0);
+    }
+  };
+}
+async function openConfigChannel(options = {}) {
+  const dir = tempDir();
+  const preferFifo = options.preferFifo ?? process.platform !== "win32";
+  const writeTimeoutMs = options.writeTimeoutMs ?? WRITE_TIMEOUT_MS;
+  if (preferFifo) {
+    try {
+      return await createFifoChannel(dir, writeTimeoutMs);
+    } catch {
+    }
+  }
+  return createTmpfileChannel(dir);
+}
+async function removeChannelDir(channel) {
+  try {
+    const info = await stat(channel.path);
+    if (info.isFIFO()) return;
+  } catch {
+  }
+  await rm(path6.dirname(channel.path), { recursive: true, force: true }).catch(() => void 0);
+}
+
+// src/core/run.ts
+var run_exports = {};
+__export(run_exports, {
+  DEFAULT_RUN_TIMEOUT_MS: () => DEFAULT_RUN_TIMEOUT_MS,
+  buildCoreArgs: () => buildCoreArgs,
+  runCore: () => runCore
+});
+import { spawn as spawn2 } from "child_process";
+var DEFAULT_RUN_TIMEOUT_MS = 12e4;
+var MAX_STDOUT = 16 * 1024 * 1024;
+var MAX_STDERR = 2 * 1024 * 1024;
+var KILL_GRACE_MS = 3e3;
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function errorFrom(stderr, exitCode) {
+  const classified = classifyStderr(stderr);
+  return {
+    code: classified.code,
+    message: classified.message,
+    retriable: classified.retriable,
+    details: { inferred: classified.inferred, exitCode }
+  };
+}
+function buildCoreArgs(channelPath, options) {
+  const args = ["run", "--config", channelPath, "--json"];
+  if (options.dryRun) args.push("--dry-run");
+  if (options.date !== void 0 && options.date !== "") args.push("--date", options.date);
+  return args;
+}
+async function runCore(options) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_RUN_TIMEOUT_MS;
+  const startedAt = nowIso();
+  const started = Date.now();
+  const channel = await openConfigChannel();
+  const yaml = `${toYaml(toCoreConfig(options.settings, options.apiKey, options.baseURLOverride))}
+`;
+  const secrets = [options.apiKey, options.token, ...options.secrets ?? []];
+  const child = spawn2(options.core.path, buildCoreArgs(channel.path, { dryRun: options.dryRun, date: options.date }), {
+    env: sanitizedEnv(process.env, { GITHUB_TOKEN: options.token, GH_TOKEN: options.token }),
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  let stdout = "";
+  let stdoutBytes = 0;
+  let stderr = "";
+  let timedOut = false;
+  let aborted = false;
+  let channelError;
+  const publish = channel.publish(yaml).catch((error) => {
+    channelError = error instanceof Error ? error : new Error(String(error));
+  });
+  const escalate = () => setTimeout(() => {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }, KILL_GRACE_MS);
+  let escalations = [];
+  const timer = setTimeout(() => {
+    timedOut = true;
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    escalations.push(escalate());
+  }, timeoutMs);
+  const onAbort = () => {
+    aborted = true;
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    escalations.push(escalate());
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  child.stdout?.setEncoding("utf8");
+  child.stdout?.on("data", (chunk) => {
+    stdoutBytes += Buffer.byteLength(chunk);
+    if (stdoutBytes <= MAX_STDOUT) stdout += chunk;
+  });
+  let stderrBuffer = "";
+  child.stderr?.setEncoding("utf8");
+  child.stderr?.on("data", (chunk) => {
+    if (stderr.length < MAX_STDERR) stderr += chunk;
+    stderrBuffer += chunk;
+    let index = stderrBuffer.indexOf("\n");
+    while (index >= 0) {
+      const line = redact(stderrBuffer.slice(0, index), secrets);
+      stderrBuffer = stderrBuffer.slice(index + 1);
+      if (line.trim() !== "") options.onStderr?.(line);
+      index = stderrBuffer.indexOf("\n");
+    }
+  });
+  const closed = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code, signal) => resolve({ code, signal }));
+  }).catch((error) => {
+    throw new IpcError("CORE_SPAWN_FAILED", `\u65E0\u6CD5\u542F\u52A8\u6838\u5FC3 ${options.core.path}\uFF1A${error instanceof Error ? error.message : String(error)}`);
+  });
+  clearTimeout(timer);
+  for (const handle of escalations) clearTimeout(handle);
+  escalations = [];
+  options.signal?.removeEventListener("abort", onAbort);
+  if (stderrBuffer.trim() !== "") options.onStderr?.(redact(stderrBuffer, secrets));
+  await publish;
+  await channel.dispose();
+  await removeChannelDir(channel);
+  const finishedAt = nowIso();
+  const durationMs = Date.now() - started;
+  const tail = stderr.trim().split("\n").slice(-20).join("\n");
+  if (aborted) {
+    throw new IpcError("CORE_CANCELLED", "\u8FD0\u884C\u5DF2\u53D6\u6D88\uFF1A\u6838\u5FC3\u8FDB\u7A0B\u5DF2\u7EC8\u6B62\uFF0C\u672A\u63D0\u4EA4\u4EFB\u4F55\u72B6\u6001");
+  }
+  if (timedOut) {
+    throw new IpcError(
+      "CORE_TIMEOUT",
+      `\u6838\u5FC3\u8FD0\u884C\u8D85\u65F6\uFF08${Math.round(timeoutMs / 1e3)} s\uFF09\u5DF2\u7EC8\u6B62${tail === "" ? "" : `\uFF1B\u6700\u540E\u8F93\u51FA\uFF1A${tail}`}`
+    );
+  }
+  if (channelError !== void 0) {
+    throw new IpcError("CORE_CONFIG_CHANNEL_FAILED", `\u914D\u7F6E\u901A\u9053\u5199\u5165\u5931\u8D25\uFF1A${channelError.message}`);
+  }
+  if (stdoutBytes > MAX_STDOUT) {
+    throw new IpcError("PAYLOAD_TOO_LARGE", `\u6838\u5FC3\u8F93\u51FA\u8D85\u8FC7 ${MAX_STDOUT} \u5B57\u8282\u4E0A\u9650`);
+  }
+  const timing2 = { coreVersion: options.version.version, startedAt, finishedAt, durationMs, dryRun: options.dryRun };
+  if (stdout.trim() === "") {
+    if (closed.code === 0) {
+      throw new IpcError("IPC_INVALID", "\u6838\u5FC3\u6B63\u5E38\u9000\u51FA\u4F46\u6CA1\u6709\u8F93\u51FA\u7ED3\u679C\u4FE1\u5C01");
+    }
+    return {
+      outcome: { ok: false, skipped: false, files: [], warnings: [], error: errorFrom(stderr, closed.code), ...timing2 },
+      channelKind: channel.kind,
+      stderr,
+      exitCode: closed.code
+    };
+  }
+  let outcome;
+  try {
+    outcome = parseRunResult(stdout, timing2);
+  } catch (error) {
+    if (closed.code !== 0) {
+      return {
+        outcome: { ok: false, skipped: false, files: [], warnings: [], error: errorFrom(stderr, closed.code), ...timing2 },
+        channelKind: channel.kind,
+        stderr,
+        exitCode: closed.code
+      };
+    }
+    throw error;
+  }
+  if (closed.code !== 0) {
+    return {
+      outcome: { ...outcome, ok: false, error: errorFrom(stderr, closed.code) },
+      channelKind: channel.kind,
+      stderr,
+      exitCode: closed.code
+    };
+  }
+  return { outcome, channelKind: channel.kind, stderr, exitCode: closed.code };
+}
+
+// src/host/core.ts
+var core_exports = {};
+__export(core_exports, {
+  detectCoexistence: () => detectCoexistence,
+  findOnPath: () => findOnPath,
+  inspectCore: () => inspectCore
+});
+import { accessSync as accessSync2, constants as constants3, statSync as statSync3 } from "fs";
+import path7 from "path";
+var CACHE_TTL_MS = 3e4;
+function executable2(file) {
+  try {
+    if (!statSync3(file).isFile()) return false;
+    accessSync2(file, constants3.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findOnPath(command, env = process.env) {
+  const raw = env.PATH ?? "";
+  const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+  for (const dir of raw.split(path7.delimiter)) {
+    if (dir.trim() === "") continue;
+    for (const ext of exts) {
+      const candidate = path7.join(dir, `${command}${ext}`);
+      if (executable2(candidate)) return candidate;
+    }
+  }
+  return void 0;
+}
+var cached;
+async function inspectCore(settings, options = {}) {
+  const env = options.env ?? process.env;
+  const key = `${settings.corePath}|${env.TRENDING_DIGEST_CORE ?? ""}|${process.platform}|${process.arch}`;
+  if (!options.fresh && cached !== void 0 && cached.key === key && Date.now() - cached.at < CACHE_TTL_MS) {
+    return cached.status;
+  }
+  const view = inspectRelease(settings, { env });
+  const release = view.descriptor === void 0 ? void 0 : {
+    repo: view.descriptor.repo,
+    tag: view.descriptor.tag,
+    asset: view.descriptor.asset,
+    url: view.descriptor.url,
+    checksumsUrl: view.descriptor.checksumsUrl,
+    cacheDir: view.descriptor.cacheDir,
+    binaryPath: view.descriptor.binaryPath,
+    cached: view.descriptor.cached
+  };
+  const base = {
+    ...release === void 0 ? {} : { release },
+    ...view.override === void 0 ? {} : { override: view.override },
+    download: view.override !== void 0 ? { state: "override" } : release === void 0 ? { state: "missing", reason: view.error ?? "release \u672A\u914D\u7F6E" } : { state: release.cached ? "cached" : "missing" }
+  };
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const core = await locateCore({ settings, env, allowDownload: false });
+    const result = await handshake(core, { timeoutMs: 5e3 });
+    const status = {
+      ...base,
+      state: "ready",
+      path: core.path,
+      source: core.source,
+      version: result.version.version,
+      commit: result.version.commit,
+      ipcSchema: result.version.ipcSchema,
+      digestSchema: result.version.digestSchema,
+      supportedProviders: result.supportedProviders,
+      checkedAt,
+      durationMs: result.durationMs
+    };
+    cached = { key, at: Date.now(), status };
+    return status;
+  } catch (error) {
+    const code = error instanceof IpcError ? error.code : "CORE_UNAVAILABLE";
+    const message = error instanceof Error ? error.message : String(error);
+    const status = {
+      ...base,
+      state: code === "CORE_INCOMPATIBLE" ? "incompatible" : "unavailable",
+      code,
+      message,
+      supportedProviders: [],
+      checkedAt
+    };
+    cached = { key, at: Date.now(), status };
+    return status;
+  }
+}
+var coexistCache;
+async function detectCoexistence(ownPath, options = {}) {
+  const env = options.env ?? process.env;
+  const found = findOnPath("trendradar", env);
+  if (found === void 0) return { found: false };
+  if (ownPath !== void 0 && path7.resolve(found) === path7.resolve(ownPath)) return { found: false };
+  if (!options.fresh && coexistCache !== void 0 && coexistCache.key === found && Date.now() - coexistCache.at < CACHE_TTL_MS) {
+    return coexistCache.status;
+  }
+  let status;
+  try {
+    const result = await execCapture(found, ["version", "--json"], { timeoutMs: 3e3 });
+    if (result.code !== 0) {
+      status = {
+        found: true,
+        path: found,
+        message: "PATH \u4E0A\u7684 trendradar \u65E0\u6CD5\u6267\u884C version --json\uFF1B\u63D2\u4EF6\u4ECD\u4F7F\u7528\u81EA\u5E26\u6838\u5FC3\uFF0C\u4E0D\u5207\u6362\u3002"
+      };
+    } else {
+      const info = JSON.parse(result.stdout);
+      const compatible = info.ipcSchema === 1 && info.digestSchema === 1;
+      status = {
+        found: true,
+        path: found,
+        version: typeof info.version === "string" ? info.version : void 0,
+        ipcSchema: typeof info.ipcSchema === "number" ? info.ipcSchema : void 0,
+        digestSchema: typeof info.digestSchema === "number" ? info.digestSchema : void 0,
+        compatible,
+        message: compatible ? "PATH \u4E0A\u53E6\u6709\u4E00\u4EFD trendradar\uFF08\u534F\u8BAE\u517C\u5BB9\uFF09\u3002\u63D2\u4EF6\u4E0D\u63A5\u7BA1\u5B83\uFF0C\u4E5F\u4E0D\u4F1A\u4ECE PATH \u89E3\u6790\u6838\u5FC3\uFF1B\u6CE8\u610F\u522B\u8BA9\u4E24\u5957\u5B9A\u65F6\u540C\u65F6\u5F00\u542F\u3002" : "PATH \u4E0A\u7684 trendradar \u534F\u8BAE\u7248\u672C\u4E0E\u63D2\u4EF6\u4E0D\u540C\u3002\u63D2\u4EF6\u4ECD\u4F7F\u7528\u81EA\u5E26\u6838\u5FC3\uFF0C\u4E0D\u5207\u6362\uFF1B\u5EFA\u8BAE\u53EA\u7528\u5176\u4E2D\u4E00\u5957\u3002"
+      };
+    }
+  } catch (error) {
+    status = {
+      found: true,
+      path: found,
+      message: `PATH \u4E0A\u7684 trendradar \u63A2\u6D4B\u5931\u8D25\uFF08${error instanceof Error ? error.message : String(error)}\uFF09\uFF1B\u63D2\u4EF6\u4ECD\u4F7F\u7528\u81EA\u5E26\u6838\u5FC3\u3002`
+    };
+  }
+  coexistCache = { key: found, at: Date.now(), status };
+  return status;
+}
+
+// src/host/credentials.ts
+var credentials_exports = {};
+__export(credentials_exports, {
+  credentialServices: () => credentialServices,
+  describeRef: () => describeRef,
+  resolveGithubToken: () => resolveGithubToken,
+  resolveRef: () => resolveRef
+});
+function credentialServices(get) {
+  const service = get("credentials");
+  return service !== void 0 && typeof service?.resolve === "function" ? service : void 0;
+}
+function fromEnv(ref, env) {
+  const raw = env[ref];
+  return typeof raw === "string" && raw.trim() !== "" ? raw : void 0;
+}
+async function describeRef(services, ref, env = process.env) {
+  if (ref.trim() === "") return { configured: false, writable: false };
+  if (services?.describe !== void 0) {
+    try {
+      const described = await services.describe(ref);
+      if (described?.configured === true) {
+        return { configured: true, source: described.source, writable: described.writable === true };
+      }
+    } catch {
+    }
+  }
+  const envValue = fromEnv(ref, env);
+  return envValue === void 0 ? { configured: false, writable: services?.set !== void 0 } : { configured: true, source: "env", writable: false };
+}
+async function resolveRef(services, ref, env = process.env) {
+  if (ref.trim() === "") return {};
+  if (services?.resolve !== void 0) {
+    try {
+      const resolved = await services.resolve(ref);
+      const value = resolved?.value;
+      if (typeof value === "string" && value.trim() !== "") return { value, source: resolved?.source ?? "credentials" };
+    } catch {
+    }
+  }
+  const envValue = fromEnv(ref, env);
+  return envValue === void 0 ? {} : { value: envValue, source: "env" };
+}
+async function resolveGithubToken(services, authMode, tokenRef, deps = {}) {
+  const env = deps.env ?? process.env;
+  if (authMode === "gh") {
+    const execGh = deps.execGh ?? defaultGhToken;
+    try {
+      const token = await execGh();
+      if (token !== void 0 && token !== "") return { token, source: "gh" };
+    } catch {
+    }
+  }
+  const resolved = await resolveRef(services, tokenRef, env);
+  if (resolved.value !== void 0) return { token: resolved.value, source: resolved.source ?? "credentials" };
+  return { source: "none" };
+}
+async function defaultGhToken() {
+  const { execCapture: execCapture2 } = await import("./exec-33EQXGUA.js");
+  const result = await execCapture2("gh", ["auth", "token"], { timeoutMs: 5e3 });
+  if (result.code !== 0) return void 0;
+  const token = result.stdout.trim();
+  return token === "" ? void 0 : token;
+}
+
+// src/host/quickfill.ts
+var quickfill_exports = {};
+__export(quickfill_exports, {
+  applyCandidate: () => applyCandidate,
+  coreProviderFor: () => coreProviderFor,
+  credentialServices: () => credentialServices,
+  listProviderCandidates: () => listProviderCandidates,
+  llmServices: () => llmServices,
+  resolveModelKey: () => resolveModelKey
+});
+function llmServices(get) {
+  const service = get("llm");
+  return service !== void 0 && typeof service?.listProviders === "function" ? service : void 0;
+}
+function coreProviderFor(providerId) {
+  return /deepseek/i.test(providerId) ? "deepseek" : "openai-compatible";
+}
+async function listModelsWithTimeout(llm, provider) {
+  if (llm.listModels === void 0) return [];
+  try {
+    const models = await Promise.race([
+      llm.listModels(provider),
+      new Promise((_resolve, reject) => setTimeout(() => reject(new Error("listModels timeout")), 3e3))
+    ]);
+    return models.filter((model) => typeof model?.id === "string" && model.id !== "").map((model) => ({ id: model.id, name: typeof model.name === "string" && model.name !== "" ? model.name : model.id }));
+  } catch {
+    return [];
+  }
+}
+async function listProviderCandidates(options) {
+  const { llm, credentials } = options;
+  const env = options.env ?? process.env;
+  if (llm === void 0) return [];
+  const live = llm.listProviders?.() ?? [];
+  const configurable = llm.listConfigurableProviders?.() ?? [];
+  const declared = new Map(configurable.map((entry) => [entry.provider, entry]));
+  const ids = [];
+  for (const provider of live) if (!ids.includes(provider.id)) ids.push(provider.id);
+  for (const entry of configurable) if (!ids.includes(entry.provider)) ids.push(entry.provider);
+  const candidates = [];
+  for (const id of ids) {
+    const entry = declared.get(id);
+    const name = live.find((provider) => provider.id === id)?.name ?? entry?.displayName ?? id;
+    const envNames = [...entry?.nativeAuth?.env ?? []];
+    const oauth = entry?.nativeAuth?.oauth === true;
+    let ref;
+    let source;
+    let mode = "missing";
+    for (const candidateRef of envNames) {
+      const described = await describeRef(credentials, candidateRef, env);
+      if (described.configured) {
+        ref = candidateRef;
+        source = described.source;
+        mode = "direct";
+        break;
+      }
+    }
+    if (mode !== "direct" && oauth) mode = "proxy";
+    const models = await listModelsWithTimeout(llm, id);
+    candidates.push({
+      id,
+      name,
+      baseURL: entry?.defaultBaseURL ?? "",
+      models,
+      credential: {
+        ...ref === void 0 ? {} : { ref },
+        env: envNames,
+        configured: mode === "direct",
+        oauth,
+        mode,
+        ...source === void 0 ? {} : { source }
+      },
+      coreProvider: coreProviderFor(id)
+    });
+  }
+  return candidates;
+}
+function applyCandidate(settings, candidate, modelId) {
+  const model = {
+    ...settings.model,
+    provider: candidate.coreProvider,
+    mode: candidate.credential.mode === "proxy" ? "proxy" : "direct",
+    hostProvider: candidate.credential.mode === "proxy" ? candidate.id : "",
+    baseURL: candidate.credential.mode === "proxy" ? "" : candidate.baseURL || PROVIDER_BASE_URLS[candidate.coreProvider] || "",
+    model: modelId,
+    apiKeyRef: candidate.credential.mode === "direct" && candidate.credential.ref !== void 0 ? candidate.credential.ref : settings.model.apiKeyRef
+  };
+  return { ...settings, model };
+}
+async function resolveModelKey(settings, credentials, env = process.env) {
+  if (settings.model.mode === "proxy") return { mode: "proxy" };
+  const resolved = await resolveRef(credentials, settings.model.apiKeyRef, env);
+  return {
+    mode: "direct",
+    ...resolved.value === void 0 ? {} : { apiKey: resolved.value },
+    ...resolved.source === void 0 ? {} : { source: resolved.source }
+  };
+}
+
+// src/host/proxy.ts
+var proxy_exports = {};
+__export(proxy_exports, {
+  foldMessages: () => foldMessages,
+  startProxy: () => startProxy
+});
+import http from "http";
+import { randomBytes, timingSafeEqual } from "crypto";
+var MAX_BODY = 4 * 1024 * 1024;
+var DEFAULT_TIMEOUT_MS = 12e4;
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (typeof part === "string") return part;
+      if (typeof part === "object" && part !== null && part.type === "text") {
+        const text = part.text;
+        return typeof text === "string" ? text : "";
+      }
+      return "";
+    }).filter((part) => part !== "").join("\n");
+  }
+  return "";
+}
+function foldMessages(messages) {
+  const systemParts = [];
+  const userParts = [];
+  for (const message of messages) {
+    const text = textOf(message.content);
+    if (text === "") continue;
+    if (message.role === "system" || message.role === "developer") systemParts.push(text);
+    else userParts.push(text);
+  }
+  return { system: systemParts.join("\n\n"), user: userParts.join("\n\n") };
+}
+function sendJson(response, status, payload) {
+  const body = JSON.stringify(payload);
+  response.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store",
+    "content-length": Buffer.byteLength(body)
+  });
+  response.end(body);
+}
+function fail(response, status, code, message) {
+  sendJson(response, status, { error: { message, type: "invalid_request_error", code } });
+}
+async function readBody(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    size += chunk.length;
+    if (size > MAX_BODY) throw new Error("\u8BF7\u6C42\u4F53\u8D85\u8FC7 4 MB");
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function startProxy(options) {
+  const token = randomBytes(24).toString("hex");
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const handle = { requests: 0 };
+  let closed = false;
+  const server = http.createServer((request, response) => {
+    void (async () => {
+      try {
+        if (request.method === "GET" && (request.url === "/healthz" || request.url === "/v1/models")) {
+          if (!authorized(request, token)) return fail(response, 401, "unauthorized", "missing or bad proxy token");
+          if (request.url === "/healthz") return sendJson(response, 200, { ok: true });
+          return sendJson(response, 200, { object: "list", data: [{ id: options.model, object: "model", owned_by: options.provider }] });
+        }
+        if (request.method !== "POST" || request.url !== "/v1/chat/completions") {
+          return fail(response, 404, "not_found", `unsupported route ${request.method ?? ""} ${request.url ?? ""}`);
+        }
+        if (!authorized(request, token)) return fail(response, 401, "unauthorized", "missing or bad proxy token");
+        const raw = await readBody(request);
+        let body;
+        try {
+          body = JSON.parse(raw);
+        } catch {
+          return fail(response, 400, "invalid_json", "request body is not JSON");
+        }
+        if (body.stream === true) {
+          return fail(response, 400, "stream_unsupported", "\u56DE\u73AF\u4EE3\u7406\u53EA\u5B9E\u73B0\u975E\u6D41\u5F0F\u8865\u5168\uFF1B\u6838\u5FC3\u4E0D\u4F1A\u5F00\u542F\u6D41\u5F0F");
+        }
+        const messages = Array.isArray(body.messages) ? body.messages : [];
+        if (messages.length === 0) return fail(response, 400, "invalid_request", "messages \u4E0D\u80FD\u4E3A\u7A7A");
+        const { system, user } = foldMessages(messages);
+        if (user === "") return fail(response, 400, "invalid_request", "messages \u91CC\u6CA1\u6709\u53EF\u7528\u7684\u6587\u672C\u5185\u5BB9");
+        handle.requests += 1;
+        const started = Date.now();
+        let text = "";
+        let usage;
+        let failure;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+          const stream = options.llm.stream({
+            provider: options.provider,
+            model: options.model,
+            system: system === "" ? void 0 : system,
+            messages: [{ role: "user", content: [{ type: "text", text: user }] }],
+            temperature: typeof body.temperature === "number" ? body.temperature : options.temperature,
+            maxTokens: typeof body.max_tokens === "number" ? body.max_tokens : typeof body.maxTokens === "number" ? body.maxTokens : options.maxTokens,
+            signal: controller.signal
+          });
+          for await (const chunk of stream) {
+            if (chunk.type === "text-delta" && typeof chunk.text === "string") text += chunk.text;
+            else if (chunk.type === "usage") usage = chunk.usage;
+            else if (chunk.type === "finish") {
+              const kind = chunk.reason?.kind;
+              if (kind === "error" || kind === "aborted") failure = chunk.reason?.failure ?? { code: kind };
+            }
+          }
+        } finally {
+          clearTimeout(timer);
+        }
+        if (failure !== void 0) {
+          return fail(response, 502, failure.code ?? "llm_failed", failure.message ?? "\u5BBF\u4E3B\u6A21\u578B\u8C03\u7528\u5931\u8D25");
+        }
+        return sendJson(response, 200, {
+          id: `chatcmpl-proxy-${Date.now().toString(36)}`,
+          object: "chat.completion",
+          created: Math.floor(Date.now() / 1e3),
+          model: options.model,
+          choices: [{ index: 0, message: { role: "assistant", content: text }, finish_reason: "stop" }],
+          usage: {
+            prompt_tokens: usage?.inputTokens ?? 0,
+            completion_tokens: usage?.outputTokens ?? 0,
+            total_tokens: usage?.totalTokens ?? (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0)
+          },
+          proxy: { provider: options.provider, durationMs: Date.now() - started }
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!response.headersSent) fail(response, 500, "proxy_failed", message);
+        else response.end();
+      }
+    })();
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  if (typeof address !== "object" || address === null) {
+    server.close();
+    throw new Error("\u56DE\u73AF\u4EE3\u7406\u672A\u80FD\u62FF\u5230\u7AEF\u53E3");
+  }
+  handle.port = address.port;
+  handle.url = `http://127.0.0.1:${address.port}/v1`;
+  handle.token = token;
+  handle.close = async () => {
+    if (closed) return;
+    closed = true;
+    await new Promise((resolve) => server.close(() => resolve()));
+  };
+  return handle;
+}
+function authorized(request, token) {
+  const header = request.headers.authorization;
+  if (typeof header !== "string") return false;
+  const match = /^Bearer\s+(.+)$/i.exec(header.trim());
+  if (match === null) return false;
+  const provided = Buffer.from(match[1] ?? "", "utf8");
+  const expected = Buffer.from(token, "utf8");
+  return provided.length === expected.length && timingSafeEqual(provided, expected);
+}
+
+// src/host/runner.ts
+var runner_exports = {};
+__export(runner_exports, {
+  Runner: () => Runner
+});
+import { existsSync as existsSync4, statSync as statSync4 } from "fs";
+import path8 from "path";
+function repoProblem(repoPath) {
+  if (repoPath.trim() === "") return { code: "CONFIG_INVALID", message: "\u8FD8\u6CA1\u6709\u9009\u62E9\u5F52\u6863\u4ED3\u5E93" };
+  if (!existsSync4(repoPath)) return { code: "REPO_NOT_GIT", message: `\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${repoPath}` };
+  try {
+    if (!statSync4(repoPath).isDirectory()) return { code: "REPO_NOT_GIT", message: `\u4E0D\u662F\u76EE\u5F55\uFF1A${repoPath}` };
+  } catch {
+    return { code: "REPO_NOT_GIT", message: `\u65E0\u6CD5\u8BBF\u95EE\uFF1A${repoPath}` };
+  }
+  if (!existsSync4(path8.join(repoPath, ".git"))) {
+    return { code: "REPO_NOT_GIT", message: `\u4E0D\u662F git \u4ED3\u5E93\uFF1A${repoPath}\uFF08\u63D2\u4EF6\u4E0D\u4F1A\u66FF\u4F60 git init\uFF09` };
+  }
+  return void 0;
+}
+var Runner = class {
+  active;
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  get running() {
+    return this.active === void 0 ? void 0 : { id: this.active.id, startedAt: this.active.startedAt };
+  }
+  cancel() {
+    if (this.active === void 0) return false;
+    this.active.controller.abort();
+    return true;
+  }
+  async run(options) {
+    const env = this.deps.env ?? process.env;
+    const store = this.deps.store;
+    const settings = store.readSettings();
+    const credentials = credentialServices(this.deps.get);
+    if (this.active !== void 0) {
+      throw new IpcError("CONFIG_INVALID", `\u5DF2\u6709\u4E00\u6B21\u8FD0\u884C\u5728\u8FDB\u884C\u4E2D\uFF08${this.active.id}\uFF09\uFF0C\u8BF7\u5148\u7B49\u5F85\u6216\u53D6\u6D88`);
+    }
+    const problems = validateSettings(settings);
+    if (problems.length > 0) {
+      const first = problems[0];
+      throw new IpcError(first?.code ?? "CONFIG_INVALID", `\u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1A${first?.message ?? "\u672A\u77E5\u95EE\u9898"}`);
+    }
+    const repoIssue = repoProblem(settings.repo.path);
+    if (repoIssue !== void 0) throw new IpcError(repoIssue.code, repoIssue.message);
+    const id = newRunId();
+    const controller = new AbortController();
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.active = { id, controller, startedAt };
+    const logFile = store.newLogPath(id);
+    const dryRun = options.dryRun === true;
+    const startedMs = Date.now();
+    let proxy;
+    try {
+      const core = await locateCore({ settings, env, allowDownload: settings.coreAutoDownload });
+      if (core.downloaded === true) {
+        store.appendLog(logFile, `[core] \u5DF2\u4E0B\u8F7D\u6838\u5FC3 ${core.tag ?? ""} \u2192 ${core.path}`);
+      }
+      const handshakeResult = await handshake(core, { signal: controller.signal });
+      if (!handshakeResult.supportedProviders.includes(settings.model.provider)) {
+        throw new IpcError(
+          "MODEL_PROVIDER_UNSUPPORTED",
+          `\u6838\u5FC3\u4E0D\u652F\u6301 provider\u300C${settings.model.provider}\u300D\uFF1B\u53EF\u7528\uFF1A${handshakeResult.supportedProviders.join(" / ")}`
+        );
+      }
+      const modelKey = await resolveModelKey(settings, credentials, env);
+      if (modelKey.mode === "direct" && (modelKey.apiKey === void 0 || modelKey.apiKey === "")) {
+        throw new IpcError("MODEL_KEY_MISSING", `\u6CA1\u6709\u89E3\u6790\u5230\u6A21\u578B\u5BC6\u94A5\uFF08\u5F15\u7528 ${settings.model.apiKeyRef}\uFF09`);
+      }
+      let baseURLOverride;
+      if (modelKey.mode === "proxy") {
+        const llm = this.deps.get("llm");
+        if (llm === void 0 || typeof llm.stream !== "function") {
+          throw new IpcError("MODEL_KEY_MISSING", "\u8BE5\u6A21\u578B\u9700\u8981\u56DE\u73AF\u4EE3\u7406\uFF0C\u4F46\u5BBF\u4E3B\u6CA1\u6709\u53EF\u7528\u7684 ctx.llm \u670D\u52A1");
+        }
+        proxy = await startProxy({
+          llm,
+          provider: settings.model.hostProvider !== "" ? settings.model.hostProvider : settings.model.provider,
+          model: settings.model.model,
+          temperature: settings.model.temperature,
+          maxTokens: settings.model.maxTokens,
+          timeoutMs: 12e4
+        });
+        baseURLOverride = proxy.url;
+        store.appendLog(
+          logFile,
+          `[proxy] \u56DE\u73AF\u4EE3\u7406\u5DF2\u542F\u52A8\uFF1A127.0.0.1:${proxy.port}\uFF08\u4E00\u6B21\u6027 token\uFF0C\u8FD0\u884C\u7ED3\u675F\u5373\u5173\u95ED\uFF09`
+        );
+      }
+      const github = await resolveGithubToken(credentials, settings.github.authMode, settings.github.tokenRef, { env });
+      if (github.token === void 0) {
+        store.appendLog(logFile, "[github] \u672A\u627E\u5230 token\uFF1Apush/PR \u4F1A\u5931\u8D25\u5E76\u8FD4\u56DE GITHUB_AUTH\uFF08dryRun \u4E0D\u53D7\u5F71\u54CD\uFF09");
+      }
+      const result = await runCore({
+        core,
+        version: handshakeResult.version,
+        settings,
+        apiKey: modelKey.apiKey ?? "",
+        ...github.token === void 0 ? {} : { token: github.token },
+        ...options.date === void 0 ? {} : { date: options.date },
+        dryRun,
+        ...baseURLOverride === void 0 ? {} : { baseURLOverride },
+        signal: controller.signal,
+        secrets: [modelKey.apiKey, github.token],
+        onStderr: (line) => store.appendLog(logFile, line)
+      });
+      const outcome = result.outcome;
+      const summary = this.summarize({
+        id,
+        outcome,
+        dryRun,
+        ...options.date === void 0 ? {} : { date: options.date },
+        logFile,
+        channel: result.channelKind,
+        proxy: proxy !== void 0,
+        coreSource: core.source,
+        ...core.tag === void 0 ? {} : { coreTag: core.tag }
+      });
+      this.record(summary, settings);
+      return summary;
+    } catch (error) {
+      const cancelled = controller.signal.aborted || error instanceof IpcError && error.code === "CORE_CANCELLED";
+      const summary = this.failureSummary({
+        id,
+        error: cancelled && !(error instanceof IpcError && error.code === "CORE_CANCELLED") ? new IpcError("CORE_CANCELLED", "\u8FD0\u884C\u5DF2\u53D6\u6D88\uFF1A\u6838\u5FC3\u8FDB\u7A0B\u5DF2\u7EC8\u6B62\uFF0C\u672A\u63D0\u4EA4\u4EFB\u4F55\u72B6\u6001") : error,
+        dryRun,
+        ...options.date === void 0 ? {} : { date: options.date },
+        logFile,
+        durationMs: Date.now() - startedMs
+      });
+      this.record(summary, settings);
+      return summary;
+    } finally {
+      if (proxy !== void 0) {
+        const port = proxy.port;
+        await proxy.close().catch(() => void 0);
+        this.deps.store.appendLog(logFile, `[proxy] \u5DF2\u5173\u95ED 127.0.0.1:${port}`);
+      }
+      this.active = void 0;
+    }
+  }
+  summarize(input) {
+    const { outcome } = input;
+    const error = outcome.error === void 0 ? void 0 : {
+      code: outcome.error.code,
+      message: redact(outcome.error.message),
+      hint: hintOf(outcome.error.code),
+      area: areaOf(outcome.error.code),
+      retriable: outcome.error.retriable,
+      inferred: outcome.error.details?.inferred === true
+    };
+    return {
+      id: input.id,
+      ok: outcome.ok,
+      skipped: outcome.skipped,
+      dryRun: input.dryRun,
+      ...input.date === void 0 ? {} : { date: input.date },
+      durationMs: outcome.durationMs,
+      coreVersion: outcome.coreVersion,
+      files: outcome.files.length,
+      ...outcome.contentHash === void 0 ? {} : { contentHash: outcome.contentHash },
+      ...outcome.branch === void 0 ? {} : { branch: outcome.branch },
+      ...outcome.prUrl === void 0 ? {} : { prUrl: outcome.prUrl },
+      ...error === void 0 ? {} : { error },
+      warnings: outcome.warnings,
+      logFile: input.logFile,
+      ...input.channel === void 0 ? {} : { channel: input.channel },
+      proxy: input.proxy,
+      ...input.coreSource === void 0 ? {} : { coreSource: input.coreSource },
+      ...input.coreTag === void 0 ? {} : { coreTag: input.coreTag }
+    };
+  }
+  failureSummary(input) {
+    const code = input.error instanceof IpcError ? input.error.code : "INTERNAL";
+    const message = redact(input.error instanceof Error ? input.error.message : String(input.error));
+    return {
+      id: input.id,
+      ok: false,
+      skipped: false,
+      dryRun: input.dryRun,
+      ...input.date === void 0 ? {} : { date: input.date },
+      durationMs: input.durationMs ?? 0,
+      coreVersion: "",
+      files: 0,
+      error: { code, message, hint: hintOf(code), area: areaOf(code), retriable: false },
+      warnings: [],
+      logFile: input.logFile
+    };
+  }
+  /** 写历史与状态；同一天的 skipped 运行不覆盖 lastDigest。 */
+  record(summary, settings) {
+    const store = this.deps.store;
+    const record = {
+      id: summary.id,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: summary.dryRun ? "dry-run" : "run",
+      ok: summary.ok,
+      skipped: summary.skipped,
+      ...summary.error === void 0 ? {} : { errorCode: summary.error.code, errorMessage: summary.error.message },
+      durationMs: summary.durationMs,
+      files: summary.files,
+      ...summary.contentHash === void 0 ? {} : { contentHash: summary.contentHash },
+      ...summary.branch === void 0 ? {} : { branch: summary.branch },
+      ...summary.prUrl === void 0 ? {} : { prUrl: summary.prUrl },
+      coreVersion: summary.coreVersion,
+      model: { provider: settings.model.provider, model: settings.model.model },
+      languages: settings.trending.languages,
+      warnings: summary.warnings,
+      logFile: summary.logFile
+    };
+    const state = store.readState();
+    const next = {
+      lastRunAt: record.at,
+      ...summary.ok && summary.prUrl !== void 0 ? { pendingPr: { url: summary.prUrl, createdAt: record.at } } : {},
+      ...summary.ok && !summary.skipped && summary.contentHash !== void 0 ? {
+        lastDigest: {
+          date: summary.date ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+          contentHash: summary.contentHash,
+          coreVersion: summary.coreVersion
+        },
+        ...state.pendingPr !== void 0 && summary.prUrl === void 0 ? { pendingPr: state.pendingPr } : {}
+      } : {}
+    };
+    store.recordRun(record, next);
+    this.deps.onFinished?.(summary);
+  }
+  /** 给设置页/工具用的「核心现在什么状态」。 */
+  async coreStatus(fresh = false) {
+    const settings = this.deps.store.readSettings();
+    return inspectCore(settings, { env: this.deps.env ?? process.env, fresh });
+  }
+};
+
+// src/host/schedule.ts
+var schedule_exports = {};
+__export(schedule_exports, {
+  Scheduler: () => Scheduler,
+  isDue: () => isDue,
+  nextOccurrence: () => nextOccurrence,
+  parseClock: () => parseClock,
+  zonedDateString: () => zonedDateString,
+  zonedTimeToUtc: () => zonedTimeToUtc
+});
+var MINUTE = 6e4;
+var CATCH_UP_MINUTES = 6 * 60;
+function partsOf(date, timezone) {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const map = /* @__PURE__ */ new Map();
+  for (const part of formatter.formatToParts(date)) {
+    if (part.type !== "literal") map.set(part.type, part.value);
+  }
+  return {
+    year: Number(map.get("year")),
+    month: Number(map.get("month")),
+    day: Number(map.get("day")),
+    hour: Number(map.get("hour")),
+    minute: Number(map.get("minute")),
+    second: Number(map.get("second"))
+  };
+}
+function offsetMs(date, timezone) {
+  const parts = partsOf(date, timezone);
+  const asUtc = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+  return asUtc - Math.floor(date.getTime() / 1e3) * 1e3;
+}
+function zonedTimeToUtc(year, month, day, hour, minute, second, timezone) {
+  const guess = Date.UTC(year, month - 1, day, hour, minute, second);
+  const first = new Date(guess - offsetMs(new Date(guess), timezone));
+  return new Date(guess - offsetMs(first, timezone));
+}
+function parseClock(time) {
+  const match = /^([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d))?$/.exec(time.trim());
+  if (match === null) throw new Error(`\u975E\u6CD5\u65F6\u95F4\uFF1A${time}`);
+  return {
+    hour: Number(match[1]),
+    minute: Number(match[2]),
+    second: Number(match[3] ?? "0")
+  };
+}
+function zonedDateString(date, timezone) {
+  const parts = partsOf(date, timezone);
+  return `${String(parts.year).padStart(4, "0")}-${String(parts.month).padStart(2, "0")}-${String(parts.day).padStart(2, "0")}`;
+}
+function nextOccurrence(now, schedule) {
+  const { hour, minute, second } = parseClock(schedule.time);
+  const today = partsOf(now, schedule.timezone);
+  const candidate = zonedTimeToUtc(today.year, today.month, today.day, hour, minute, second, schedule.timezone);
+  if (candidate.getTime() > now.getTime()) return candidate;
+  const tomorrow = new Date(Date.UTC(today.year, today.month - 1, today.day) + 864e5);
+  return zonedTimeToUtc(
+    tomorrow.getUTCFullYear(),
+    tomorrow.getUTCMonth() + 1,
+    tomorrow.getUTCDate(),
+    hour,
+    minute,
+    second,
+    schedule.timezone
+  );
+}
+function isDue(now, schedule) {
+  const { hour, minute } = parseClock(schedule.time);
+  const parts = partsOf(now, schedule.timezone);
+  const nowMinutes = parts.hour * 60 + parts.minute;
+  const targetMinutes = hour * 60 + minute;
+  const late = nowMinutes - targetMinutes;
+  return late >= 0 && late <= CATCH_UP_MINUTES;
+}
+var Scheduler = class {
+  deps;
+  timerHandle;
+  stopped = false;
+  lastFiredFor;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  start() {
+    this.stopped = false;
+    const timer = this.deps.getTimer();
+    const tick = () => {
+      void this.tick();
+    };
+    if (timer !== void 0 && typeof timer.interval === "function") {
+      this.timerHandle = timer.interval(tick, MINUTE);
+    } else {
+      const handle = setInterval(tick, MINUTE);
+      handle.unref?.();
+      this.timerHandle = handle;
+    }
+    setTimeout(tick, 5e3).unref?.();
+  }
+  stop() {
+    this.stopped = true;
+    const handle = this.timerHandle;
+    if (typeof handle === "object" && handle !== null && typeof handle.clear === "function") handle.clear();
+    else if (typeof handle === "number" || handle !== void 0) clearInterval(handle);
+    this.timerHandle = void 0;
+  }
+  /** 公开给测试：判断此刻是否该跑，并按需触发一次。 */
+  async tick(now = /* @__PURE__ */ new Date()) {
+    if (this.stopped) return "skipped";
+    const schedule = this.readSchedule();
+    if (!schedule.enabled) return "disabled";
+    if (!isDue(now, schedule)) return "skipped";
+    const today = zonedDateString(now, schedule.timezone);
+    const state = this.deps.store.readState();
+    const lastDate = state.lastRunAt === void 0 ? void 0 : zonedDateString(new Date(state.lastRunAt), schedule.timezone);
+    if (lastDate === today) return "skipped";
+    if (this.lastFiredFor === today) return "skipped";
+    if (this.deps.isRunning()) return "busy";
+    this.lastFiredFor = today;
+    try {
+      await this.deps.run("schedule");
+      return "ran";
+    } catch (error) {
+      this.deps.onError?.(error);
+      return "skipped";
+    }
+  }
+  readSchedule() {
+    const settings = this.deps.store.readSettings();
+    return {
+      enabled: settings.schedule.enabled,
+      time: settings.schedule.time,
+      timezone: settings.schedule.timezone
+    };
+  }
+  /** 下一次运行（禁用时为 undefined）。 */
+  next() {
+    const schedule = this.readSchedule();
+    if (!schedule.enabled) return void 0;
+    try {
+      return nextOccurrence(/* @__PURE__ */ new Date(), schedule);
+    } catch {
+      return void 0;
+    }
+  }
+  describe(state, now = /* @__PURE__ */ new Date()) {
+    const schedule = this.readSchedule();
+    const next = schedule.enabled ? this.next() : void 0;
+    return {
+      enabled: schedule.enabled,
+      time: schedule.time,
+      timezone: schedule.timezone,
+      ...next === void 0 ? {} : { nextRunAt: next.toISOString() },
+      ...state.lastRunAt === void 0 ? {} : { lastRunDate: zonedDateString(new Date(state.lastRunAt), schedule.timezone) },
+      catchUpMinutes: CATCH_UP_MINUTES,
+      source: "timer"
+    };
+  }
+};
+
+// src/host/import-cli.ts
+var import_cli_exports = {};
+__export(import_cli_exports, {
+  cliConfigCandidates: () => cliConfigCandidates,
+  importFirstAvailable: () => importFirstAvailable,
+  importFromCli: () => importFromCli,
+  parseSimpleYaml: () => parseSimpleYaml
+});
+import { readFileSync as readFileSync3 } from "fs";
+import os3 from "os";
+import path9 from "path";
+function cliConfigCandidates(env = process.env, home = os3.homedir()) {
+  const xdg = env.XDG_CONFIG_HOME?.trim();
+  const base = xdg !== void 0 && xdg !== "" ? path9.resolve(xdg) : path9.join(home, ".config");
+  return [
+    env.TRENDradar_CONFIG?.trim() ?? "",
+    path9.join(base, "trendradar", "config.yaml"),
+    path9.join(home, ".trendradar", "config.yaml")
+  ].filter((item) => item !== "");
+}
+function unquote(raw) {
+  const value = raw.trim();
+  if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value.slice(1, -1);
+    }
+  }
+  if (value.startsWith("'") && value.endsWith("'") && value.length >= 2) return value.slice(1, -1);
+  return value;
+}
+function scalar(raw) {
+  const value = raw.trim();
+  if (value === "") return "";
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (inner === "") return [];
+    return inner.split(",").map((item) => unquote(item));
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+  return unquote(value);
+}
+function parseSimpleYaml(text) {
+  const root = {};
+  let current;
+  let currentIndent = -1;
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.replace(/\r$/, "");
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    const match = /^([^:#]+):(.*)$/.exec(trimmed);
+    if (match === null) throw new Error(`\u65E0\u6CD5\u89E3\u6790\u7684 YAML \u884C\uFF1A${trimmed}`);
+    const key = match[1]?.trim() ?? "";
+    const rest = match[2] ?? "";
+    if (rest.trim() === "") {
+      const child = {};
+      root[key] = child;
+      current = child;
+      currentIndent = indent;
+      continue;
+    }
+    if (indent === 0) {
+      root[key] = scalar(rest);
+      current = void 0;
+      currentIndent = -1;
+      continue;
+    }
+    if (current === void 0 || indent <= currentIndent) {
+      root[key] = scalar(rest);
+      continue;
+    }
+    current[key] = scalar(rest);
+  }
+  return root;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asBool(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function asStrings(value) {
+  return Array.isArray(value) && value.length > 0 ? value.filter((item) => typeof item === "string") : void 0;
+}
+function isSecretKey(key) {
+  return /(apikey|api_key|token|secret|password|passwd|credential)/i.test(key);
+}
+function importFromCli(filePath, base = DEFAULT_SETTINGS) {
+  let text;
+  try {
+    text = readFileSync3(filePath, "utf8");
+  } catch (error) {
+    return {
+      ok: false,
+      source: filePath,
+      imported: [],
+      skippedSecrets: [],
+      problems: [`\u8BFB\u53D6\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`]
+    };
+  }
+  let parsed;
+  try {
+    parsed = parseSimpleYaml(text);
+  } catch (error) {
+    return {
+      ok: false,
+      source: filePath,
+      imported: [],
+      skippedSecrets: [],
+      problems: [`\u89E3\u6790\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`]
+    };
+  }
+  const imported = [];
+  const skippedSecrets = [];
+  const model = asRecord(parsed.model);
+  const repo = asRecord(parsed.repo);
+  const pr = asRecord(parsed.pr);
+  const trending = asRecord(parsed.trending);
+  const output = asRecord(parsed.output);
+  const schedule = asRecord(parsed.schedule);
+  const patch = JSON.parse(JSON.stringify(base));
+  const take = (keys, key, value, apply) => {
+    if (value === void 0) return;
+    apply(value);
+    keys.push(key);
+  };
+  take(imported, "model.provider", asString(model.provider), (value) => {
+    patch.model.provider = value;
+  });
+  take(imported, "model.model", asString(model.name), (value) => {
+    patch.model.model = value;
+  });
+  take(imported, "model.baseURL", asString(model.baseURL), (value) => {
+    patch.model.baseURL = value;
+  });
+  take(imported, "model.temperature", asNumber(model.temperature), (value) => {
+    patch.model.temperature = value;
+  });
+  take(imported, "model.maxTokens", asNumber(model.maxTokens), (value) => {
+    patch.model.maxTokens = value;
+  });
+  take(imported, "model.allowDegraded", asBool(model.allowDegraded), (value) => {
+    patch.model.allowDegraded = value;
+  });
+  take(imported, "repo.path", asString(repo.path), (value) => {
+    patch.repo.path = value;
+  });
+  take(imported, "repo.remote", asString(repo.remote), (value) => {
+    patch.repo.remote = value;
+  });
+  take(imported, "repo.baseBranch", asString(repo.baseBranch), (value) => {
+    patch.repo.baseBranch = value;
+  });
+  take(imported, "repo.authorName", asString(repo.authorName), (value) => {
+    patch.repo.authorName = value;
+  });
+  take(imported, "repo.authorEmail", asString(repo.authorEmail), (value) => {
+    patch.repo.authorEmail = value;
+  });
+  take(imported, "pr.enabled", asBool(pr.enabled), (value) => {
+    patch.pr.enabled = value;
+  });
+  take(imported, "pr.titleTemplate", asString(pr.titleTemplate), (value) => {
+    patch.pr.titleTemplate = value;
+  });
+  take(imported, "pr.autoMerge", asBool(pr.autoMerge), (value) => {
+    patch.pr.autoMerge = value;
+  });
+  take(imported, "pr.labels", asStrings(pr.labels), (value) => {
+    patch.pr.labels = value;
+  });
+  take(imported, "trending.languages", asStrings(trending.languages), (value) => {
+    patch.trending.languages = value;
+  });
+  take(imported, "trending.since", asString(trending.since), (value) => {
+    patch.trending.since = value === "weekly" ? "weekly" : "daily";
+  });
+  take(imported, "trending.perLanguage", asNumber(trending.perLanguage), (value) => {
+    patch.trending.topN = Math.round(value);
+  });
+  take(imported, "output.dir", asString(output.dir), (value) => {
+    patch.output.dir = value;
+  });
+  for (const [section, values] of Object.entries({ model, repo, pr, trending, output, schedule })) {
+    for (const [key, value] of Object.entries(values)) {
+      if (isSecretKey(key) && value !== void 0 && value !== "") skippedSecrets.push(`${section}.${key}`);
+    }
+  }
+  if (patch.model.baseURL === "") {
+    const fallback = PROVIDER_BASE_URLS[patch.model.provider];
+    if (fallback !== void 0) patch.model.baseURL = fallback;
+  }
+  const problems = [];
+  if (asString(schedule.cron) !== void 0) {
+    problems.push("CLI \u7684 schedule.cron \u65E0\u6CD5\u6620\u5C04\u6210\u63D2\u4EF6\u7684\u6BCF\u65E5\u65F6\u95F4\uFF0C\u672A\u5BFC\u5165\uFF08\u8BF7\u5728\u8BBE\u7F6E\u9875\u91CD\u8BBE\u65F6\u95F4\uFF09\u3002");
+  }
+  if (skippedSecrets.length > 0) {
+    problems.push(`\u5BC6\u94A5\u7C7B\u5B57\u6BB5\u4E0D\u5BFC\u5165\uFF1A${skippedSecrets.join("\u3001")}\uFF08\u8BF7\u5728\u8BBE\u7F6E\u9875\u624B\u52A8\u586B\u5199\u6216\u6CBF\u7528 DSH \u51ED\u636E\uFF09\u3002`);
+  }
+  return {
+    ok: imported.length > 0,
+    source: filePath,
+    settings: normalizeSettings(patch),
+    imported,
+    skippedSecrets,
+    problems
+  };
+}
+function importFirstAvailable(env = process.env, base) {
+  const candidates = cliConfigCandidates(env);
+  for (const candidate of candidates) {
+    const result = importFromCli(candidate, base);
+    if (result.ok || result.problems.some((problem) => problem.startsWith("\u89E3\u6790\u5931\u8D25"))) return result;
+  }
+  return {
+    ok: false,
+    imported: [],
+    skippedSecrets: [],
+    problems: [`\u6CA1\u6709\u627E\u5230\u672C\u673A CLI \u914D\u7F6E\uFF08\u627E\u8FC7\uFF1A${candidates.join("\u3001")}\uFF09`]
+  };
+}
+
+// src/host/preflight.ts
+var preflight_exports = {};
+__export(preflight_exports, {
+  preflightModel: () => preflightModel
+});
+var TIMEOUT_MS = 15e3;
+async function preflightModel(options) {
+  const started = Date.now();
+  const settings = options.settings;
+  const key = await resolveModelKey(settings, options.credentials, options.env ?? process.env);
+  if (key.mode === "proxy") {
+    const llm = options.llm;
+    if (llm === void 0 || typeof llm.stream !== "function") {
+      return {
+        ok: false,
+        code: "MODEL_KEY_MISSING",
+        message: "\u8BE5\u6A21\u578B\u9700\u8981\u56DE\u73AF\u4EE3\u7406\uFF0C\u4F46\u5BBF\u4E3B\u6CA1\u6709\u53EF\u7528\u7684 ctx.llm \u670D\u52A1",
+        hint: hintOf("MODEL_KEY_MISSING"),
+        area: areaOf("MODEL_KEY_MISSING"),
+        durationMs: Date.now() - started,
+        mode: "proxy"
+      };
+    }
+    const provider = settings.model.hostProvider !== "" ? settings.model.hostProvider : settings.model.provider;
+    const controller2 = new AbortController();
+    const timer2 = setTimeout(() => controller2.abort(), TIMEOUT_MS);
+    try {
+      const stream = llm.stream({
+        provider,
+        model: settings.model.model,
+        messages: [{ role: "user", content: [{ type: "text", text: "ping" }] }],
+        maxTokens: 8,
+        signal: controller2.signal
+      });
+      let failure;
+      for await (const chunk of stream) {
+        if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) {
+          failure = chunk.reason.failure;
+        }
+      }
+      if (failure !== void 0) {
+        const code = failure.code === "AUTH" ? "MODEL_UNAUTHORIZED" : failure.code === "RATE_LIMIT" ? "MODEL_RATE_LIMITED" : "MODEL_FAILED";
+        return {
+          ok: false,
+          code,
+          message: failure.message ?? failure.code ?? "\u5BBF\u4E3B\u6A21\u578B\u8C03\u7528\u5931\u8D25",
+          hint: hintOf(code),
+          area: areaOf(code),
+          durationMs: Date.now() - started,
+          mode: "proxy"
+        };
+      }
+      return { ok: true, durationMs: Date.now() - started, mode: "proxy", endpoint: `\u5BBF\u4E3B provider ${provider}` };
+    } catch (error) {
+      return {
+        ok: false,
+        code: "MODEL_FAILED",
+        message: error instanceof Error ? error.message : String(error),
+        hint: hintOf("MODEL_FAILED"),
+        area: areaOf("MODEL_FAILED"),
+        durationMs: Date.now() - started,
+        mode: "proxy"
+      };
+    } finally {
+      clearTimeout(timer2);
+    }
+  }
+  if (key.apiKey === void 0 || key.apiKey === "") {
+    return {
+      ok: false,
+      code: "MODEL_KEY_MISSING",
+      message: `\u6CA1\u6709\u89E3\u6790\u5230\u6A21\u578B\u5BC6\u94A5\uFF08\u5F15\u7528 ${settings.model.apiKeyRef}\uFF09`,
+      hint: hintOf("MODEL_KEY_MISSING"),
+      area: areaOf("MODEL_KEY_MISSING"),
+      durationMs: Date.now() - started,
+      mode: "direct"
+    };
+  }
+  const baseURL = effectiveBaseURL(settings.model).replace(/\/+$/, "");
+  const endpoint = `${baseURL}/chat/completions`;
+  const doFetch = options.fetchImpl ?? fetch;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+  try {
+    const response = await doFetch(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${key.apiKey}` },
+      body: JSON.stringify({
+        model: settings.model.model,
+        messages: [{ role: "user", content: "ping" }],
+        max_tokens: 8,
+        temperature: 0
+      }),
+      signal: controller.signal
+    });
+    if (response.ok) return { ok: true, durationMs: Date.now() - started, mode: "direct", endpoint };
+    const text = await response.text().catch(() => "");
+    const snippet = text.slice(0, 400);
+    const code = response.status === 401 || response.status === 403 ? "MODEL_UNAUTHORIZED" : response.status === 404 || /model[^\n]*not found|not found[^\n]*model/i.test(snippet) ? "MODEL_NOT_FOUND" : response.status === 429 ? "MODEL_RATE_LIMITED" : "MODEL_FAILED";
+    return {
+      ok: response.status === 429,
+      code,
+      message: `HTTP ${response.status}\uFF1A${snippet === "" ? response.statusText : snippet}`,
+      hint: hintOf(code),
+      area: areaOf(code),
+      durationMs: Date.now() - started,
+      mode: "direct",
+      endpoint
+    };
+  } catch (error) {
+    const aborted = error instanceof Error && error.name === "AbortError";
+    const code = aborted ? "MODEL_TIMEOUT" : "MODEL_FAILED";
+    return {
+      ok: false,
+      code,
+      message: aborted ? `\u9884\u68C0\u8D85\u65F6\uFF08${TIMEOUT_MS / 1e3} s\uFF09` : error instanceof Error ? error.message : String(error),
+      hint: hintOf(code),
+      area: areaOf(code),
+      durationMs: Date.now() - started,
+      mode: "direct",
+      endpoint
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/host/routes.ts
+var routes_exports = {};
+__export(routes_exports, {
+  HEADER: () => HEADER,
+  ROUTE_PREFIX: () => ROUTE_PREFIX,
+  createRoutes: () => createRoutes
+});
+var ROUTE_PREFIX = "/api/morehao/github-trending";
+var HEADER = "x-dsh-github-trending";
+var MAX_BODY2 = 512 * 1024;
+function sendJson2(response, status, payload) {
+  const body = JSON.stringify(payload);
+  response.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store",
+    "content-length": Buffer.byteLength(body)
+  });
+  response.end(body);
+}
+async function readBody2(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    size += chunk.length;
+    if (size > MAX_BODY2) throw new IpcError("PAYLOAD_TOO_LARGE", "\u8BF7\u6C42\u4F53\u8FC7\u5927");
+    chunks.push(chunk);
+  }
+  if (chunks.length === 0) return {};
+  const text = Buffer.concat(chunks).toString("utf8").trim();
+  if (text === "") return {};
+  try {
+    const value = JSON.parse(text);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      throw new Error("body must be a JSON object");
+    }
+    return value;
+  } catch (error) {
+    throw new IpcError("CONFIG_INVALID", `\u8BF7\u6C42\u4F53\u4E0D\u662F JSON \u5BF9\u8C61\uFF1A${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function createRoutes(deps) {
+  return async function handler(request, response) {
+    if (request.headers[HEADER] !== "1") {
+      sendJson2(response, 403, { ok: false, code: "FORBIDDEN", message: `\u7F3A\u5C11 ${HEADER}: 1 \u5934` });
+      return;
+    }
+    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    const pathname = url.pathname.startsWith(ROUTE_PREFIX) ? url.pathname.slice(ROUTE_PREFIX.length) || "/" : url.pathname;
+    const method = (request.method ?? "GET").toUpperCase();
+    try {
+      const result = await dispatch(method, pathname, url, request, deps);
+      if (!response.writableEnded) sendJson2(response, 200, { ok: true, ...result });
+    } catch (error) {
+      if (response.writableEnded) return;
+      const code = error instanceof IpcError ? error.code : "INTERNAL";
+      const message = redact(error instanceof Error ? error.message : String(error));
+      deps.logger?.("route.error", { pathname, method, code, message });
+      sendJson2(response, code === "CONFIG_INVALID" ? 400 : 500, { ok: false, code, message });
+    }
+  };
+}
+async function dispatch(method, pathname, url, request, deps) {
+  const env = deps.env ?? process.env;
+  const settings = deps.store.readSettings();
+  if (method === "GET" && pathname === "/state") return statePayload(deps, settings);
+  if (method === "GET" && pathname === "/core") {
+    const core = await inspectCore(settings, { env, fresh: url.searchParams.get("fresh") === "1" });
+    const coexistence = await detectCoexistence(core.path, { env });
+    return { core, coexistence };
+  }
+  if (method === "POST" && pathname === "/core/download") {
+    const core = await locateCore({ settings, env, forceDownload: true });
+    const status = await inspectCore(settings, { env, fresh: true });
+    return { downloaded: true, path: core.path, tag: core.tag ?? null, core: status };
+  }
+  if (method === "POST" && pathname === "/config") {
+    const body = await readBody2(request);
+    const next = normalizeSettings(body.settings ?? body);
+    const core = await inspectCore({ ...next, corePath: settings.corePath }, { env });
+    const providers = core.supportedProviders.length > 0 ? core.supportedProviders : void 0;
+    const problems = validateSettings(next, providers);
+    if (problems.length > 0) {
+      return { saved: false, problems, settings: next };
+    }
+    deps.store.writeSettings(next);
+    return { saved: true, settings: next, problems: [] };
+  }
+  if (method === "POST" && pathname === "/preflight") {
+    const body = await readBody2(request);
+    const candidate = body.settings === void 0 ? settings : normalizeSettings(body.settings);
+    const result = await preflightModel({
+      settings: candidate,
+      credentials: credentialServices(deps.get),
+      llm: llmServices(deps.get),
+      env
+    });
+    return { preflight: result };
+  }
+  if (method === "POST" && pathname === "/run") {
+    const body = await readBody2(request);
+    const summary = await deps.runner.run({
+      dryRun: body.dryRun === true,
+      ...typeof body.date === "string" && body.date !== "" ? { date: body.date } : {},
+      trigger: "manual"
+    });
+    return { summary };
+  }
+  if (method === "POST" && pathname === "/run/cancel") {
+    return { cancelled: deps.runner.cancel() };
+  }
+  if (method === "GET" && pathname === "/quickfill") {
+    const candidates = await listProviderCandidates({
+      llm: llmServices(deps.get),
+      credentials: credentialServices(deps.get),
+      env
+    });
+    return { providers: candidates };
+  }
+  if (method === "POST" && pathname === "/quickfill") {
+    const body = await readBody2(request);
+    const providerId = typeof body.providerId === "string" ? body.providerId : "";
+    const modelId = typeof body.modelId === "string" ? body.modelId : "";
+    const candidates = await listProviderCandidates({
+      llm: llmServices(deps.get),
+      credentials: credentialServices(deps.get),
+      env
+    });
+    const candidate = candidates.find((item) => item.id === providerId);
+    if (candidate === void 0) throw new IpcError("CONFIG_INVALID", `\u5BBF\u4E3B\u6CA1\u6709\u8FD9\u4E2A provider\uFF1A${providerId}`);
+    if (modelId === "") throw new IpcError("CONFIG_INVALID", "\u5FC5\u987B\u9009\u62E9\u4E00\u4E2A\u6A21\u578B");
+    const next = applyCandidate(settings, candidate, modelId);
+    deps.store.writeSettings(next);
+    return { saved: true, settings: next, applied: { provider: candidate.id, model: modelId, mode: candidate.credential.mode } };
+  }
+  if (method === "POST" && pathname === "/import") {
+    const result = importFirstAvailable(env, settings);
+    if (result.ok && result.settings !== void 0) deps.store.writeSettings(result.settings);
+    return { import: { ...result, settings: result.settings === void 0 ? void 0 : result.settings } };
+  }
+  if (method === "GET" && pathname === "/log") {
+    const id = url.searchParams.get("id") ?? "";
+    if (!/^[A-Za-z0-9-]+$/.test(id)) throw new IpcError("CONFIG_INVALID", "\u975E\u6CD5\u7684\u8FD0\u884C id");
+    const file = deps.store.newLogPath(id);
+    const text = deps.store.readLog(file);
+    return { id, exists: text !== "", text };
+  }
+  throw new IpcError("NOT_FOUND", `\u672A\u5904\u7406\u7684\u8DEF\u7531\uFF1A${method} ${pathname}`);
+}
+async function statePayload(deps, settings) {
+  const env = deps.env ?? process.env;
+  const credentials = credentialServices(deps.get);
+  const state = deps.store.readState();
+  const history = deps.store.readHistory().slice(0, 10);
+  const core = await inspectCore(settings, { env });
+  const coexistence = await detectCoexistence(core.path, { env });
+  const modelCredential = await describeRef(credentials, settings.model.apiKeyRef, env);
+  const github = await resolveGithubToken(credentials, settings.github.authMode, settings.github.tokenRef, { env });
+  return {
+    plugin: { name: "@morehao/dsh-github-trending", version: deps.version },
+    settings,
+    core,
+    coexistence,
+    schedule: deps.scheduler.describe(state),
+    status: {
+      running: deps.runner.running ?? null,
+      lastRunAt: state.lastRunAt ?? null,
+      lastDigest: state.lastDigest ?? null,
+      lastResult: state.lastResult ?? null,
+      pendingPr: state.pendingPr ?? null,
+      history
+    },
+    model: {
+      mode: settings.model.mode,
+      credential: {
+        ref: settings.model.apiKeyRef,
+        configured: modelCredential.configured,
+        source: modelCredential.source ?? null,
+        writable: modelCredential.writable
+      },
+      effectiveBaseURL: settings.model.baseURL
+    },
+    github: {
+      authMode: settings.github.authMode,
+      configured: github.token !== void 0,
+      source: github.source
+    }
+  };
+}
+
+// src/tools.ts
+var tools_exports = {};
+__export(tools_exports, {
+  createTrendingHistoryTool: () => createTrendingHistoryTool,
+  createTrendingRunTool: () => createTrendingRunTool
+});
+var RUN_OUTPUT_SCHEMA = {
+  type: "object",
+  additionalProperties: true,
+  properties: {
+    id: { type: "string" },
+    ok: { type: "boolean" },
+    skipped: { type: "boolean" },
+    dryRun: { type: "boolean" },
+    durationMs: { type: "number" },
+    coreVersion: { type: "string" },
+    files: { type: "number" },
+    contentHash: { type: "string" },
+    branch: { type: "string" },
+    prUrl: { type: "string" },
+    errorCode: { type: "string" },
+    errorMessage: { type: "string" },
+    errorHint: { type: "string" },
+    warnings: { type: "array", items: { type: "string" } },
+    markdown: { type: "string" }
+  },
+  required: ["ok", "markdown"]
+};
+var HISTORY_OUTPUT_SCHEMA = {
+  type: "object",
+  additionalProperties: true,
+  properties: {
+    lastRunAt: { type: "string" },
+    nextRunAt: { type: "string" },
+    coreVersion: { type: "string" },
+    model: { type: "string" },
+    provider: { type: "string" },
+    pendingPr: { type: "string" },
+    records: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          at: { type: "string" },
+          ok: { type: "boolean" },
+          skipped: { type: "boolean" },
+          errorCode: { type: "string" },
+          durationMs: { type: "number" },
+          files: { type: "number" },
+          branch: { type: "string" },
+          prUrl: { type: "string" },
+          coreVersion: { type: "string" }
+        }
+      }
+    },
+    markdown: { type: "string" }
+  },
+  required: ["markdown"]
+};
+function formatDuration(ms) {
+  if (ms <= 0) return "\u2014";
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function describeRecord(record) {
+  const when = record.at.replace("T", " ").slice(0, 19);
+  const state = record.skipped ? "\u65E0\u53D8\u66F4" : record.ok ? "\u6210\u529F" : `\u5931\u8D25 ${record.errorCode ?? ""}`.trim();
+  const tail = [record.branch, record.prUrl].filter((item) => typeof item === "string" && item !== "").join(" \xB7 ");
+  return `\xB7 ${when} ${state} \xB7 ${record.files} \u4E2A\u6587\u4EF6 \xB7 ${formatDuration(record.durationMs)}${tail === "" ? "" : ` \xB7 ${tail}`}`;
+}
+function createTrendingRunTool(runner) {
+  return {
+    name: "trending_run",
+    description: "\u6267\u884C\u4E00\u6B21 GitHub \u8D8B\u52BF\u65E5\u62A5\uFF1A\u5B9A\u4F4D\u5E76\u63E1\u624B\u672C\u5730\u6838\u5FC3\uFF0Cspawn \u4E00\u6B21 run\uFF0C\u8FD4\u56DE\u7ED3\u6784\u5316\u6458\u8981\uFF08\u6587\u4EF6\u6570\u3001commit\u3001PR\u3001\u9519\u8BEF\u7801\uFF09\u3002dryRun=true \u53EA\u6293\u53D6\u4E0E\u6E32\u67D3\u3001\u4E0D\u5199\u6587\u4EF6\u4E5F\u4E0D\u63D0\u4EA4\u3002\u540C\u65E5\u540C\u5185\u5BB9\u91CD\u8DD1\u4F1A\u8FD4\u56DE skipped=true\uFF08\u96F6\u65B0\u589E commit\uFF09\u3002",
+    parameters: {
+      dryRun: { type: "boolean", description: "\u53EA\u8BD5\u8DD1\uFF1A\u4E0D\u5199\u6587\u4EF6\u3001\u4E0D\u63D0\u4EA4\u3001\u4E0D\u5F00 PR" },
+      date: { type: "string", description: "\u6307\u5B9A\u65E5\u671F\uFF08YYYY-MM-DD\uFF09\uFF1B\u7701\u7565\u5219\u7528\u4ECA\u5929" }
+    },
+    output: {
+      schema: RUN_OUTPUT_SCHEMA,
+      render: (_args, value) => [{ type: "text", text: typeof value?.markdown === "string" ? value.markdown : "" }]
+    },
+    async execute(args = {}, exec = {}) {
+      void exec;
+      const summary = await runner.run({
+        dryRun: args.dryRun === true,
+        ...typeof args.date === "string" && args.date !== "" ? { date: args.date } : {},
+        trigger: "tool"
+      });
+      const lines = [];
+      const head = summary.ok ? summary.skipped ? "\u65E0\u53D8\u66F4\uFF08skipped\uFF09" : summary.dryRun ? "\u8BD5\u8DD1\u5B8C\u6210" : "\u8FD0\u884C\u6210\u529F" : `\u8FD0\u884C\u5931\u8D25\uFF1A${summary.error?.code ?? "INTERNAL"}`;
+      lines.push(`${summary.ok ? "\u2713" : "\u2717"} ${head}`);
+      lines.push(`\xB7 \u6838\u5FC3 ${summary.coreVersion || "(\u672A\u77E5)"} \xB7 ${formatDuration(summary.durationMs)} \xB7 ${summary.files} \u4E2A\u6587\u4EF6`);
+      if (summary.contentHash !== void 0) lines.push(`\xB7 contentHash ${summary.contentHash.slice(0, 12)}`);
+      if (summary.branch !== void 0) lines.push(`\xB7 \u5206\u652F ${summary.branch}`);
+      if (summary.prUrl !== void 0) lines.push(`\xB7 PR ${summary.prUrl}`);
+      if (summary.error !== void 0) {
+        lines.push(`\xB7 ${summary.error.message}`);
+        lines.push(`\xB7 \u4E0B\u4E00\u6B65\uFF1A${summary.error.hint}`);
+      }
+      if (summary.dryRun) lines.push("\xB7 \u8FD9\u662F\u8BD5\u8DD1\uFF0C\u6CA1\u6709\u5199\u6587\u4EF6\u3001\u6CA1\u6709\u63D0\u4EA4");
+      return {
+        id: summary.id,
+        ok: summary.ok,
+        skipped: summary.skipped,
+        dryRun: summary.dryRun,
+        durationMs: summary.durationMs,
+        coreVersion: summary.coreVersion,
+        files: summary.files,
+        ...summary.contentHash === void 0 ? {} : { contentHash: summary.contentHash },
+        ...summary.branch === void 0 ? {} : { branch: summary.branch },
+        ...summary.prUrl === void 0 ? {} : { prUrl: summary.prUrl },
+        ...summary.error === void 0 ? {} : { errorCode: summary.error.code, errorMessage: summary.error.message, errorHint: summary.error.hint },
+        warnings: summary.warnings,
+        markdown: lines.join("\n")
+      };
+    }
+  };
+}
+function createTrendingHistoryTool(store, scheduler) {
+  return {
+    name: "trending_history",
+    description: "\u67E5\u770B GitHub \u8D8B\u52BF\u65E5\u62A5\u7684\u8FD0\u884C\u72B6\u6001\uFF1A\u4E0A\u6B21/\u4E0B\u6B21\u8FD0\u884C\u3001\u6700\u8FD1 N \u6761\u8BB0\u5F55\uFF08\u7ED3\u679C\u3001\u8017\u65F6\u3001commit/PR\u3001\u9519\u8BEF\u7801\uFF09\u3001\u6838\u5FC3\u7248\u672C\u3001\u5F53\u524D\u6A21\u578B\u4E0E\u672A\u5408\u5E76 PR\u3002",
+    parameters: {
+      limit: { type: "number", description: "\u8FD4\u56DE\u6700\u8FD1\u591A\u5C11\u6761\u8BB0\u5F55\uFF08\u9ED8\u8BA4 10\uFF0C\u6700\u591A 30\uFF09" }
+    },
+    output: {
+      schema: HISTORY_OUTPUT_SCHEMA,
+      render: (_args, value) => [{ type: "text", text: typeof value?.markdown === "string" ? value.markdown : "" }]
+    },
+    async execute(args = {}) {
+      const limit = Math.min(Math.max(Math.round(Number(args.limit ?? 10)) || 10, 1), 30);
+      const settings = store.readSettings();
+      const state = store.readState();
+      const records = store.readHistory().slice(0, limit);
+      const schedule = scheduler.describe(state);
+      const lines = [];
+      lines.push(`\u4E0A\u6B21\u8FD0\u884C\uFF1A${state.lastRunAt === void 0 ? "\u4ECE\u672A" : state.lastRunAt.replace("T", " ").slice(0, 19)}`);
+      lines.push(`\u4E0B\u6B21\u8FD0\u884C\uFF1A${schedule.nextRunAt === void 0 ? "\u672A\u542F\u7528" : `${schedule.nextRunAt.replace("T", " ").slice(0, 16)} UTC\uFF08${schedule.time} ${schedule.timezone}\uFF09`}`);
+      lines.push(`\u6838\u5FC3\u7248\u672C\uFF1A${state.lastResult?.coreVersion ?? "(\u5C1A\u672A\u8FD0\u884C)"}`);
+      lines.push(`\u6A21\u578B\uFF1A${settings.model.provider} / ${settings.model.model || "(\u672A\u586B)"} \xB7 ${settings.model.mode === "proxy" ? "\u56DE\u73AF\u4EE3\u7406" : `\u51ED\u636E ${settings.model.apiKeyRef}`}`);
+      if (state.pendingPr !== void 0) lines.push(`\u672A\u5408\u5E76 PR\uFF1A${state.pendingPr.url}`);
+      if (state.lastDigest !== void 0) {
+        lines.push(`\u4E0A\u6B21\u5185\u5BB9\uFF1A${state.lastDigest.date} \xB7 ${state.lastDigest.contentHash.slice(0, 12)} \xB7 \u6838\u5FC3 ${state.lastDigest.coreVersion}`);
+      }
+      lines.push(`\u6700\u8FD1 ${records.length} \u6B21\uFF1A`);
+      if (records.length === 0) lines.push("\xB7 \u8FD8\u6CA1\u6709\u8FD0\u884C\u8BB0\u5F55");
+      for (const record of records) lines.push(describeRecord(record));
+      return {
+        ...state.lastRunAt === void 0 ? {} : { lastRunAt: state.lastRunAt },
+        ...schedule.nextRunAt === void 0 ? {} : { nextRunAt: schedule.nextRunAt },
+        coreVersion: state.lastResult?.coreVersion ?? "",
+        model: settings.model.model,
+        provider: settings.model.provider,
+        ...state.pendingPr === void 0 ? {} : { pendingPr: state.pendingPr.url },
+        records,
+        markdown: lines.join("\n")
+      };
+    }
+  };
+}
+
+export {
+  config_exports,
+  paths_exports,
+  Store,
+  state_exports,
+  errors_exports,
+  ipc_exports,
+  handshake_exports,
+  release_exports,
+  locate_exports,
+  channel_exports,
+  run_exports,
+  core_exports,
+  credentials_exports,
+  quickfill_exports,
+  proxy_exports,
+  Runner,
+  runner_exports,
+  Scheduler,
+  schedule_exports,
+  import_cli_exports,
+  preflight_exports,
+  ROUTE_PREFIX,
+  createRoutes,
+  routes_exports,
+  createTrendingRunTool,
+  createTrendingHistoryTool,
+  tools_exports
+};