@yoooclaw/cli 0.0.3 → 0.0.4

package/dist/bin.cjs

@@ -2944,8 +2944,8 @@ async function writeTextAtomic(filePath, content, options) {
   const mkdirOptions = { recursive: true };
   if (typeof options?.ensureDirMode === "number")
     mkdirOptions.mode = options.ensureDirMode;
-  await import_promises3.default.mkdir(import_node_path10.default.dirname(filePath), mkdirOptions);
-  const parentDir = import_node_path10.default.dirname(filePath);
+  await import_promises3.default.mkdir(import_node_path9.default.dirname(filePath), mkdirOptions);
+  const parentDir = import_node_path9.default.dirname(filePath);
   const tmp = `${filePath}.${import_node_crypto5.randomUUID()}.tmp`;
   try {
     const tmpHandle = await import_promises3.default.open(tmp, "w", mode);
@@ -2996,9 +2996,9 @@ function createAsyncLock() {
     }
   };
 }
-var import_node_path10, import_promises3, import_node_crypto5;
+var import_node_path9, import_promises3, import_node_crypto5;
 var init_json_files_DMrq2IfK = __esm(() => {
-  import_node_path10 = __toESM(require("node:path"));
+  import_node_path9 = __toESM(require("node:path"));
   import_promises3 = __toESM(require("node:fs/promises"));
   import_node_crypto5 = require("node:crypto");
 });
@@ -3014,7 +3014,7 @@ function normalize(value) {
 }
 function resolveEffectiveHomeDir(env = process.env, homedir3 = import_node_os4.default.homedir) {
   const raw = resolveRawHomeDir(env, homedir3);
-  return raw ? import_node_path11.default.resolve(raw) : undefined;
+  return raw ? import_node_path10.default.resolve(raw) : undefined;
 }
 function resolveRawHomeDir(env, homedir3) {
   const explicitHome = normalize(env.OPENCLAW_HOME);
@@ -3046,7 +3046,7 @@ function normalizeSafe(homedir3) {
   }
 }
 function resolveRequiredHomeDir(env = process.env, homedir3 = import_node_os4.default.homedir) {
-  return resolveEffectiveHomeDir(env, homedir3) ?? import_node_path11.default.resolve(process.cwd());
+  return resolveEffectiveHomeDir(env, homedir3) ?? import_node_path10.default.resolve(process.cwd());
 }
 function expandHomePrefix(input, opts) {
   if (!input.startsWith("~"))
@@ -3066,13 +3066,13 @@ function resolveHomeRelativePath(input, opts) {
       env: opts?.env,
       homedir: opts?.homedir
     });
-    return import_node_path11.default.resolve(expanded);
+    return import_node_path10.default.resolve(expanded);
   }
-  return import_node_path11.default.resolve(trimmed);
+  return import_node_path10.default.resolve(trimmed);
 }
-var import_node_path11, import_node_os4;
+var import_node_path10, import_node_os4;
 var init_home_dir_BnP38vVl = __esm(() => {
-  import_node_path11 = __toESM(require("node:path"));
+  import_node_path10 = __toESM(require("node:path"));
   import_node_os4 = __toESM(require("node:os"));
 });
 
@@ -3087,10 +3087,10 @@ function envHomedir(env) {
   return () => resolveRequiredHomeDir(env, import_node_os5.default.homedir);
 }
 function legacyStateDirs(homedir3 = resolveDefaultHomeDir) {
-  return LEGACY_STATE_DIRNAMES.map((dir) => import_node_path12.default.join(homedir3(), dir));
+  return LEGACY_STATE_DIRNAMES.map((dir) => import_node_path11.default.join(homedir3(), dir));
 }
 function newStateDir(homedir3 = resolveDefaultHomeDir) {
-  return import_node_path12.default.join(homedir3(), NEW_STATE_DIRNAME);
+  return import_node_path11.default.join(homedir3(), NEW_STATE_DIRNAME);
 }
 function resolveStateDir2(env = process.env, homedir3 = envHomedir(env)) {
   const effectiveHomedir = () => resolveRequiredHomeDir(env, homedir3);
@@ -3101,11 +3101,11 @@ function resolveStateDir2(env = process.env, homedir3 = envHomedir(env)) {
   if (env.OPENCLAW_TEST_FAST === "1")
     return newDir;
   const legacyDirs = legacyStateDirs(effectiveHomedir);
-  if (import_node_fs14.default.existsSync(newDir))
+  if (import_node_fs15.default.existsSync(newDir))
     return newDir;
   const existingLegacy = legacyDirs.find((dir) => {
     try {
-      return import_node_fs14.default.existsSync(dir);
+      return import_node_fs15.default.existsSync(dir);
     } catch {
       return false;
     }
@@ -3124,14 +3124,14 @@ function resolveCanonicalConfigPath(env = process.env, stateDir = resolveStateDi
   const override = env.OPENCLAW_CONFIG_PATH?.trim();
   if (override)
     return resolveUserPath(override, env, envHomedir(env));
-  return import_node_path12.default.join(stateDir, CONFIG_FILENAME);
+  return import_node_path11.default.join(stateDir, CONFIG_FILENAME);
 }
 function resolveConfigPathCandidate(env = process.env, homedir3 = envHomedir(env)) {
   if (env.OPENCLAW_TEST_FAST === "1")
     return resolveCanonicalConfigPath(env, resolveStateDir2(env, homedir3));
   const existing = resolveDefaultConfigCandidates(env, homedir3).find((candidate) => {
     try {
-      return import_node_fs14.default.existsSync(candidate);
+      return import_node_fs15.default.existsSync(candidate);
     } catch {
       return false;
     }
@@ -3149,21 +3149,21 @@ function resolveDefaultConfigCandidates(env = process.env, homedir3 = envHomedir
   const openclawStateDir = env.OPENCLAW_STATE_DIR?.trim();
   if (openclawStateDir) {
     const resolved = resolveUserPath(openclawStateDir, env, effectiveHomedir);
-    candidates.push(import_node_path12.default.join(resolved, CONFIG_FILENAME));
-    candidates.push(...LEGACY_CONFIG_FILENAMES.map((name) => import_node_path12.default.join(resolved, name)));
+    candidates.push(import_node_path11.default.join(resolved, CONFIG_FILENAME));
+    candidates.push(...LEGACY_CONFIG_FILENAMES.map((name) => import_node_path11.default.join(resolved, name)));
   }
   const defaultDirs = [newStateDir(effectiveHomedir), ...legacyStateDirs(effectiveHomedir)];
   for (const dir of defaultDirs) {
-    candidates.push(import_node_path12.default.join(dir, CONFIG_FILENAME));
-    candidates.push(...LEGACY_CONFIG_FILENAMES.map((name) => import_node_path12.default.join(dir, name)));
+    candidates.push(import_node_path11.default.join(dir, CONFIG_FILENAME));
+    candidates.push(...LEGACY_CONFIG_FILENAMES.map((name) => import_node_path11.default.join(dir, name)));
   }
   return candidates;
 }
-var import_node_fs14, import_node_path12, import_node_os5, isNixMode, LEGACY_STATE_DIRNAMES, NEW_STATE_DIRNAME = ".openclaw", CONFIG_FILENAME = "openclaw.json", LEGACY_CONFIG_FILENAMES, STATE_DIR, CONFIG_PATH;
+var import_node_fs15, import_node_path11, import_node_os5, isNixMode, LEGACY_STATE_DIRNAMES, NEW_STATE_DIRNAME = ".openclaw", CONFIG_FILENAME = "openclaw.json", LEGACY_CONFIG_FILENAMES, STATE_DIR, CONFIG_PATH;
 var init_paths_Y4UT24Of = __esm(() => {
   init_home_dir_BnP38vVl();
-  import_node_fs14 = __toESM(require("node:fs"));
-  import_node_path12 = __toESM(require("node:path"));
+  import_node_fs15 = __toESM(require("node:fs"));
+  import_node_path11 = __toESM(require("node:path"));
   import_node_os5 = __toESM(require("node:os"));
   isNixMode = resolveIsNixMode();
   LEGACY_STATE_DIRNAMES = [".clawdbot", ".moldbot"];
@@ -3215,11 +3215,11 @@ function resolveMissingRequestedScope(params) {
 }
 function resolvePairingPaths(baseDir, subdir) {
   const root = baseDir ?? resolveStateDir2();
-  const dir = import_node_path13.default.join(root, subdir);
+  const dir = import_node_path12.default.join(root, subdir);
   return {
     dir,
-    pendingPath: import_node_path13.default.join(dir, "pending.json"),
-    pairedPath: import_node_path13.default.join(dir, "paired.json")
+    pendingPath: import_node_path12.default.join(dir, "pending.json"),
+    pairedPath: import_node_path12.default.join(dir, "paired.json")
   };
 }
 function pruneExpiredPending(pendingById, nowMs, ttlMs) {
@@ -3241,10 +3241,10 @@ function verifyPairingToken(provided, expected) {
     return false;
   return safeEqualSecret(provided, expected);
 }
-var import_node_path13, import_node_crypto6, OPERATOR_ROLE = "operator", OPERATOR_ADMIN_SCOPE = "operator.admin", OPERATOR_READ_SCOPE = "operator.read", OPERATOR_WRITE_SCOPE = "operator.write", OPERATOR_SCOPE_PREFIX = "operator.";
+var import_node_path12, import_node_crypto6, OPERATOR_ROLE = "operator", OPERATOR_ADMIN_SCOPE = "operator.admin", OPERATOR_READ_SCOPE = "operator.read", OPERATOR_WRITE_SCOPE = "operator.write", OPERATOR_SCOPE_PREFIX = "operator.";
 var init_pairing_token_C5g4QivV = __esm(() => {
   init_paths_Y4UT24Of();
-  import_node_path13 = __toESM(require("node:path"));
+  import_node_path12 = __toESM(require("node:path"));
   import_node_crypto6 = require("node:crypto");
 });
 
@@ -3454,7 +3454,7 @@ function sameDeviceBootstrapProfile(left, right) {
   return left.roles.length === right.roles.length && left.scopes.length === right.scopes.length && left.roles.every((value, index) => value === right.roles[index]) && left.scopes.every((value, index) => value === right.scopes[index]);
 }
 function resolveBootstrapPath(baseDir) {
-  return import_node_path14.default.join(resolvePairingPaths(baseDir, "devices").dir, "bootstrap.json");
+  return import_node_path13.default.join(resolvePairingPaths(baseDir, "devices").dir, "bootstrap.json");
 }
 function resolvePersistedBootstrapProfile(record) {
   return normalizeDeviceBootstrapProfile(record.profile ?? record);
@@ -3536,12 +3536,12 @@ async function revokeDeviceBootstrapToken(params) {
     return { removed: true };
   });
 }
-var import_node_path14, PAIRING_SETUP_BOOTSTRAP_PROFILE, DEVICE_BOOTSTRAP_TOKEN_TTL_MS, withLock2;
+var import_node_path13, PAIRING_SETUP_BOOTSTRAP_PROFILE, DEVICE_BOOTSTRAP_TOKEN_TTL_MS, withLock2;
 var init_device_bootstrap_DKsEcfsd = __esm(() => {
   init_json_files_DMrq2IfK();
   init_pairing_token_C5g4QivV();
   init_device_auth_BRUxebMD();
-  import_node_path14 = __toESM(require("node:path"));
+  import_node_path13 = __toESM(require("node:path"));
   PAIRING_SETUP_BOOTSTRAP_PROFILE = {
     roles: ["node"],
     scopes: []
@@ -3806,16 +3806,17 @@ var COMMAND_TREE = [
     subcommands: [
       {
         name: "send",
-        summary: "发送灯效指令到硬件（--segments / --preset）",
+        summary: "发送灯效指令到硬件（--segments / --preset / --rule 三选一）",
         options: [
-          { flags: "--segments <json>", summary: "灯效参数 JSON" },
-          { flags: "--preset <name>", summary: "预设名，如 red-blink" },
-          { flags: "--repeat", summary: "无限循环播放" },
-          { flags: "--repeat-times <n>", summary: "整条组合重复次数（0=无限）" }
+          { flags: "--segments <json>", summary: "灯效参数 JSON（原始段）" },
+          { flags: "--preset <name>", summary: "内置预设 id（如 red-steady / red-strobe-3）" },
+          { flags: "--rule <name>", summary: "已保存的 lightrule 名" },
+          { flags: "--repeat", summary: "无限循环播放（覆盖来源默认值）" },
+          { flags: "--repeat-times <n>", summary: "整条组合重复次数（0=无限，覆盖来源默认值）" }
         ]
       }
     ],
-    shortcuts: [{ name: "+blink", summary: "灯效连通性测试" }]
+    shortcuts: [{ name: "+blink", summary: "灯效连通性测试（red-strobe-3）" }]
   },
   {
     name: "lightrule",
@@ -3959,11 +3960,13 @@ var COMMAND_TREE = [
     summary: "Agent 技能管理：把随包发布的 SKILL.md 装到 agent 可发现目录 \uD83D\uDFE2",
     subcommands: [
       { name: "list", summary: "列出随 CLI 发布的内置 Skill 及其触发说明" },
+      { name: "targets", summary: "列出支持的 Agent skills 目录与自动探测结果" },
       {
         name: "install",
-        summary: "把内置 Skill 安装到 agent skills 目录（默认 ~/.claude/skills，软链）",
+        summary: "把内置 Skill 安装到 agent skills 目录（默认自动探测，软链）",
         options: [
-          { flags: "--target <dir>", summary: "安装目标目录", default: "~/.claude/skills" },
+          { flags: "--agent <agent>", summary: "安装目标 agent：auto|claude|codex|custom", default: "auto" },
+          { flags: "--target <dir>", summary: "安装目标目录；传入后优先于自动探测" },
           { flags: "--copy", summary: "复制而非软链（升级后不随包自动更新）" },
           { flags: "--force", summary: "目标已存在同名 Skill 时覆盖" }
         ]
@@ -4191,7 +4194,7 @@ function buildContext(flags) {
 var import_node_fs3 = require("node:fs");
 function readBuildInjectedVersion() {
   if (false) {}
-  const version = "0.0.3".trim();
+  const version = "0.0.4".trim();
   return version || undefined;
 }
 function readVersionFromPackageJson() {
@@ -5010,7 +5013,7 @@ async function authCheck(ctx) {
 }
 
 // src/notification/query.ts
-var import_node_fs15 = require("node:fs");
+var import_node_fs16 = require("node:fs");
 
 // ../phone-notifications/src/cli/helpers.ts
 var import_node_fs8 = require("node:fs");
@@ -6735,9 +6738,655 @@ function registerLightRulesGateway(api, registry, logger, rememberBroadcast) {
     }
   });
 }
-// ../phone-notifications/src/tunnel/relay-client.ts
+// ../phone-notifications/src/light/sender.ts
+var import_node_crypto4 = require("node:crypto");
+
+// ../phone-notifications/src/light/protocol.ts
+var MAX_LIGHT_SEGMENTS = 12;
+var PROTOCOL_DIGITS = [
+  "€",
+  "",
+  "‚",
+  "ƒ",
+  "„",
+  "‘",
+  "’",
+  "“",
+  "”",
+  "•",
+  "–",
+  "—"
+];
+var LED_SEPARATOR_ONCE = "š";
+var LED_SEPARATOR_LOOP = "›";
+var DURATION_STEPS_S = [0.5, 1, 2, 3, 5, 6, 8, 16, 24, 32, 48];
+var INTERVAL_STEPS_MS = [50, 100, 200, 300, 500, 600, 800, 1600, 2400, 3200, 4800];
+var BREATH_STEPS_MS = [1040, 1560, 2080, 2600, 3100, 4160];
+var BRIGHTNESS_STEPS = [32, 64, 96, 128, 192, 255];
+var COLOR_STEPS = [0, 32, 64, 128, 192, 255];
+var BACKGROUND_BRIGHTNESS_STEPS = [0, 32, 64, 96, 128, 192, 255];
+var MULTI_CHANNEL_COLOR_COEFFICIENTS = { r: 1, g: 0.25, b: 0.25 };
+var PURE_WHITE_COLOR_COEFFICIENTS = { r: 1, g: 0.35, b: 0.35 };
+var MODE_TO_INDEX = {
+  wave: 0,
+  breath: 1,
+  strobe: 2,
+  steady: 3,
+  color_flow: 4,
+  pixel_frame: 5
+};
+function buildLightEffectApnsBody(segments, repeatInput, visibleTextOverride) {
+  assertSegmentCount(segments);
+  assertSegmentsValid(segments);
+  const repeatTimes = normalizeRepeatTimes(repeatInput);
+  assertAncsRepeatTimes(repeatTimes);
+  const visibleText = resolveVisibleText(visibleTextOverride, segments);
+  const separator = repeatTimes === 0 ? LED_SEPARATOR_LOOP : LED_SEPARATOR_ONCE;
+  const payload = segments.map((segment) => encodeSegment(segment)).join("");
+  return `${visibleText}${separator}${payload}`;
+}
+function resolveVisibleText(override, segments) {
+  const trimmed = override?.trim();
+  if (trimmed)
+    return trimmed;
+  return summarizeSegments(segments);
+}
+function assertSegmentCount(segments) {
+  if (segments.length < 1 || segments.length > MAX_LIGHT_SEGMENTS) {
+    throw new Error(`light_control supports 1-${MAX_LIGHT_SEGMENTS} segments`);
+  }
+}
+function summarizeSegments(segments) {
+  const modeDesc = segments.map((segment) => segment.mode).join("+");
+  return `Effect: ${modeDesc} (${segments.length} segment${segments.length > 1 ? "s" : ""})`;
+}
+function assertSegmentsValid(segments) {
+  const validation = validateSegments(segments);
+  if (!validation.valid) {
+    throw new Error(validation.errors.map((error) => `${error.field}: ${error.message}`).join("; "));
+  }
+}
+function encodeSegment(segment) {
+  const common = [
+    MODE_TO_INDEX[segment.mode],
+    quantizeDuration(segment.duration_s)
+  ];
+  let values;
+  switch (segment.mode) {
+    case "wave":
+    case "color_flow":
+      const color = normalizeProtocolColor(segment.color);
+      const background = normalizeProtocolColor(segment.background);
+      values = [
+        ...common,
+        quantize(segment.interval_ms ?? 200, INTERVAL_STEPS_MS),
+        quantizeBrightnessValue(segment.brightness ?? 0),
+        quantize(color.r, COLOR_STEPS),
+        quantize(color.g, COLOR_STEPS),
+        quantize(color.b, COLOR_STEPS),
+        segment.direction === "rtl" ? 1 : 0,
+        quantizeWindow(segment.window ?? 2),
+        quantize(background.r, COLOR_STEPS),
+        quantize(background.g, COLOR_STEPS),
+        quantize(background.b, COLOR_STEPS),
+        quantize(segment.background?.brightness ?? 0, BACKGROUND_BRIGHTNESS_STEPS)
+      ];
+      break;
+    case "breath":
+      const breathColor = normalizeProtocolColor(segment.color);
+      values = [
+        ...common,
+        quantizeBreathRiseFall(segment.breath_timing?.rise_ms),
+        quantizeBreathHoldOff(segment.breath_timing?.hold_ms),
+        quantizeBreathRiseFall(segment.breath_timing?.fall_ms),
+        quantizeBreathHoldOff(segment.breath_timing?.off_ms),
+        quantizeBrightnessValue(segment.brightness ?? 0),
+        quantize(breathColor.r, COLOR_STEPS),
+        quantize(breathColor.g, COLOR_STEPS),
+        quantize(breathColor.b, COLOR_STEPS)
+      ];
+      break;
+    case "strobe":
+      const strobeColor = normalizeProtocolColor(segment.color);
+      values = [
+        ...common,
+        quantize(segment.interval_ms ?? 200, INTERVAL_STEPS_MS),
+        quantizeBrightnessValue(segment.brightness ?? 0),
+        quantize(strobeColor.r, COLOR_STEPS),
+        quantize(strobeColor.g, COLOR_STEPS),
+        quantize(strobeColor.b, COLOR_STEPS)
+      ];
+      break;
+    case "steady":
+      const steadyColor = normalizeProtocolColor(segment.color);
+      values = [
+        ...common,
+        quantizeBrightnessValue(segment.brightness ?? 0),
+        quantize(steadyColor.r, COLOR_STEPS),
+        quantize(steadyColor.g, COLOR_STEPS),
+        quantize(steadyColor.b, COLOR_STEPS)
+      ];
+      break;
+    case "pixel_frame":
+      values = encodePixelFrameValues(common, segment);
+      break;
+  }
+  return values.map((value) => PROTOCOL_DIGITS[value]).join("");
+}
+function encodePixelFrameValues(common, segment) {
+  const pixels = segment.pixels ?? [];
+  return [
+    ...common,
+    pixels.length - 1,
+    ...pixels.flatMap((pixel) => {
+      const color = normalizeProtocolColor(pixel.color);
+      return [
+        pixel.index,
+        quantize(color.r, COLOR_STEPS),
+        quantize(color.g, COLOR_STEPS),
+        quantize(color.b, COLOR_STEPS),
+        quantizeBrightnessValue(pixel.brightness)
+      ];
+    })
+  ];
+}
+function normalizeProtocolColor(color) {
+  const normalized = {
+    r: color?.r ?? 0,
+    g: color?.g ?? 0,
+    b: color?.b ?? 0
+  };
+  if (isPureWhiteProtocolColor(normalized)) {
+    return applyProtocolColorCoefficients(normalized, PURE_WHITE_COLOR_COEFFICIENTS);
+  }
+  if (countActiveProtocolColorChannels(normalized) <= 1) {
+    return normalized;
+  }
+  return applyProtocolColorCoefficients(normalized, MULTI_CHANNEL_COLOR_COEFFICIENTS);
+}
+function countActiveProtocolColorChannels(color) {
+  return Number(color.r > 0) + Number(color.g > 0) + Number(color.b > 0);
+}
+function isPureWhiteProtocolColor(color) {
+  return color.r === 255 && color.g === 255 && color.b === 255;
+}
+function applyProtocolColorCoefficients(color, coefficients) {
+  return {
+    r: scaleProtocolColorChannel(color.r, coefficients.r),
+    g: scaleProtocolColorChannel(color.g, coefficients.g),
+    b: scaleProtocolColorChannel(color.b, coefficients.b)
+  };
+}
+function scaleProtocolColorChannel(value, coefficient) {
+  return Math.max(0, Math.min(255, Math.round(value * coefficient)));
+}
+function quantize(value, steps) {
+  let bestIndex = 0;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const [index, step] of steps.entries()) {
+    const distance = Math.abs(value - step);
+    if (distance < bestDistance) {
+      bestIndex = index;
+      bestDistance = distance;
+    }
+  }
+  return bestIndex;
+}
+function quantizeDuration(duration_s) {
+  if (duration_s === 0)
+    return 11;
+  return quantize(duration_s, DURATION_STEPS_S);
+}
+function quantizeBrightnessValue(brightness) {
+  if (brightness === 0)
+    return 11;
+  return quantize(brightness, BRIGHTNESS_STEPS);
+}
+function quantizeBreathRiseFall(value) {
+  return quantize(value ?? 1040, BREATH_STEPS_MS);
+}
+function quantizeBreathHoldOff(value) {
+  if (value === 0) {
+    return 5;
+  }
+  return quantize(value ?? 1040, BREATH_STEPS_MS.slice(0, 5));
+}
+function quantizeWindow(value) {
+  return value - 1;
+}
+
+// ../phone-notifications/src/env.ts
+var import_node_fs13 = require("node:fs");
+
+// ../phone-notifications/src/auth/credentials.ts
+var import_node_fs12 = require("node:fs");
+
+// ../phone-notifications/src/profile/paths.ts
 var import_node_fs11 = require("node:fs");
 var import_node_path7 = require("node:path");
+var DEFAULT_JVSCLAW_STATE_DIR = "/home/admin/.openclaw";
+function trimToUndefined(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+function homeDir() {
+  return process.env.HOME || process.env.USERPROFILE || "/tmp";
+}
+function expandUserPath(value) {
+  if (!value) {
+    return;
+  }
+  if (value === "~") {
+    return homeDir();
+  }
+  if (value.startsWith("~/")) {
+    return import_node_path7.join(homeDir(), value.slice(2));
+  }
+  return value;
+}
+function candidateMetaPaths() {
+  const home = homeDir();
+  return [
+    import_node_path7.join(home, ".qclaw", "qclaw.json"),
+    import_node_path7.join(home, ".qclow", "qclaw.json")
+  ];
+}
+function loadQClawMeta() {
+  for (const metaPath of candidateMetaPaths()) {
+    if (!import_node_fs11.existsSync(metaPath)) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(import_node_fs11.readFileSync(metaPath, "utf-8"));
+      return {
+        stateDir: expandUserPath(trimToUndefined(parsed?.stateDir)),
+        configPath: expandUserPath(trimToUndefined(parsed?.configPath))
+      };
+    } catch {}
+  }
+  return;
+}
+function resolveStateDirFromEnv() {
+  return expandUserPath(trimToUndefined(process.env.JVSCLAW_STATE_DIR) ?? trimToUndefined(process.env.JVSCLAW_HOME) ?? trimToUndefined(process.env.OPENCLAW_STATE_DIR) ?? trimToUndefined(process.env.QCLAW_STATE_DIR) ?? trimToUndefined(process.env.OPENCLAW_ROOT) ?? trimToUndefined(process.env.OPENCLAW_HOME) ?? trimToUndefined(process.env.QCLAW_HOME));
+}
+function hasJvsclawProfileEnv() {
+  return trimToUndefined(process.env.CLAW_PROFILE)?.toLowerCase() === "jvsclaw";
+}
+function hasPersistedJvsclawProfile() {
+  try {
+    const content = import_node_fs11.readFileSync(import_node_path7.join(DEFAULT_JVSCLAW_STATE_DIR, ".env"), "utf-8");
+    return content.split(`
+`).some((line) => line.trim().toLowerCase() === "claw_profile=jvsclaw");
+  } catch {
+    return false;
+  }
+}
+function hasOpenClawMarkers() {
+  const baseDir = import_node_path7.join(homeDir(), ".openclaw");
+  return [
+    import_node_path7.join(baseDir, "openclaw.json"),
+    import_node_path7.join(baseDir, "credentials.json"),
+    import_node_path7.join(baseDir, "extensions")
+  ].some((candidate) => import_node_fs11.existsSync(candidate));
+}
+function resolveStateDir() {
+  const envDir = resolveStateDirFromEnv();
+  if (envDir) {
+    return envDir;
+  }
+  if (hasJvsclawProfileEnv() || hasPersistedJvsclawProfile()) {
+    return DEFAULT_JVSCLAW_STATE_DIR;
+  }
+  if (hasOpenClawMarkers()) {
+    return import_node_path7.join(homeDir(), ".openclaw");
+  }
+  const meta = loadQClawMeta();
+  if (meta?.stateDir) {
+    return meta.stateDir;
+  }
+  if (meta?.configPath) {
+    return import_node_path7.dirname(meta.configPath);
+  }
+  return import_node_path7.join(homeDir(), ".openclaw");
+}
+function resolveStateFile(filename) {
+  return import_node_path7.join(resolveStateDir(), filename);
+}
+
+// ../phone-notifications/src/profile/detect.ts
+var VALID_CLAW_KINDS = new Set([
+  "openclaw",
+  "arkclaw",
+  "jvsclaw"
+]);
+// ../phone-notifications/src/auth/credentials.ts
+function credentialsPath() {
+  return resolveStateFile("credentials.json");
+}
+function readCredentials() {
+  const path = credentialsPath();
+  if (!import_node_fs12.existsSync(path))
+    return {};
+  try {
+    return JSON.parse(import_node_fs12.readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+// ../phone-notifications/src/env.ts
+function getEnvHost(env) {
+  switch (env) {
+    case "development":
+      return "openclaw-service-dev.yoooclaw.com";
+    case "test":
+      return "openclaw-service-test.yoooclaw.com";
+    case "production":
+      return "openclaw-service.yoooclaw.com";
+  }
+}
+function buildEnvUrls(host) {
+  const https = `https://${host}`;
+  const wss = `wss://${host}`;
+  return {
+    lightApiUrl: `${https}/api/message/tob/sendMessage`,
+    relayTunnelUrl: `${wss}/message/messages/ws/plugin`,
+    appNameMapUrl: `${https}/api/application-config/app-package/config-all`,
+    modelProxyLongRecordingSubmitTaskUrl: `${https}/api/model-proxy/long-recording/submit-task`,
+    modelProxyLongRecordingQueryTaskResultBaseUrl: `${https}/api/model-proxy/long-recording/query-task-result`,
+    accountFileDeleteUrl: `${https}/api/account/file/delete`,
+    gatewayConnectStatusUrl: `${https}/api/message/messageBridge/plugin/gateway-connect-status`,
+    clawManagerInstanceReadyUrl: `${https}/claw-manager/internal/claw-manager/instance/ready`
+  };
+}
+var VALID_ENVS = new Set([
+  "development",
+  "test",
+  "production"
+]);
+function readDotEnv() {
+  const path = resolveStateFile(".env");
+  if (!import_node_fs13.existsSync(path))
+    return {};
+  return Object.fromEntries(import_node_fs13.readFileSync(path, "utf-8").split(`
+`).flatMap((line) => {
+    const eq = line.indexOf("=");
+    if (eq < 1)
+      return [];
+    return [[line.slice(0, eq).trim(), line.slice(eq + 1).trim()]];
+  }));
+}
+function readPersistedEnvName() {
+  const fromDotEnv = readDotEnv()["PHONE_NOTIFICATIONS_ENV"]?.trim();
+  if (fromDotEnv && VALID_ENVS.has(fromDotEnv))
+    return fromDotEnv;
+  return;
+}
+function loadEnvName() {
+  const fromEnvVar = process.env.PHONE_NOTIFICATIONS_ENV?.trim();
+  if (fromEnvVar && VALID_ENVS.has(fromEnvVar))
+    return fromEnvVar;
+  const fromDotEnv = readPersistedEnvName();
+  if (fromDotEnv)
+    return fromDotEnv;
+  const { env } = readCredentials();
+  if (env && VALID_ENVS.has(env))
+    return env;
+  return "production";
+}
+function getEnvUrls(env) {
+  return buildEnvUrls(getEnvHost(env ?? loadEnvName()));
+}
+
+// ../phone-notifications/src/light/sender.ts
+async function sendLightEffect(apiKey, segments, logger, repeatInput, reason, title) {
+  const apiUrl = getEnvUrls().lightApiUrl;
+  const appKey = process.env.LIGHT_APP_KEY;
+  const templateId = process.env.LIGHT_TEMPLATE_ID;
+  const resolvedTitle = resolveLightTitle(title, reason, segments);
+  logger?.info(`Light sender: apiUrl=${apiUrl ?? "UNSET"}, appKey=${appKey ? appKey.substring(0, 8) + "…" : "UNSET"}, templateId=${templateId ?? "UNSET"}, apiKey=${apiKey ? apiKey.substring(0, 20) + "…" : "EMPTY"}, title=${resolvedTitle}, reason=${reason ?? ""}, segments=${JSON.stringify(segments)}`);
+  if (!apiUrl || !appKey || !templateId) {
+    return {
+      ok: false,
+      error: "灯效 API 未配置，请设置环境变量 LIGHT_API_URL / LIGHT_APP_KEY / LIGHT_TEMPLATE_ID"
+    };
+  }
+  let bizContent;
+  try {
+    bizContent = buildLightEffectApnsBody(segments, repeatInput, reason);
+  } catch (error) {
+    return { ok: false, error: error?.message ?? String(error) };
+  }
+  const bizUniqueId = import_node_crypto4.randomUUID();
+  const requestBody = {
+    appKey,
+    bizMap: { noticeType: "APP_NOTIFICATION_IMPORTANT", title: resolvedTitle, reason },
+    bizUniqueId,
+    paramsMap: { bizContent },
+    pushType: "SPECIFY_PUSH",
+    templateId
+  };
+  logger?.info(`Light sender: POST ${apiUrl}, bizUniqueId=${bizUniqueId}, body=${JSON.stringify(requestBody).substring(0, 500)}`);
+  const res = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Api-Key-Id": apiKey.startsWith("Bearer ") ? apiKey.slice("Bearer ".length) : apiKey
+    },
+    body: JSON.stringify(requestBody)
+  });
+  const resBody = await res.text();
+  if (!res.ok) {
+    logger?.warn(`Light sender: FAILED ${res.status}, url=${apiUrl}, resBody=${resBody.substring(0, 500)}`);
+    return { ok: false, status: res.status, error: resBody };
+  }
+  logger?.info(`Light sender: OK bizUniqueId=${bizUniqueId}, resBody=${resBody.substring(0, 200)}`);
+  return { ok: true, bizUniqueId, response: JSON.parse(resBody) };
+}
+function resolveLightTitle(title, reason, segments) {
+  const trimmedTitle = title?.trim();
+  if (trimmedTitle)
+    return trimmedTitle;
+  const trimmedReason = reason?.trim();
+  if (trimmedReason)
+    return trimmedReason;
+  const modeDesc = segments.map((segment) => segment.mode).join("+");
+  return `Effect: ${modeDesc || "custom"}`;
+}
+// ../phone-notifications/src/light/presets-v1.json
+var presets_v1_default = {
+  version: "v1",
+  presets: [
+    {
+      presetId: "red-steady",
+      displayName: "红色常亮",
+      description: "红灯持续亮起 5 秒",
+      repeat_times: 1,
+      segments: [
+        {
+          mode: "steady",
+          duration_s: 5,
+          brightness: 192,
+          color: {
+            r: 255,
+            g: 0,
+            b: 0
+          }
+        }
+      ],
+      base64: "RWZmZWN0OiBzdGVhZHkgKDEgc2VnbWVudCnCmsKDwoTChMKRwoDCgA=="
+    },
+    {
+      presetId: "red-breath",
+      displayName: "红色呼吸",
+      description: "红色缓慢呼吸约两轮",
+      repeat_times: 1,
+      segments: [
+        {
+          mode: "breath",
+          duration_s: 8,
+          brightness: 192,
+          color: {
+            r: 255,
+            g: 0,
+            b: 0
+          },
+          breath_timing: {
+            rise_ms: 2080,
+            hold_ms: 0,
+            fall_ms: 2080,
+            off_ms: 0
+          }
+        }
+      ],
+      base64: "RWZmZWN0OiBicmVhdGggKDEgc2VnbWVudCnCmsKBwpLCgsKRwoLCkcKEwpHCgMKA"
+    },
+    {
+      presetId: "red-strobe-3",
+      displayName: "红色三闪",
+      description: "红色短促频闪，体感接近三闪",
+      repeat_times: 1,
+      segments: [
+        {
+          mode: "strobe",
+          duration_s: 1,
+          interval_ms: 300,
+          brightness: 192,
+          color: {
+            r: 255,
+            g: 0,
+            b: 0
+          }
+        }
+      ],
+      base64: "RWZmZWN0OiBzdHJvYmUgKDEgc2VnbWVudCnCmsKCwoHCg8KEwpHCgMKA"
+    },
+    {
+      presetId: "green-steady",
+      displayName: "绿色常亮",
+      description: "绿灯持续亮起 5 秒",
+      repeat_times: 1,
+      segments: [
+        {
+          mode: "steady",
+          duration_s: 5,
+          brightness: 192,
+          color: {
+            r: 0,
+            g: 255,
+            b: 0
+          }
+        }
+      ],
+      base64: "RWZmZWN0OiBzdGVhZHkgKDEgc2VnbWVudCnCmsKDwoTChMKAwpHCgA=="
+    },
+    {
+      presetId: "green-breath",
+      displayName: "绿色呼吸",
+      description: "绿色缓慢呼吸约两轮",
+      repeat_times: 1,
+      segments: [
+        {
+          mode: "breath",
+          duration_s: 8,
+          brightness: 192,
+          color: {
+            r: 0,
+            g: 255,
+            b: 0
+          },
+          breath_timing: {
+            rise_ms: 2080,
+            hold_ms: 0,
+            fall_ms: 2080,
+            off_ms: 0
+          }
+        }
+      ],
+      base64: "RWZmZWN0OiBicmVhdGggKDEgc2VnbWVudCnCmsKBwpLCgsKRwoLCkcKEwoDCkcKA"
+    },
+    {
+      presetId: "blue-wave",
+      displayName: "蓝色波浪",
+      description: "蓝色从左到右流动一轮",
+      repeat_times: 1,
+      segments: [
+        {
+          mode: "wave",
+          duration_s: 5,
+          interval_ms: 200,
+          brightness: 192,
+          color: {
+            r: 0,
+            g: 0,
+            b: 255
+          },
+          direction: "ltr",
+          window: 2,
+          background: {
+            r: 0,
+            g: 0,
+            b: 0,
+            brightness: 0
+          }
+        }
+      ],
+      base64: "RWZmZWN0OiB3YXZlICgxIHNlZ21lbnQpwprCgMKEwoLChMKAwoDCkcKAwoHCgMKAwoDCgA=="
+    },
+    {
+      presetId: "blue-breath",
+      displayName: "蓝色呼吸",
+      description: "蓝色缓慢呼吸约两轮",
+      repeat_times: 1,
+      segments: [
+        {
+          mode: "breath",
+          duration_s: 8,
+          brightness: 192,
+          color: {
+            r: 0,
+            g: 0,
+            b: 255
+          },
+          breath_timing: {
+            rise_ms: 2080,
+            hold_ms: 0,
+            fall_ms: 2080,
+            off_ms: 0
+          }
+        }
+      ],
+      base64: "RWZmZWN0OiBicmVhdGggKDEgc2VnbWVudCnCmsKBwpLCgsKRwoLCkcKEwoDCgMKR"
+    },
+    {
+      presetId: "yellow-strobe-3",
+      displayName: "黄色三闪",
+      description: "黄色短促频闪，体感接近三闪",
+      repeat_times: 1,
+      segments: [
+        {
+          mode: "strobe",
+          duration_s: 1,
+          interval_ms: 300,
+          brightness: 192,
+          color: {
+            r: 255,
+            g: 255,
+            b: 0
+          }
+        }
+      ],
+      base64: "RWZmZWN0OiBzdHJvYmUgKDEgc2VnbWVudCnCmsKCwoHCg8KEwpHCgsKA"
+    }
+  ]
+};
+
+// ../phone-notifications/src/tunnel/relay-client.ts
+var import_node_fs14 = require("node:fs");
+var import_node_path8 = require("node:path");
 
 // ../../node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -6754,6 +7403,9 @@ var wrapper_default = import_websocket.default;
 function previewText2(text, max = 500) {
   return text.length <= max ? text : `${text.substring(0, max)}…`;
 }
+function maskableSecret(credential) {
+  return credential.query?.apiKey ?? Object.values(credential.headers ?? {})[0] ?? "";
+}
 var HANDSHAKE_TIMEOUT_MS = 15000;
 var CONNECT_WATCHDOG_MS = 20000;
 var SEND_SKIPPED_LOG_INTERVAL_MS = 30000;
@@ -6785,8 +7437,8 @@ class RelayClient {
       lastDisconnectReason
     };
     try {
-      import_node_fs11.mkdirSync(import_node_path7.dirname(this.opts.statusFilePath), { recursive: true });
-      import_node_fs11.writeFileSync(this.opts.statusFilePath, JSON.stringify(info, null, 2));
+      import_node_fs14.mkdirSync(import_node_path8.dirname(this.opts.statusFilePath), { recursive: true });
+      import_node_fs14.writeFileSync(this.opts.statusFilePath, JSON.stringify(info, null, 2));
     } catch {}
   }
   onInbound(handler) {
@@ -6910,8 +7562,17 @@ class RelayClient {
     if (this.aborted)
       return;
     this.cleanup(true);
-    const rawApiKey = this.opts.apiKey.startsWith("Bearer ") ? this.opts.apiKey.slice("Bearer ".length) : this.opts.apiKey;
-    this.opts.logger.info(`Relay tunnel: connecting to ${redactUrlSecrets(this.opts.tunnelUrl)} (attempt=${this.reconnectAttempt}, heartbeat=${this.opts.heartbeatSec}s, apiKey=${maskSecret(rawApiKey)})`);
+    let credential;
+    try {
+      credential = await this.opts.credentialProvider();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.opts.logger.warn(`Relay tunnel: failed to resolve credential, scheduling reconnect: ${message}`);
+      this.writeStatus("disconnected", `credential-error: ${message}`);
+      this.scheduleReconnect();
+      return;
+    }
+    this.opts.logger.info(`Relay tunnel: connecting to ${redactUrlSecrets(this.opts.tunnelUrl)} (attempt=${this.reconnectAttempt}, heartbeat=${this.opts.heartbeatSec}s, apiKey=${maskSecret(maskableSecret(credential))})`);
     this.writeStatus("connecting");
     return new Promise((resolve) => {
       let settled = false;
@@ -6922,13 +7583,13 @@ class RelayClient {
         }
       };
       const wsUrl = new URL(this.opts.tunnelUrl);
-      if (!wsUrl.searchParams.get("apiKey")) {
-        wsUrl.searchParams.set("apiKey", rawApiKey);
+      for (const [key, value] of Object.entries(credential.query ?? {})) {
+        if (!wsUrl.searchParams.get(key)) {
+          wsUrl.searchParams.set(key, value);
+        }
       }
       const ws = new wrapper_default(wsUrl.toString(), {
-        headers: {
-          "X-Api-Key-Id": rawApiKey
-        },
+        headers: credential.headers ?? {},
         handshakeTimeout: HANDSHAKE_TIMEOUT_MS
       });
       this.ws = ws;
@@ -7167,92 +7828,16 @@ class RelayClient {
 // ../phone-notifications/src/tunnel/proxy.ts
 var import_node_crypto7 = require("node:crypto");
 
-// ../phone-notifications/src/host.ts
-var import_node_fs12 = require("node:fs");
-var import_node_path8 = require("node:path");
-function trimToUndefined(value) {
-  if (typeof value !== "string") {
-    return;
-  }
-  const trimmed = value.trim();
-  return trimmed || undefined;
-}
-function homeDir() {
-  return process.env.HOME || process.env.USERPROFILE || "/tmp";
-}
-function expandUserPath(value) {
-  if (!value) {
-    return;
-  }
-  if (value === "~") {
-    return homeDir();
-  }
-  if (value.startsWith("~/")) {
-    return import_node_path8.join(homeDir(), value.slice(2));
-  }
-  return value;
-}
-function candidateMetaPaths() {
-  const home = homeDir();
-  return [
-    import_node_path8.join(home, ".qclaw", "qclaw.json"),
-    import_node_path8.join(home, ".qclow", "qclaw.json")
-  ];
-}
-function loadQClawMeta() {
-  for (const metaPath of candidateMetaPaths()) {
-    if (!import_node_fs12.existsSync(metaPath)) {
-      continue;
-    }
-    try {
-      const parsed = JSON.parse(import_node_fs12.readFileSync(metaPath, "utf-8"));
-      return {
-        stateDir: expandUserPath(trimToUndefined(parsed?.stateDir)),
-        configPath: expandUserPath(trimToUndefined(parsed?.configPath))
-      };
-    } catch {}
-  }
-  return;
-}
-function resolveStateDirFromEnv() {
-  return expandUserPath(trimToUndefined(process.env.OPENCLAW_STATE_DIR) ?? trimToUndefined(process.env.QCLAW_STATE_DIR) ?? trimToUndefined(process.env.OPENCLAW_ROOT) ?? trimToUndefined(process.env.OPENCLAW_HOME) ?? trimToUndefined(process.env.QCLAW_HOME));
-}
-function hasOpenClawMarkers() {
-  const baseDir = import_node_path8.join(homeDir(), ".openclaw");
-  return [
-    import_node_path8.join(baseDir, "openclaw.json"),
-    import_node_path8.join(baseDir, "credentials.json"),
-    import_node_path8.join(baseDir, "extensions")
-  ].some((candidate) => import_node_fs12.existsSync(candidate));
-}
-function resolveStateDir() {
-  const envDir = resolveStateDirFromEnv();
-  if (envDir) {
-    return envDir;
-  }
-  if (hasOpenClawMarkers()) {
-    return import_node_path8.join(homeDir(), ".openclaw");
-  }
-  const meta = loadQClawMeta();
-  if (meta?.stateDir) {
-    return meta.stateDir;
-  }
-  if (meta?.configPath) {
-    return import_node_path8.dirname(meta.configPath);
-  }
-  return import_node_path8.join(homeDir(), ".openclaw");
-}
-
 // ../phone-notifications/src/tunnel/device-identity.ts
-var import_node_crypto4 = __toESM(require("node:crypto"));
-var import_node_fs13 = __toESM(require("node:fs"));
-var import_node_path9 = __toESM(require("node:path"));
+var crypto = __toESM(require("node:crypto"));
+var fs = __toESM(require("node:fs"));
+var path = __toESM(require("node:path"));
 var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
 function base64UrlEncode(buf) {
   return buf.toString("base64").replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/g, "");
 }
 function derivePublicKeyRaw(publicKeyPem) {
-  const spki = import_node_crypto4.default.createPublicKey(publicKeyPem).export({
+  const spki = crypto.createPublicKey(publicKeyPem).export({
     type: "spki",
     format: "der"
   });
@@ -7262,14 +7847,14 @@ function derivePublicKeyRaw(publicKeyPem) {
 }
 function fingerprintPublicKey(publicKeyPem) {
   const raw = derivePublicKeyRaw(publicKeyPem);
-  return import_node_crypto4.default.createHash("sha256").update(raw).digest("hex");
+  return crypto.createHash("sha256").update(raw).digest("hex");
 }
 function publicKeyRawBase64UrlFromPem(publicKeyPem) {
   return base64UrlEncode(derivePublicKeyRaw(publicKeyPem));
 }
 function signDevicePayload(privateKeyPem, payload) {
-  const key = import_node_crypto4.default.createPrivateKey(privateKeyPem);
-  return base64UrlEncode(import_node_crypto4.default.sign(null, Buffer.from(payload, "utf8"), key));
+  const key = crypto.createPrivateKey(privateKeyPem);
+  return base64UrlEncode(crypto.sign(null, Buffer.from(payload, "utf8"), key));
 }
 function buildDeviceAuthPayload(params) {
   const scopes = params.scopes.join(",");
@@ -7290,10 +7875,10 @@ function resolveClientStateDir(stateDir) {
   return stateDir ?? resolveStateDir();
 }
 function ensureDir2(filePath) {
-  import_node_fs13.default.mkdirSync(import_node_path9.default.dirname(filePath), { recursive: true });
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
 }
 function resolveIdentityPath(stateDir) {
-  return import_node_path9.default.join(stateDir, "identity", "device.json");
+  return path.join(stateDir, "identity", "device.json");
 }
 function normalizeDeviceAuthRole(role) {
   return role.trim();
@@ -7309,13 +7894,13 @@ function normalizeDeviceAuthScopes(scopes) {
   return [...out].sort();
 }
 function resolveDeviceAuthPath(stateDir) {
-  return import_node_path9.default.join(stateDir, "identity", "device-auth.json");
+  return path.join(stateDir, "identity", "device-auth.json");
 }
 function readDeviceAuthStore(filePath) {
   try {
-    if (!import_node_fs13.default.existsSync(filePath))
+    if (!fs.existsSync(filePath))
       return null;
-    const raw = import_node_fs13.default.readFileSync(filePath, "utf8");
+    const raw = fs.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed?.version !== 1 || typeof parsed.deviceId !== "string")
       return null;
@@ -7328,12 +7913,12 @@ function readDeviceAuthStore(filePath) {
 }
 function writeDeviceAuthStore(filePath, store) {
   ensureDir2(filePath);
-  import_node_fs13.default.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
+  fs.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
 `, {
     mode: 384
   });
   try {
-    import_node_fs13.default.chmodSync(filePath, 384);
+    fs.chmodSync(filePath, 384);
   } catch {}
 }
 function loadDeviceAuthToken(params) {
@@ -7383,8 +7968,8 @@ function clearDeviceAuthToken(params) {
 function loadOrCreateDeviceIdentity(stateDir) {
   const filePath = resolveIdentityPath(stateDir);
   try {
-    if (import_node_fs13.default.existsSync(filePath)) {
-      const raw = import_node_fs13.default.readFileSync(filePath, "utf8");
+    if (fs.existsSync(filePath)) {
+      const raw = fs.readFileSync(filePath, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed?.version === 1 && typeof parsed.deviceId === "string" && typeof parsed.publicKeyPem === "string" && typeof parsed.privateKeyPem === "string") {
         const derivedId = fingerprintPublicKey(parsed.publicKeyPem);
@@ -7396,7 +7981,7 @@ function loadOrCreateDeviceIdentity(stateDir) {
       }
     }
   } catch {}
-  const { publicKey, privateKey } = import_node_crypto4.default.generateKeyPairSync("ed25519");
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");
   const publicKeyPem = publicKey.export({ type: "spki", format: "pem" }).toString();
   const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
   const identity = {
@@ -7404,14 +7989,14 @@ function loadOrCreateDeviceIdentity(stateDir) {
     publicKeyPem,
     privateKeyPem
   };
-  import_node_fs13.default.mkdirSync(import_node_path9.default.dirname(filePath), { recursive: true });
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
   const stored = {
     version: 1,
     ...identity,
     createdAtMs: Date.now()
   };
   ensureDir2(filePath);
-  import_node_fs13.default.writeFileSync(filePath, `${JSON.stringify(stored, null, 2)}
+  fs.writeFileSync(filePath, `${JSON.stringify(stored, null, 2)}
 `, {
     mode: 384
   });
@@ -8212,6 +8797,10 @@ class TunnelProxy {
     ws.send(JSON.stringify(connectReq));
   }
 }
+
+// src/shared.ts
+var LIGHT_PRESETS_V1 = presets_v1_default;
+
 // src/notification/query.ts
 var ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(Z|[+-]\d{2}:\d{2})$/;
 function parseIso(value, name) {
@@ -8256,7 +8845,7 @@ function buildQueryOptions(opts, defaultLimit = 100) {
   };
 }
 async function queryNotifications(paths, options) {
-  if (!import_node_fs15.existsSync(paths.notifications))
+  if (!import_node_fs16.existsSync(paths.notifications))
     return [];
   return collectMatchingNotifications(paths.notifications, options);
 }
@@ -8350,26 +8939,26 @@ function notificationUnread() {
 }
 function tzOffset() {
   const min = -new Date().getTimezoneOffset();
-  const sign = min >= 0 ? "+" : "-";
+  const sign2 = min >= 0 ? "+" : "-";
   const abs = Math.abs(min);
   const hh = String(Math.floor(abs / 60)).padStart(2, "0");
   const mm = String(abs % 60).padStart(2, "0");
-  return `${sign}${hh}:${mm}`;
+  return `${sign2}${hh}:${mm}`;
 }
 
 // src/notification/sync.ts
-var import_node_fs16 = require("node:fs");
-var import_node_path15 = require("node:path");
+var import_node_fs17 = require("node:fs");
+var import_node_path14 = require("node:path");
 var SYNC_FETCH_LIMIT = 300;
 function checkpointPath(dir) {
-  return import_node_path15.join(dir, ".checkpoint.json");
+  return import_node_path14.join(dir, ".checkpoint.json");
 }
 function readCheckpoint(dir) {
   const p = checkpointPath(dir);
-  if (!import_node_fs16.existsSync(p))
+  if (!import_node_fs17.existsSync(p))
     return {};
   try {
-    return JSON.parse(import_node_fs16.readFileSync(p, "utf-8"));
+    return JSON.parse(import_node_fs17.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
@@ -8378,11 +8967,11 @@ function writeCheckpoint(dir, data) {
   writeJsonFile(checkpointPath(dir), data);
 }
 function listDateKeys(dir) {
-  if (!import_node_fs16.existsSync(dir))
+  if (!import_node_fs17.existsSync(dir))
     return [];
   const pattern = /^(\d{4}-\d{2}-\d{2})\.json$/;
   const keys = [];
-  for (const entry of import_node_fs16.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of import_node_fs17.readdirSync(dir, { withFileTypes: true })) {
     if (!entry.isFile())
       continue;
     const m = pattern.exec(entry.name);
@@ -8392,11 +8981,11 @@ function listDateKeys(dir) {
   return keys.sort((a, b) => b.localeCompare(a));
 }
 function readDateFile(dir, dateKey) {
-  const filePath = import_node_path15.join(dir, `${dateKey}.json`);
-  if (!import_node_fs16.existsSync(filePath))
+  const filePath = import_node_path14.join(dir, `${dateKey}.json`);
+  if (!import_node_fs17.existsSync(filePath))
     return [];
   try {
-    const parsed = JSON.parse(import_node_fs16.readFileSync(filePath, "utf-8"));
+    const parsed = JSON.parse(import_node_fs17.readFileSync(filePath, "utf-8"));
     return Array.isArray(parsed) ? parsed : [];
   } catch {
     return [];
@@ -8512,10 +9101,10 @@ function syncCommit(ctx, _args, opts) {
 }
 
 // src/commands/recording.ts
-var import_node_fs17 = require("node:fs");
-var import_node_path16 = require("node:path");
+var import_node_fs18 = require("node:fs");
+var import_node_path15 = require("node:path");
 function readIndex(ctx) {
-  if (!import_node_fs17.existsSync(ctx.paths.recordings))
+  if (!import_node_fs18.existsSync(ctx.paths.recordings))
     return [];
   return readRecordingIndex(ctx.paths.recordings);
 }
@@ -8594,30 +9183,30 @@ async function recordingSetupAsr(ctx, _args, opts) {
   if (apiKey)
     config.apiKey = apiKey;
   ensureDir(ctx.paths.recordings);
-  const path7 = import_node_path16.join(ctx.paths.recordings, "asr-config.json");
+  const path7 = import_node_path15.join(ctx.paths.recordings, "asr-config.json");
   writeJsonFile(path7, config);
   return { ok: true, path: path7, provider, keyConfigured: Boolean(apiKey) };
 }
 
 // src/image/storage.ts
-var import_node_fs18 = require("node:fs");
-var import_node_path17 = require("node:path");
+var import_node_fs19 = require("node:fs");
+var import_node_path16 = require("node:path");
 function imagesIndexPath(paths) {
-  return import_node_path17.join(paths.images, "index.json");
+  return import_node_path16.join(paths.images, "index.json");
 }
 function readImageIndex(paths) {
   const indexPath = imagesIndexPath(paths);
-  if (!import_node_fs18.existsSync(indexPath))
+  if (!import_node_fs19.existsSync(indexPath))
     return [];
   try {
-    const raw = JSON.parse(import_node_fs18.readFileSync(indexPath, "utf-8"));
+    const raw = JSON.parse(import_node_fs19.readFileSync(indexPath, "utf-8"));
     return Array.isArray(raw?.images) ? raw.images : [];
   } catch {
     return [];
   }
 }
 function resolveImageFile(paths, relative) {
-  return import_node_path17.isAbsolute(relative) ? relative : import_node_path17.join(paths.images, relative);
+  return import_node_path16.isAbsolute(relative) ? relative : import_node_path16.join(paths.images, relative);
 }
 
 // src/commands/image.ts
@@ -8671,17 +9260,17 @@ function imageLatest(ctx) {
 }
 
 // src/log/reader.ts
-var import_node_fs19 = require("node:fs");
-var import_node_path18 = require("node:path");
+var import_node_fs20 = require("node:fs");
+var import_node_path17 = require("node:path");
 var LINE_RE = /^(\d{4}-\d{2}-\d{2})(T\S+)?\s+\[(\w+)\]\s+(.*)$/;
 function logFiles(daemonLog) {
-  const dir = import_node_path18.dirname(daemonLog);
-  const base = import_node_path18.basename(daemonLog);
-  if (!import_node_fs19.existsSync(dir))
+  const dir = import_node_path17.dirname(daemonLog);
+  const base = import_node_path17.basename(daemonLog);
+  if (!import_node_fs20.existsSync(dir))
     return [];
-  const rotated = import_node_fs19.readdirSync(dir).filter((f) => f.startsWith(`${base}.`) && /\.\d{4}-\d{2}-\d{2}$/.test(f)).sort((a, b) => b.localeCompare(a)).map((f) => import_node_path18.join(dir, f));
+  const rotated = import_node_fs20.readdirSync(dir).filter((f) => f.startsWith(`${base}.`) && /\.\d{4}-\d{2}-\d{2}$/.test(f)).sort((a, b) => b.localeCompare(a)).map((f) => import_node_path17.join(dir, f));
   const files = [];
-  if (import_node_fs19.existsSync(daemonLog))
+  if (import_node_fs20.existsSync(daemonLog))
     files.push(daemonLog);
   files.push(...rotated);
   return files;
@@ -8703,7 +9292,7 @@ function searchLogs(daemonLog, query) {
   const level = query.level?.toLowerCase();
   const results = [];
   for (const file of logFiles(daemonLog)) {
-    const content = import_node_fs19.readFileSync(file, "utf-8");
+    const content = import_node_fs20.readFileSync(file, "utf-8");
     const lines = content.split(`
 `).filter(Boolean).reverse();
     for (const raw of lines) {
@@ -8748,34 +9337,34 @@ function logErrors(ctx) {
 }
 
 // src/commands/migrate.ts
-var import_node_fs20 = require("node:fs");
+var import_node_fs21 = require("node:fs");
 var import_node_os6 = require("node:os");
-var import_node_path19 = require("node:path");
+var import_node_path18 = require("node:path");
 function countFiles(dir) {
-  if (!import_node_fs20.existsSync(dir))
+  if (!import_node_fs21.existsSync(dir))
     return 0;
   try {
-    return import_node_fs20.readdirSync(dir, { recursive: true }).length;
+    return import_node_fs21.readdirSync(dir, { recursive: true }).length;
   } catch {
     return 0;
   }
 }
 function migrateFromOpenclaw(ctx, _args, opts) {
-  const sourceRoot = opts.source ?? import_node_path19.join(import_node_os6.homedir(), ".openclaw");
-  const pluginRoot = import_node_path19.join(sourceRoot, "plugins", "phone-notifications");
+  const sourceRoot = opts.source ?? import_node_path18.join(import_node_os6.homedir(), ".openclaw");
+  const pluginRoot = import_node_path18.join(sourceRoot, "plugins", "phone-notifications");
   const plans = [
-    { name: "notifications", source: import_node_path19.join(pluginRoot, "notifications"), target: ctx.paths.notifications },
-    { name: "recordings", source: import_node_path19.join(pluginRoot, "recordings"), target: ctx.paths.recordings },
-    { name: "light-rules", source: import_node_path19.join(pluginRoot, "light-rules"), target: ctx.paths.lightRules },
-    { name: "images", source: import_node_path19.join(pluginRoot, "images"), target: ctx.paths.images }
-  ].map((p) => ({ ...p, exists: import_node_fs20.existsSync(p.source), fileCount: countFiles(p.source) }));
-  const srcCreds = readJsonFile(import_node_path19.join(sourceRoot, "credentials.json"));
+    { name: "notifications", source: import_node_path18.join(pluginRoot, "notifications"), target: ctx.paths.notifications },
+    { name: "recordings", source: import_node_path18.join(pluginRoot, "recordings"), target: ctx.paths.recordings },
+    { name: "light-rules", source: import_node_path18.join(pluginRoot, "light-rules"), target: ctx.paths.lightRules },
+    { name: "images", source: import_node_path18.join(pluginRoot, "images"), target: ctx.paths.images }
+  ].map((p) => ({ ...p, exists: import_node_fs21.existsSync(p.source), fileCount: countFiles(p.source) }));
+  const srcCreds = readJsonFile(import_node_path18.join(sourceRoot, "credentials.json"));
   const srcApiKey = typeof srcCreds?.[API_KEY_FIELD] === "string" ? srcCreds[API_KEY_FIELD] : undefined;
   const sharedPath = sharedCredentialsPath();
   const existingShared = readJsonFile(sharedPath);
   const apiKeyAction = !srcApiKey ? "none" : existingShared?.[API_KEY_FIELD] ? "skip-existing" : "copy";
   const backupDir = `${ctx.paths.dir}.bak-${Date.now()}`;
-  const willBackup = import_node_fs20.existsSync(ctx.paths.dir) && import_node_fs20.readdirSync(ctx.paths.dir).length > 0;
+  const willBackup = import_node_fs21.existsSync(ctx.paths.dir) && import_node_fs21.readdirSync(ctx.paths.dir).length > 0;
   if (opts.dryRun) {
     return {
       ok: true,
@@ -8789,14 +9378,14 @@ function migrateFromOpenclaw(ctx, _args, opts) {
     };
   }
   if (willBackup) {
-    import_node_fs20.cpSync(ctx.paths.dir, backupDir, { recursive: true });
+    import_node_fs21.cpSync(ctx.paths.dir, backupDir, { recursive: true });
   }
   ensureDir(ctx.paths.dir);
   const migrated = [];
   for (const plan of plans) {
     if (!plan.exists)
       continue;
-    import_node_fs20.cpSync(plan.source, plan.target, { recursive: true });
+    import_node_fs21.cpSync(plan.source, plan.target, { recursive: true });
     migrated.push(plan.name);
   }
   let apiKeyResult = apiKeyAction;
@@ -8869,7 +9458,7 @@ async function updateSelf(_ctx, _args, opts) {
 }
 
 // src/commands/doctor.ts
-var import_node_fs21 = require("node:fs");
+var import_node_fs22 = require("node:fs");
 var MIN_NODE = [22, 12, 0];
 function checkNode() {
   const parts = process.versions.node.split(".").map(Number);
@@ -8889,7 +9478,7 @@ function checkNode() {
   };
 }
 function checkDir(name, dir, fix) {
-  if (!import_node_fs21.existsSync(dir)) {
+  if (!import_node_fs22.existsSync(dir)) {
     if (fix) {
       ensureDir(dir);
       return { name, status: "ok", detail: `已创建 ${dir}` };
@@ -8897,11 +9486,11 @@ function checkDir(name, dir, fix) {
     return { name, status: "warn", detail: `目录不存在：${dir}（--fix 可创建）` };
   }
   try {
-    import_node_fs21.accessSync(dir, import_node_fs21.constants.R_OK | import_node_fs21.constants.W_OK);
+    import_node_fs22.accessSync(dir, import_node_fs22.constants.R_OK | import_node_fs22.constants.W_OK);
   } catch {
     return { name, status: "fail", detail: `目录不可读写：${dir}` };
   }
-  const mode = import_node_fs21.statSync(dir).mode & 511;
+  const mode = import_node_fs22.statSync(dir).mode & 511;
   const tooOpen = (mode & 63) !== 0;
   return {
     name,
@@ -8963,47 +9552,161 @@ function doctor(ctx, _args, opts) {
 }
 
 // src/commands/skills.ts
-var import_node_fs22 = require("node:fs");
+var import_node_fs23 = require("node:fs");
 var import_node_url = require("node:url");
 var import_node_os7 = require("node:os");
-var import_node_path20 = require("node:path");
-function defaultTarget() {
-  return import_node_path20.join(import_node_os7.homedir(), ".claude", "skills");
+var import_node_path19 = require("node:path");
+var AGENT_IDS = ["claude", "codex"];
+var INSTALL_AGENT_IDS = ["auto", "custom", ...AGENT_IDS];
+function trimEnv(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : undefined;
+}
+function claudeHomeDir() {
+  return import_node_path19.join(import_node_os7.homedir(), ".claude");
+}
+function codexHomeDir() {
+  return trimEnv("CODEX_HOME") ?? import_node_path19.join(import_node_os7.homedir(), ".codex");
+}
+var AGENT_ADAPTERS = [
+  {
+    id: "claude",
+    label: "Claude Code",
+    homeDir: claudeHomeDir,
+    skillsDir: () => import_node_path19.join(claudeHomeDir(), "skills")
+  },
+  {
+    id: "codex",
+    label: "Codex",
+    homeDir: codexHomeDir,
+    skillsDir: () => import_node_path19.join(codexHomeDir(), "skills"),
+    envHint: "CODEX_HOME"
+  }
+];
+function getAgentAdapter(id) {
+  const adapter = AGENT_ADAPTERS.find((a) => a.id === id);
+  if (!adapter) {
+    throw new YoooclawError(ErrorCode.INVALID_ARGUMENT, `不支持的 agent：${id}`, { hint: `可选值：${INSTALL_AGENT_IDS.join(" | ")}` });
+  }
+  return adapter;
+}
+function normalizeAgent(raw) {
+  const agent = typeof raw === "string" && raw.trim() ? raw.trim() : "auto";
+  if (INSTALL_AGENT_IDS.includes(agent)) {
+    return agent;
+  }
+  throw new YoooclawError(ErrorCode.INVALID_ARGUMENT, `不支持的 agent：${agent}`, { hint: `可选值：${INSTALL_AGENT_IDS.join(" | ")}` });
+}
+function hasPath(path7) {
+  return import_node_fs23.existsSync(path7);
+}
+function listSkillTargetCandidates() {
+  return AGENT_ADAPTERS.map((adapter) => {
+    const homeDir2 = adapter.homeDir();
+    const target = adapter.skillsDir();
+    const hasHome = hasPath(homeDir2);
+    const hasTarget = hasPath(target);
+    const envValue = adapter.envHint ? trimEnv(adapter.envHint) : undefined;
+    return {
+      agent: adapter.id,
+      label: adapter.label,
+      homeDir: homeDir2,
+      target,
+      detected: hasHome || hasTarget || Boolean(envValue),
+      reason: hasTarget ? "skills 目录已存在" : hasHome ? "agent 配置目录已存在" : envValue && adapter.envHint ? `${adapter.envHint} 已设置` : adapter.envHint ? `未发现配置目录；可设置 ${adapter.envHint} 或显式传 --agent ${adapter.id}` : `未发现配置目录；可显式传 --agent ${adapter.id}`,
+      installCommand: `yoooclaw skills install --agent ${adapter.id}`
+    };
+  });
+}
+function resolveTargetSelection(opts) {
+  const explicitTarget = opts.target?.trim();
+  const agent = normalizeAgent(opts.agent);
+  if (explicitTarget) {
+    if (agent === "auto" || agent === "custom") {
+      return {
+        agent: "custom",
+        agentLabel: "Custom",
+        target: explicitTarget,
+        source: "explicit-target"
+      };
+    }
+    const adapter = getAgentAdapter(agent);
+    return {
+      agent,
+      agentLabel: adapter.label,
+      target: explicitTarget,
+      source: "explicit-target"
+    };
+  }
+  if (agent === "custom") {
+    throw new YoooclawError(ErrorCode.INVALID_ARGUMENT, "`--agent custom` 需要同时传 `--target <dir>`", { hint: "例如：yoooclaw skills install --agent custom --target ~/.config/agent/skills" });
+  }
+  if (agent !== "auto") {
+    const adapter = getAgentAdapter(agent);
+    return {
+      agent,
+      agentLabel: adapter.label,
+      target: adapter.skillsDir(),
+      source: "agent-default"
+    };
+  }
+  const candidates = listSkillTargetCandidates();
+  const detected = candidates.filter((c) => c.detected);
+  if (detected.length === 1) {
+    const only = detected[0];
+    return {
+      agent: only.agent,
+      agentLabel: only.label,
+      target: only.target,
+      source: "auto-detected",
+      detectedTargets: detected
+    };
+  }
+  if (detected.length === 0) {
+    throw new YoooclawError(ErrorCode.NOT_FOUND, "未检测到可安装 Skill 的 Agent", {
+      hint: "请显式指定 `--agent claude` / `--agent codex`，或使用 `--target <dir>` 指定任意 skills 目录",
+      targets: candidates
+    });
+  }
+  throw new YoooclawError(ErrorCode.CONFIRMATION_REQUIRED, "检测到多个 Agent，无法自动判断 Skill 应安装到哪里", {
+    hint: "请显式指定 `--agent claude` / `--agent codex`，或使用 `--target <dir>`",
+    targets: detected
+  });
 }
 function candidateAnchorDirs() {
   const out = [];
   try {
     const mainFile = require.main?.filename;
     if (mainFile)
-      out.push(import_node_path20.dirname(mainFile));
+      out.push(import_node_path19.dirname(mainFile));
   } catch {}
   try {
     const argv1 = process.argv[1];
     if (argv1)
-      out.push(import_node_path20.dirname(import_node_fs22.realpathSync(argv1)));
+      out.push(import_node_path19.dirname(import_node_fs23.realpathSync(argv1)));
   } catch {}
   try {
     const url = "file:///Users/cobb/github/openclaw-plugin/packages/cli/src/commands/skills.ts";
     if (url)
-      out.push(import_node_path20.dirname(import_node_url.fileURLToPath(url)));
+      out.push(import_node_path19.dirname(import_node_url.fileURLToPath(url)));
   } catch {}
   return out;
 }
 function looksLikeSkillsDir(dir) {
-  if (!import_node_fs22.existsSync(dir))
+  if (!import_node_fs23.existsSync(dir))
     return false;
-  return import_node_fs22.readdirSync(dir, { withFileTypes: true }).some((e) => e.isDirectory() && import_node_fs22.existsSync(import_node_path20.join(dir, e.name, "SKILL.md")));
+  return import_node_fs23.readdirSync(dir, { withFileTypes: true }).some((e) => e.isDirectory() && import_node_fs23.existsSync(import_node_path19.join(dir, e.name, "SKILL.md")));
 }
 function resolveBundledSkillsDir() {
   const checked = [];
   for (const anchor of candidateAnchorDirs()) {
     let cur = anchor;
     for (let i = 0;i < 6; i += 1) {
-      const candidate = import_node_path20.join(cur, "skills");
+      const candidate = import_node_path19.join(cur, "skills");
       checked.push(candidate);
       if (looksLikeSkillsDir(candidate))
         return candidate;
-      const parent = import_node_path20.dirname(cur);
+      const parent = import_node_path19.dirname(cur);
       if (parent === cur)
         break;
       cur = parent;
@@ -9024,9 +9727,9 @@ function parseSkillMeta(skillMd) {
   return { name: pick("name"), description: pick("description") };
 }
 function listBundledSkills(skillsDir) {
-  return import_node_fs22.readdirSync(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory() && import_node_fs22.existsSync(import_node_path20.join(skillsDir, e.name, "SKILL.md"))).map((e) => {
-    const dir = import_node_path20.join(skillsDir, e.name);
-    const meta = parseSkillMeta(import_node_fs22.readFileSync(import_node_path20.join(dir, "SKILL.md"), "utf-8"));
+  return import_node_fs23.readdirSync(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory() && import_node_fs23.existsSync(import_node_path19.join(skillsDir, e.name, "SKILL.md"))).map((e) => {
+    const dir = import_node_path19.join(skillsDir, e.name);
+    const meta = parseSkillMeta(import_node_fs23.readFileSync(import_node_path19.join(dir, "SKILL.md"), "utf-8"));
     return {
       name: e.name,
       dir,
@@ -9047,25 +9750,33 @@ function skillsList(_ctx) {
       title: s.title,
       description: s.description
     })),
-    hint: "用 `yoooclaw skills install` 安装到 agent skills 目录（默认 ~/.claude/skills）"
+    hint: "用 `yoooclaw skills targets` 查看可安装目标，再用 `yoooclaw skills install --agent <agent>` 安装"
+  };
+}
+function skillsTargets(_ctx) {
+  const targets = listSkillTargetCandidates();
+  return {
+    ok: true,
+    targets,
+    hint: "裸 `yoooclaw skills install` 只会在检测到唯一 Agent 时自动安装；否则请显式传 `--agent` 或 `--target`"
   };
 }
 function isSameSymlink(dest, source) {
   try {
-    if (!import_node_fs22.lstatSync(dest).isSymbolicLink())
+    if (!import_node_fs23.lstatSync(dest).isSymbolicLink())
       return false;
-    return import_node_fs22.realpathSync(dest) === import_node_fs22.realpathSync(source);
+    return import_node_fs23.realpathSync(dest) === import_node_fs23.realpathSync(source);
   } catch {
     return false;
   }
 }
 function linkOrCopy(source, dest, mode) {
   if (mode === "copy") {
-    import_node_fs22.cpSync(source, dest, { recursive: true });
+    import_node_fs23.cpSync(source, dest, { recursive: true });
     return;
   }
   try {
-    import_node_fs22.symlinkSync(source, dest, "dir");
+    import_node_fs23.symlinkSync(source, dest, "dir");
   } catch (err) {
     const e = err;
     if (e.code === "EPERM" || e.code === "EACCES") {
@@ -9075,16 +9786,16 @@ function linkOrCopy(source, dest, mode) {
   }
 }
 function installOne(skill, target, mode, force) {
-  const source = import_node_fs22.realpathSync(skill.dir);
-  const dest = import_node_path20.join(target, skill.name);
-  if (import_node_fs22.existsSync(dest) || isSymlinkPresent(dest)) {
+  const source = import_node_fs23.realpathSync(skill.dir);
+  const dest = import_node_path19.join(target, skill.name);
+  if (import_node_fs23.existsSync(dest) || isSymlinkPresent(dest)) {
     if (mode === "symlink" && isSameSymlink(dest, source)) {
       return { name: skill.name, status: "installed", via: "symlink", dest };
     }
     if (!force) {
       return { name: skill.name, status: "skipped", reason: "目标已存在，加 --force 覆盖", dest };
     }
-    import_node_fs22.rmSync(dest, { recursive: true, force: true });
+    import_node_fs23.rmSync(dest, { recursive: true, force: true });
   }
   linkOrCopy(source, dest, mode);
   return { name: skill.name, status: "installed", via: mode, dest };
@@ -9092,25 +9803,30 @@ function installOne(skill, target, mode, force) {
 function skillsInstall(_ctx, _args, opts) {
   const skillsDir = resolveBundledSkillsDir();
   const skills = listBundledSkills(skillsDir);
-  const target = opts.target?.trim() || defaultTarget();
+  const selection = resolveTargetSelection(opts);
+  const target = selection.target;
   const mode = opts.copy ? "copy" : "symlink";
-  import_node_fs22.mkdirSync(target, { recursive: true });
+  import_node_fs23.mkdirSync(target, { recursive: true });
   const results = skills.map((skill) => installOne(skill, target, mode, opts.force ?? false));
   const installed = results.filter((r) => r.status === "installed");
   return {
     ok: true,
+    agent: selection.agent,
+    agentLabel: selection.agentLabel,
     target,
+    targetSource: selection.source,
     mode,
     sourceDir: skillsDir,
     installed: installed.map((r) => r.name),
     skipped: results.filter((r) => r.status === "skipped"),
     results,
+    detectedTargets: selection.detectedTargets,
     hint: installed.length > 0 ? '重启 agent 会话后即可被发现；试试说"看看最近的通知"触发 yoooclaw-notification-query' : "没有新安装的 Skill（已存在则加 --force 覆盖）"
   };
 }
 function isSymlinkPresent(p) {
   try {
-    import_node_fs22.lstatSync(p);
+    import_node_fs23.lstatSync(p);
     return true;
   } catch {
     return false;
@@ -9119,15 +9835,15 @@ function isSymlinkPresent(p) {
 
 // src/commands/daemon.ts
 var import_node_child_process2 = require("node:child_process");
-var import_node_fs26 = require("node:fs");
+var import_node_fs27 = require("node:fs");
 var import_promises4 = require("node:timers/promises");
 
 // src/daemon/main.ts
 var import_node_http = require("node:http");
 
 // src/daemon/logger.ts
-var import_node_fs23 = require("node:fs");
-var import_node_path21 = require("node:path");
+var import_node_fs24 = require("node:fs");
+var import_node_path20 = require("node:path");
 var LEVEL_ORDER = {
   error: 0,
   warn: 1,
@@ -9138,9 +9854,9 @@ var LEVEL_ORDER = {
 function isoLocal(d) {
   const pad = (n, w = 2) => String(n).padStart(w, "0");
   const off = -d.getTimezoneOffset();
-  const sign = off >= 0 ? "+" : "-";
+  const sign2 = off >= 0 ? "+" : "-";
   const abs = Math.abs(off);
-  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` + `T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}` + `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` + `T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}` + `${sign2}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
 }
 function dateKey(d) {
   const pad = (n) => String(n).padStart(2, "0");
@@ -9156,7 +9872,7 @@ class DaemonLogger {
     this.logFile = logFile;
     this.level = level;
     this.alsoStderr = alsoStderr;
-    ensureDir(import_node_path21.dirname(logFile));
+    ensureDir(import_node_path20.dirname(logFile));
     this.currentDay = dateKey(new Date);
     this.rotateIfNeeded(new Date);
   }
@@ -9164,18 +9880,18 @@ class DaemonLogger {
     return (LEVEL_ORDER[level] ?? 2) <= (LEVEL_ORDER[this.level] ?? 2);
   }
   rotateIfNeeded(now) {
-    if (!import_node_fs23.existsSync(this.logFile))
+    if (!import_node_fs24.existsSync(this.logFile))
       return;
     let fileDay;
     try {
-      fileDay = dateKey(import_node_fs23.statSync(this.logFile).mtime);
+      fileDay = dateKey(import_node_fs24.statSync(this.logFile).mtime);
     } catch {
       return;
     }
     const today2 = dateKey(now);
     if (fileDay !== today2) {
       try {
-        import_node_fs23.renameSync(this.logFile, `${this.logFile}.${fileDay}`);
+        import_node_fs24.renameSync(this.logFile, `${this.logFile}.${fileDay}`);
       } catch {}
     }
   }
@@ -9190,7 +9906,7 @@ class DaemonLogger {
     const line = `${isoLocal(now)} [${level.toUpperCase()}] ${msg}
 `;
     try {
-      import_node_fs23.appendFileSync(this.logFile, line);
+      import_node_fs24.appendFileSync(this.logFile, line);
     } catch {}
     if (this.alsoStderr)
       process.stderr.write(line);
@@ -9269,19 +9985,23 @@ class StandaloneRuntime {
 }
 
 // src/daemon/relay.ts
-var import_node_path22 = require("node:path");
+var import_node_path21 = require("node:path");
 var DEFAULT_HEARTBEAT_SEC = 10;
 var DEFAULT_RECONNECT_BACKOFF_MS = 2000;
+function relayCredential(apiKey) {
+  const raw = apiKey.startsWith("Bearer ") ? apiKey.slice("Bearer ".length) : apiKey;
+  return { query: { apiKey: raw } };
+}
 function startRelayTunnel(opts) {
   const { logger } = opts;
-  const statusFilePath = import_node_path22.join(opts.stateDir, "state", "tunnel-status.json");
+  const statusFilePath = import_node_path21.join(opts.stateDir, "state", "tunnel-status.json");
   let abortController = new AbortController;
   let connected = false;
   let reconnectAttempt = 0;
   let lastDisconnectReason;
   const client = new RelayClient({
     tunnelUrl: opts.tunnelUrl,
-    apiKey: opts.apiKey,
+    credentialProvider: async () => relayCredential(opts.apiKey),
     heartbeatSec: opts.heartbeatSec ?? DEFAULT_HEARTBEAT_SEC,
     reconnectBackoffMs: opts.reconnectBackoffMs ?? DEFAULT_RECONNECT_BACKOFF_MS,
     statusFilePath,
@@ -9337,15 +10057,15 @@ function startRelayTunnel(opts) {
 }
 
 // src/image/channel.ts
-var import_node_fs24 = require("node:fs");
+var import_node_fs25 = require("node:fs");
 var import_node_stream = require("node:stream");
-var import_node_path23 = require("node:path");
+var import_node_path22 = require("node:path");
 function readAll(paths) {
   const p = imagesIndexPath(paths);
-  if (!import_node_fs24.existsSync(p))
+  if (!import_node_fs25.existsSync(p))
     return [];
   try {
-    const raw = JSON.parse(import_node_fs24.readFileSync(p, "utf-8"));
+    const raw = JSON.parse(import_node_fs25.readFileSync(p, "utf-8"));
     return Array.isArray(raw?.images) ? raw.images : [];
   } catch {
     return [];
@@ -9400,10 +10120,10 @@ function ingestImage(paths, payload, opts) {
   return { ok: true, imageId, status: "syncing" };
 }
 async function downloadInBackground(paths, entry, opts) {
-  const filesDir = import_node_path23.join(paths.images, "files");
+  const filesDir = import_node_path22.join(paths.images, "files");
   ensureDir(filesDir);
   const relative = `files/${entry.imageId}.${extFromMime(entry.metadata.mime_type)}`;
-  const dest = import_node_path23.join(paths.images, relative);
+  const dest = import_node_path22.join(paths.images, relative);
   try {
     const res = await fetch(entry.metadata.oss_image_url);
     if (!res.ok || !res.body) {
@@ -9414,7 +10134,7 @@ async function downloadInBackground(paths, entry, opts) {
       throw new Error(`图片超过上限 ${opts.maxBytes} 字节`);
     }
     let written = 0;
-    const fileStream = import_node_fs24.createWriteStream(dest);
+    const fileStream = import_node_fs25.createWriteStream(dest);
     const reader = import_node_stream.Readable.fromWeb(res.body);
     for await (const chunk of reader) {
       written += chunk.length;
@@ -9446,17 +10166,17 @@ async function downloadInBackground(paths, entry, opts) {
 }
 
 // src/monitor/store.ts
-var import_node_fs25 = require("node:fs");
-var import_node_path24 = require("node:path");
+var import_node_fs26 = require("node:fs");
+var import_node_path23 = require("node:path");
 function storePath(paths) {
-  return import_node_path24.join(paths.state, "monitors.json");
+  return import_node_path23.join(paths.state, "monitors.json");
 }
 function listMonitors(paths) {
   const p = storePath(paths);
-  if (!import_node_fs25.existsSync(p))
+  if (!import_node_fs26.existsSync(p))
     return [];
   try {
-    const raw = JSON.parse(import_node_fs25.readFileSync(p, "utf-8"));
+    const raw = JSON.parse(import_node_fs26.readFileSync(p, "utf-8"));
     return Array.isArray(raw?.monitors) ? raw.monitors : [];
   } catch {
     return [];
@@ -9509,6 +10229,104 @@ function setMonitorEnabled(paths, name, enabled) {
   return true;
 }
 
+// src/daemon/light-send.ts
+async function performLightSend(input, deps) {
+  let resolved;
+  try {
+    resolved = resolveSource(input, deps.registry);
+  } catch (err) {
+    return errorOutcome(400, "INVALID_PARAMS", err.message);
+  }
+  const overrideRepeat = input.repeat !== undefined || input.repeat_times !== undefined;
+  let repeatTimes = resolved.repeat_times;
+  if (overrideRepeat) {
+    try {
+      repeatTimes = normalizeRepeatTimes({
+        repeat: input.repeat,
+        repeat_times: input.repeat_times
+      });
+    } catch (err) {
+      return errorOutcome(400, "VALIDATION_FAILED", err.message);
+    }
+  }
+  try {
+    assertAncsRepeatTimes(repeatTimes);
+  } catch (err) {
+    return errorOutcome(400, "VALIDATION_FAILED", err.message);
+  }
+  const apiKey = resolveApiKey();
+  if (!apiKey.value) {
+    return errorOutcome(401, "AUTH_REQUIRED", "未配置 api-key，运行 `yoooclaw auth set-api-key <ock_…>`");
+  }
+  deps.logger.info(`/light/send 解析完成 source=${resolved.source} reason=${resolved.reason} ` + `segments=${resolved.segments.length} repeat_times=${repeatTimes}`);
+  const result = await sendLightEffect(apiKey.value, resolved.segments, deps.logger, { repeat_times: repeatTimes }, resolved.reason, resolved.title);
+  if (!result.ok) {
+    return errorOutcome(result.status ?? 502, "LIGHT_SEND_FAILED", result.error ?? "灯效投递失败");
+  }
+  return {
+    ok: true,
+    status: 200,
+    body: {
+      ok: true,
+      accepted: true,
+      delivered: true,
+      source: resolved.source,
+      bizUniqueId: result.bizUniqueId,
+      segments: resolved.segments,
+      repeat_times: repeatTimes,
+      response: result.response
+    }
+  };
+}
+function resolveSource(input, registry) {
+  if (input.rule) {
+    const meta = registry.get(input.rule);
+    if (!meta)
+      throw new Error(`规则不存在：${input.rule}`);
+    return {
+      segments: meta.segments,
+      repeat_times: meta.repeat_times,
+      source: "rule",
+      reason: `rule:${meta.name}`,
+      title: meta.title
+    };
+  }
+  if (input.preset) {
+    const preset = LIGHT_PRESETS_V1.presets.find((p) => p.presetId === input.preset);
+    if (!preset) {
+      const available = LIGHT_PRESETS_V1.presets.map((p) => p.presetId).join(", ");
+      throw new Error(`未知 preset：${input.preset}（可用：${available}）`);
+    }
+    return {
+      segments: preset.segments,
+      repeat_times: preset.repeat_times,
+      source: "preset",
+      reason: `preset:${preset.presetId}`,
+      title: preset.displayName
+    };
+  }
+  if (input.segments !== undefined) {
+    const validation = validateSegments(input.segments);
+    if (!validation.valid) {
+      throw new Error(JSON.stringify(validation.errors));
+    }
+    return {
+      segments: validation.segments,
+      repeat_times: 1,
+      source: "segments",
+      reason: "manual"
+    };
+  }
+  throw new Error("需要 segments / preset / rule 之一");
+}
+function errorOutcome(status, code, message) {
+  return {
+    ok: false,
+    status,
+    body: { ok: false, error: { code, message } }
+  };
+}
+
 // src/daemon/main.ts
 var PROTOCOL_VERSION = 1;
 var CAPABILITIES = ["notifications", "recordings", "images", "lightrules"];
@@ -9672,7 +10490,11 @@ async function runDaemonForeground(ctx, opts) {
       const body = await parseJson(req, res);
       if (body === undefined)
         return;
-      await handleLightSend(body, res);
+      const outcome = await performLightSend(body, {
+        logger,
+        registry: lightRuleRegistry
+      });
+      sendJson(res, outcome.status, outcome.body);
       return;
     }
     if (path7 === "/images" && method === "POST") {
@@ -9741,27 +10563,6 @@ async function runDaemonForeground(ctx, opts) {
       return;
     }
   }
-  async function handleLightSend(body, res) {
-    const input = body;
-    if (!input.segments && !input.preset) {
-      sendJson(res, 400, { ok: false, error: { code: "INVALID_PARAMS", message: "需要 --segments 或 --preset" } });
-      return;
-    }
-    if (input.segments) {
-      const validation = validateSegments(input.segments);
-      if (!validation.valid) {
-        sendJson(res, 400, { ok: false, error: { code: "VALIDATION_FAILED", message: JSON.stringify(validation.errors) } });
-        return;
-      }
-    }
-    logger.info(`/light/send 已接收（preset=${input.preset ?? "-"}）；standalone 无连接设备，未实际投递`);
-    sendJson(res, 200, {
-      ok: true,
-      accepted: true,
-      delivered: false,
-      reason: "standalone daemon 暂无连接的灯效设备会话（需手机端在线 / relay）"
-    });
-  }
   let serverRef = null;
   let relayHandle = null;
   let shuttingDown = false;
@@ -9956,9 +10757,9 @@ async function daemonStatus(ctx) {
   return res.body;
 }
 function tailLines(file, n) {
-  if (!import_node_fs26.existsSync(file))
+  if (!import_node_fs27.existsSync(file))
     return [];
-  const content = import_node_fs26.readFileSync(file, "utf-8").split(`
+  const content = import_node_fs27.readFileSync(file, "utf-8").split(`
 `).filter(Boolean);
   return content.slice(-n);
 }
@@ -9976,14 +10777,14 @@ async function daemonLogs(ctx, _args, opts) {
   for (const l of lines)
     process.stdout.write(l + `
 `);
-  let size = import_node_fs26.existsSync(file) ? import_node_fs26.statSync(file).size : 0;
+  let size = import_node_fs27.existsSync(file) ? import_node_fs27.statSync(file).size : 0;
   await new Promise(() => {
-    import_node_fs26.watchFile(file, { interval: 500 }, () => {
-      if (!import_node_fs26.existsSync(file))
+    import_node_fs27.watchFile(file, { interval: 500 }, () => {
+      if (!import_node_fs27.existsSync(file))
         return;
-      const cur = import_node_fs26.statSync(file).size;
+      const cur = import_node_fs27.statSync(file).size;
       if (cur > size) {
-        const chunk = import_node_fs26.readFileSync(file, "utf-8").slice(-(cur - size));
+        const chunk = import_node_fs27.readFileSync(file, "utf-8").slice(-(cur - size));
         size = cur;
         process.stdout.write(chunk);
       } else if (cur < size) {
@@ -9995,7 +10796,7 @@ async function daemonLogs(ctx, _args, opts) {
 }
 
 // src/commands/daemon-services.ts
-var import_node_fs27 = require("node:fs");
+var import_node_fs28 = require("node:fs");
 function client(ctx) {
   assertDaemonRunning(ctx.paths);
   return new DaemonClient(ctx.paths);
@@ -10010,11 +10811,16 @@ function parseJsonArg(raw, label) {
   }
 }
 async function lightSend(ctx, _args, opts) {
+  if (!opts.segments && !opts.preset && !opts.rule) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "需要 --segments / --preset / --rule 之一");
+  }
   const body = {};
   if (opts.segments)
     body.segments = parseJsonArg(opts.segments, "--segments");
   if (opts.preset)
     body.preset = opts.preset;
+  if (opts.rule)
+    body.rule = opts.rule;
   if (opts.repeat)
     body.repeat = true;
   if (opts.repeatTimes !== undefined)
@@ -10023,7 +10829,7 @@ async function lightSend(ctx, _args, opts) {
   return res.body;
 }
 async function lightBlink(ctx) {
-  const res = await client(ctx).post("/light/send", { preset: "blink" });
+  const res = await client(ctx).post("/light/send", { preset: "red-strobe-3" });
   return res.body;
 }
 async function listRules(c) {
@@ -10042,7 +10848,7 @@ async function lightruleShow(ctx, args) {
 }
 async function buildRuleParams(opts, name) {
   if (opts.fromFile) {
-    const raw = opts.fromFile === "-" ? await readStdin() : import_node_fs27.readFileSync(opts.fromFile, "utf-8");
+    const raw = opts.fromFile === "-" ? await readStdin() : import_node_fs28.readFileSync(opts.fromFile, "utf-8");
     return JSON.parse(raw);
   }
   const params = {};
@@ -10182,7 +10988,7 @@ async function apiRaw(ctx, args, opts) {
     if (opts.data === "-")
       raw = await readStdin();
     else if (opts.data.startsWith("@"))
-      raw = import_node_fs27.readFileSync(opts.data.slice(1), "utf-8");
+      raw = import_node_fs28.readFileSync(opts.data.slice(1), "utf-8");
     else
       raw = opts.data;
     try {
@@ -10241,6 +11047,7 @@ var HANDLERS = {
   "migrate from-openclaw": migrateFromOpenclaw,
   "update self": updateSelf,
   "skills list": skillsList,
+  "skills targets": skillsTargets,
   "skills install": skillsInstall,
   doctor,
   "daemon start": daemonStart,
@@ -10352,5 +11159,5 @@ async function run(argv = process.argv) {
 // src/bin.ts
 run(process.argv);
 
-//# debugId=3D842115BFE90B5564756E2164756E21
+//# debugId=C3FED3BF0AFFC1F564756E2164756E21
 //# sourceMappingURL=bin.cjs.map