@coolclaw/coolclaw 1.0.15 → 1.0.17

package/dist/{chunk-R4H3YAWU.js → chunk-3YKMAM6K.js}

@@ -1,10 +1,68 @@
+// flavors/coolclaw.flavor.json
+var coolclaw_flavor_default = {
+  productKey: "coolclaw",
+  displayName: "CoolClaw",
+  npmScope: "@coolclaw",
+  channelPackageName: "@coolclaw/coolclaw",
+  cliPackageName: "@coolclaw/coolclaw-cli",
+  skillsPackageName: "@coolclaw/coolclaw-skills",
+  channelId: "coolclaw",
+  pluginId: "coolclaw",
+  skillName: "coolclaw",
+  envPrefix: "COOLCLAW",
+  configDirName: "coolclaw",
+  defaultGatewayUrl: "https://agits-xa.baidu.com/riddle",
+  targetPrefix: "coolclaw"
+};
+
+// flavors/clawtopia.flavor.json
+var clawtopia_flavor_default = {
+  productKey: "clawtopia",
+  displayName: "Clawtopia",
+  npmScope: "@clawtopia",
+  channelPackageName: "@clawtopia/clawtopia",
+  cliPackageName: "@clawtopia/clawtopia-cli",
+  skillsPackageName: "@clawtopia/clawtopia-skills",
+  channelId: "clawtopia",
+  pluginId: "clawtopia",
+  skillName: "clawtopia",
+  envPrefix: "CLAWTOPIA",
+  configDirName: "clawtopia",
+  defaultGatewayUrl: "https://clawtopia.baidu.com/riddle",
+  targetPrefix: "clawtopia"
+};
+
+// src/flavor-build.ts
+var BUILT_PRODUCT_FLAVOR = "coolclaw";
+
+// src/flavor.ts
+var FLAVORS = {
+  coolclaw: coolclaw_flavor_default,
+  clawtopia: clawtopia_flavor_default
+};
+function getFlavorByKey(key) {
+  const flavor = FLAVORS[key];
+  if (!flavor) {
+    throw new Error(`Unknown PRODUCT_FLAVOR: ${key}`);
+  }
+  return flavor;
+}
+function activeFlavor(env = process.env) {
+  return getFlavorByKey(env.PRODUCT_FLAVOR ?? BUILT_PRODUCT_FLAVOR);
+}
+function resolveFlavor(input) {
+  if (!input) return activeFlavor();
+  return typeof input === "string" ? getFlavorByKey(input) : input;
+}
+
 // src/binding.ts
 import { mkdir, readFile, rename, writeFile, chmod } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
 import { fileURLToPath } from "url";
-function defaultBindingFile(home = homedir()) {
-  return path.join(home, ".config", "coolclaw", "agent_binding.json");
+function defaultBindingFile(home = homedir(), flavorInput) {
+  const flavor = resolveFlavor(flavorInput);
+  return path.join(home, ".config", flavor.configDirName, "agent_binding.json");
 }
 async function readTokenRef(tokenRef) {
   if (!tokenRef) return void 0;
@@ -122,6 +180,7 @@ var FileAckStore = class {
 
 // src/agent-task.ts
 import { createHash } from "crypto";
+var WEREWOLF_STRUCTURED_ACTION_PROTOCOL_VERSION = "WEREWOLF_STRUCTURED_JSON_MESSAGE_V1";
 function normalizeAgentTask(value) {
   if (!isRecord(value)) return null;
   const actionContract = normalizeActionContract(value.actionContract);
@@ -133,6 +192,9 @@ function normalizeAgentTask(value) {
     renderedPrompt: readString(value.renderedPrompt) ?? "",
     renderedPromptHash: readString(value.renderedPromptHash),
     actionFormat: readString(value.actionFormat),
+    actionProtocolVersion: readString(value.actionProtocolVersion),
+    outputSchema: isRecord(value.outputSchema) ? value.outputSchema : void 0,
+    retryPolicy: normalizeRetryPolicy(value.retryPolicy),
     conversationKey: readString(value.conversationKey),
     actionContract,
     fallbackAction,
@@ -142,6 +204,9 @@ function normalizeAgentTask(value) {
 function isDispatchableAgentTask(task) {
   return task.requiresReply === true && task.renderedPrompt.trim().length > 0 && allowedActionTypes(task).length > 0;
 }
+function isStructuredJsonTask(task) {
+  return task.actionProtocolVersion === WEREWOLF_STRUCTURED_ACTION_PROTOCOL_VERSION || task.actionFormat === "STRICT_JSON_OBJECT";
+}
 function validateAgentAction(action, task) {
   if (!isRecord(action.actionData)) {
     return { ok: false, reason: "invalid_action_shape" };
@@ -158,12 +223,18 @@ function validateAgentAction(action, task) {
   if (!matchesActionDataSchema(repaired.actionData, option.actionDataSchema)) {
     return { ok: false, reason: "invalid_action_shape" };
   }
+  if (isStructuredJsonTask(task) && !matchesRootOutputSchema(action, task.outputSchema)) {
+    return { ok: false, reason: "invalid_action_shape" };
+  }
+  const normalizedAction = {
+    actionType: action.actionType,
+    actionData: repaired.actionData
+  };
+  if (typeof action.speech === "string") normalizedAction.speech = action.speech;
+  if (typeof action.reason === "string") normalizedAction.reason = action.reason;
   return {
     ok: true,
-    action: {
-      actionType: action.actionType,
-      actionData: repaired.actionData
-    },
+    action: normalizedAction,
     repairReason: repaired.repairReason
   };
 }
@@ -193,6 +264,14 @@ function normalizeActionContract(value) {
     finalOutputRules: Array.isArray(value.finalOutputRules) ? value.finalOutputRules.filter((rule) => typeof rule === "string") : void 0
   };
 }
+function normalizeRetryPolicy(value) {
+  if (!isRecord(value)) return void 0;
+  return {
+    maxRetries: readNumber(value.maxRetries),
+    shareDeadline: typeof value.shareDeadline === "boolean" ? value.shareDeadline : void 0,
+    rejectedOutputActionType: readString(value.rejectedOutputActionType)
+  };
+}
 function normalizeActionOption(value) {
   if (!isRecord(value) || typeof value.actionType !== "string" || value.actionType.length === 0) {
     return [];
@@ -208,20 +287,17 @@ function allowedActionTypes(task) {
 }
 function matchesActionDataSchema(actionData, schema) {
   if (!schema || Object.keys(schema).length === 0) return true;
-  if (typeof schema.type === "string" && schema.type !== "object") return false;
-  const properties = isRecord(schema.properties) ? schema.properties : {};
-  const required = Array.isArray(schema.required) ? schema.required.filter((field) => typeof field === "string" && field.length > 0) : [];
-  for (const field of required) {
-    if (!Object.prototype.hasOwnProperty.call(actionData, field)) return false;
-    if (!matchesSchemaValue(actionData[field], properties[field], true)) return false;
-  }
-  for (const [field, value] of Object.entries(actionData)) {
-    const propertySchema = properties[field];
-    if (propertySchema !== void 0 && !matchesSchemaValue(value, propertySchema, false)) {
-      return false;
-    }
-  }
-  return true;
+  return matchesSchemaValue(actionData, schema, true);
+}
+function matchesRootOutputSchema(action, schema) {
+  if (!schema || Object.keys(schema).length === 0) return true;
+  const root = {
+    actionType: action.actionType,
+    actionData: action.actionData
+  };
+  if (typeof action.speech === "string") root.speech = action.speech;
+  if (typeof action.reason === "string") root.reason = action.reason;
+  return matchesSchemaValue(root, schema, true);
 }
 function repairActionDataForSchema(actionData, schema) {
   if (!schema || Object.keys(schema).length === 0) {
@@ -257,12 +333,28 @@ function repairActionDataForSchema(actionData, schema) {
   };
 }
 function matchesSchemaValue(value, schema, required) {
-  if (value == null) return !required;
   if (!isRecord(schema)) return true;
+  if (value == null) {
+    return !required || schemaAllowsType(schema.type, "null");
+  }
+  const oneOf = Array.isArray(schema.oneOf) ? schema.oneOf : [];
+  if (oneOf.length > 0) {
+    return oneOf.some((variant) => matchesSchemaValue(value, variant, required));
+  }
   if (Array.isArray(schema.enum) && !schema.enum.includes(value)) {
     return false;
   }
-  switch (schema.type) {
+  const allowedTypes = Array.isArray(schema.type) ? schema.type.filter((type) => typeof type === "string") : typeof schema.type === "string" ? [schema.type] : [];
+  if (allowedTypes.length === 0) {
+    return true;
+  }
+  return allowedTypes.some((type) => matchesSchemaTypedValue(value, schema, type));
+}
+function schemaAllowsType(typeNode, type) {
+  return Array.isArray(typeNode) ? typeNode.includes(type) : typeNode === type;
+}
+function matchesSchemaTypedValue(value, schema, type) {
+  switch (type) {
     case "integer":
       return typeof value === "number" && Number.isInteger(value);
     case "number":
@@ -272,13 +364,33 @@ function matchesSchemaValue(value, schema, required) {
     case "boolean":
       return typeof value === "boolean";
     case "object":
-      return isRecord(value);
+      return matchesObjectSchema(value, schema);
     case "array":
       return Array.isArray(value);
+    case "null":
+      return value == null;
     default:
       return true;
   }
 }
+function matchesObjectSchema(value, schema) {
+  if (!isRecord(value)) return false;
+  const properties = isRecord(schema.properties) ? schema.properties : {};
+  const required = Array.isArray(schema.required) ? schema.required.filter((field) => typeof field === "string" && field.length > 0) : [];
+  for (const field of required) {
+    if (!Object.prototype.hasOwnProperty.call(value, field)) return false;
+    if (!matchesSchemaValue(value[field], properties[field], true)) return false;
+  }
+  for (const [field, fieldValue] of Object.entries(value)) {
+    const propertySchema = properties[field];
+    if (propertySchema === void 0) {
+      if (schema.additionalProperties === false) return false;
+      continue;
+    }
+    if (!matchesSchemaValue(fieldValue, propertySchema, false)) return false;
+  }
+  return true;
+}
 function readString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -358,14 +470,19 @@ function isRecord2(value) {
 // src/inbound.ts
 var ARENA_REPORT_SHARE_NOTIFY_TYPE = "ARENA_REPORT_SHARE_REQUEST";
 var ARENA_MODEL_QUERY_NOTIFY_TYPE = "ARENA_MODEL_QUERY_REQUEST";
+var ARENA_VOICE_SELECT_NOTIFY_TYPE = "ARENA_VOICE_SELECT_REQUEST";
 var REPORT_SHARE_DEDUPE_LIMIT = 500;
 var MODEL_QUERY_DEDUPE_LIMIT = 500;
+var VOICE_SELECT_DEDUPE_LIMIT = 500;
 var processedArenaReportShareEventIds = /* @__PURE__ */ new Set();
 var processedArenaReportShareEventOrder = [];
 var inFlightArenaReportShareEventIds = /* @__PURE__ */ new Map();
 var processedArenaModelQueryEventIds = /* @__PURE__ */ new Set();
 var processedArenaModelQueryEventOrder = [];
 var inFlightArenaModelQueryEventIds = /* @__PURE__ */ new Map();
+var processedArenaVoiceSelectEventIds = /* @__PURE__ */ new Set();
+var processedArenaVoiceSelectEventOrder = [];
+var inFlightArenaVoiceSelectEventIds = /* @__PURE__ */ new Map();
 function mapInboundFrame(frame) {
   if (frame.type === "PRIVATE_MESSAGE") {
     const payload = assertPrivatePayload(frame.payload);
@@ -441,6 +558,13 @@ async function handleInboundFrame(input) {
       inFlight: inFlightArenaModelQueryEventIds,
       remember: rememberArenaModelQueryEventId
     };
+  } else if (isArenaVoiceSelectEnvelope(envelope)) {
+    dedupeState = {
+      eventId: String(envelope.metadata.eventId),
+      processed: processedArenaVoiceSelectEventIds,
+      inFlight: inFlightArenaVoiceSelectEventIds,
+      remember: rememberArenaVoiceSelectEventId
+    };
   }
   if (dedupeState) {
     if (dedupeState.processed.has(dedupeState.eventId)) {
@@ -493,6 +617,9 @@ function isArenaReportShareEnvelope(envelope) {
 function isArenaModelQueryEnvelope(envelope) {
   return envelope.metadata?.arenaModelQueryRequest === true && typeof envelope.metadata.eventId === "string" && envelope.metadata.eventId.length > 0 && typeof envelope.metadata.callbackUrl === "string" && envelope.metadata.callbackUrl.length > 0;
 }
+function isArenaVoiceSelectEnvelope(envelope) {
+  return envelope.metadata?.arenaVoiceSelectRequest === true && typeof envelope.metadata.eventId === "string" && envelope.metadata.eventId.length > 0 && typeof envelope.metadata.callbackUrl === "string" && envelope.metadata.callbackUrl.length > 0;
+}
 function mapNotificationFrame(frame) {
   const payload = isRecord3(frame.payload) ? frame.payload : {};
   const seq = typeof payload.seq === "number" ? payload.seq : void 0;
@@ -534,6 +661,9 @@ function mapNotificationFrame(frame) {
     if (notifyType === ARENA_MODEL_QUERY_NOTIFY_TYPE) {
       return mapArenaModelQueryFrame(frame, payload, seq);
     }
+    if (notifyType === ARENA_VOICE_SELECT_NOTIFY_TYPE) {
+      return mapArenaVoiceSelectFrame(frame, payload, seq);
+    }
     const postId = payload.postId != null ? String(payload.postId) : "";
     return {
       id: frame.id,
@@ -548,6 +678,43 @@ function mapNotificationFrame(frame) {
   }
   return null;
 }
+function mapArenaVoiceSelectFrame(frame, payload, seq) {
+  const voicePayload = isRecord3(payload.payload) ? payload.payload : {};
+  const eventId = firstText(payload.eventId, voicePayload.eventId) ?? frame.id;
+  const traceId = typeof payload.traceId === "string" ? payload.traceId : "";
+  const roomId = Number(voicePayload.roomId ?? 0);
+  const seatNumber = Number(voicePayload.seatNumber ?? 0);
+  const seatEpoch = voicePayload.seatEpoch != null ? String(voicePayload.seatEpoch) : "";
+  const callbackUrl = typeof voicePayload.callbackUrl === "string" ? voicePayload.callbackUrl : "";
+  if (!callbackUrl || !roomId || !seatNumber || !seatEpoch) {
+    return null;
+  }
+  const deadlineEpochMs = Number(voicePayload.deadlineEpochMs ?? 0);
+  const voiceOptions = Array.isArray(voicePayload.voiceOptions) ? voicePayload.voiceOptions.filter(isRecord3).map((option) => option) : [];
+  return {
+    id: eventId,
+    channel: "coolclaw",
+    conversationId: `notification:arena_voice_select:${eventId}`,
+    text: "/arena-voice-select",
+    messageType: frame.type,
+    seq,
+    shouldReply: true,
+    metadata: {
+      sourceFrameId: frame.id,
+      payload: frame.payload,
+      voiceSelectPayload: voicePayload,
+      arenaVoiceSelectRequest: true,
+      eventId,
+      traceId,
+      roomId,
+      seatNumber,
+      seatEpoch,
+      callbackUrl,
+      deadlineEpochMs,
+      voiceOptions
+    }
+  };
+}
 function mapArenaModelQueryFrame(frame, payload, seq) {
   const eventId = typeof payload.eventId === "string" && payload.eventId.length > 0 ? payload.eventId : frame.id;
   const traceId = typeof payload.traceId === "string" ? payload.traceId : "";
@@ -583,6 +750,14 @@ function mapArenaModelQueryFrame(frame, payload, seq) {
     }
   };
 }
+function firstText(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  return null;
+}
 function mapArenaReportShareFrame(frame, payload, seq) {
   const eventId = typeof payload.eventId === "string" && payload.eventId.length > 0 ? payload.eventId : frame.id;
   const traceId = typeof payload.traceId === "string" ? payload.traceId : "";
@@ -624,6 +799,15 @@ function rememberArenaModelQueryEventId(eventId) {
     if (expired) processedArenaModelQueryEventIds.delete(expired);
   }
 }
+function rememberArenaVoiceSelectEventId(eventId) {
+  if (processedArenaVoiceSelectEventIds.has(eventId)) return;
+  processedArenaVoiceSelectEventIds.add(eventId);
+  processedArenaVoiceSelectEventOrder.push(eventId);
+  while (processedArenaVoiceSelectEventOrder.length > VOICE_SELECT_DEDUPE_LIMIT) {
+    const expired = processedArenaVoiceSelectEventOrder.shift();
+    if (expired) processedArenaVoiceSelectEventIds.delete(expired);
+  }
+}
 function mapGameEventFrame(frame, payload) {
   const eventType = typeof payload.eventType === "string" ? payload.eventType : "UNKNOWN";
   const agentTask = normalizeAgentTask(payload.agentTask);
@@ -782,15 +966,16 @@ var TargetParseError = class extends Error {
     this.name = "TargetParseError";
   }
 };
-function parseCoolclawTarget(raw) {
-  const normalized = normalizeCoolclawTarget(raw);
+function parseCoolclawTarget(raw, flavorInput) {
+  const flavor = resolveFlavor(flavorInput);
+  const normalized = normalizeCoolclawTarget(raw, flavor);
   const parts = normalized.split(":");
   if (parts.length !== 3) {
-    throw new TargetParseError(`Invalid CoolClaw target: ${raw}`);
+    throw new TargetParseError(`Invalid ${flavor.displayName} target: ${raw}`);
   }
   const [channel, type, id] = parts;
-  if (channel !== "coolclaw" || id.length === 0) {
-    throw new TargetParseError(`Invalid CoolClaw target: ${raw}`);
+  if (channel !== flavor.targetPrefix || id.length === 0) {
+    throw new TargetParseError(`Invalid ${flavor.displayName} target: ${raw}`);
   }
   if (type === "human") {
     return { kind: "private", userType: "HUMAN", userId: id };
@@ -801,9 +986,10 @@ function parseCoolclawTarget(raw) {
   if (type === "group") {
     return { kind: "group", groupId: id };
   }
-  throw new TargetParseError(`Invalid CoolClaw target type: ${type}`);
+  throw new TargetParseError(`Invalid ${flavor.displayName} target type: ${type}`);
 }
-function normalizeCoolclawTarget(raw) {
+function normalizeCoolclawTarget(raw, flavorInput) {
+  resolveFlavor(flavorInput);
   const trimmed = raw.trim();
   const parts = trimmed.split(":");
   if (parts.length !== 3) {
@@ -812,25 +998,27 @@ function normalizeCoolclawTarget(raw) {
   const [channel, type, id] = parts;
   return `${channel.toLowerCase()}:${type.toLowerCase()}:${id.trim()}`;
 }
-function inferCoolclawTargetChatType(raw) {
+function inferCoolclawTargetChatType(raw, flavorInput) {
   try {
-    const target = parseCoolclawTarget(raw);
+    const target = parseCoolclawTarget(raw, flavorInput);
     return target.kind === "private" ? "direct" : "group";
   } catch {
     return void 0;
   }
 }
-function isCoolclawTargetId(raw, normalized = normalizeCoolclawTarget(raw)) {
+function isCoolclawTargetId(raw, normalized = normalizeCoolclawTarget(raw), flavorInput) {
+  const flavor = resolveFlavor(flavorInput);
   try {
-    parseCoolclawTarget(normalized);
-    return normalized.startsWith("coolclaw:");
+    parseCoolclawTarget(normalized, flavor);
+    return normalized.startsWith(`${flavor.targetPrefix}:`);
   } catch {
     return false;
   }
 }
-async function resolveCoolclawMessagingTarget(raw, preferredKind) {
-  const normalized = normalizeCoolclawTarget(raw);
-  const target = parseCoolclawTarget(normalized);
+async function resolveCoolclawMessagingTarget(raw, preferredKind, flavorInput) {
+  const flavor = resolveFlavor(flavorInput);
+  const normalized = normalizeCoolclawTarget(raw, flavor);
+  const target = parseCoolclawTarget(normalized, flavor);
   const kind = target.kind === "private" ? "user" : "group";
   if (preferredKind && preferredKind !== kind) {
     return null;
@@ -913,7 +1101,17 @@ async function sendGameAction(input) {
     rawResponsePreview: input.rawResponsePreview,
     modelActionRejected: input.modelActionRejected,
     modelActionType: input.modelActionType,
-    validationReason: input.validationReason
+    validationReason: input.validationReason,
+    submissionStatus: input.submissionStatus,
+    structuredProtocolVersion: input.structuredProtocolVersion,
+    retryCount: input.retryCount,
+    firstRawResponseHash: input.firstRawResponseHash,
+    firstModelActionType: input.firstModelActionType,
+    firstValidationReason: input.firstValidationReason,
+    retryRawResponseHash: input.retryRawResponseHash,
+    retryValidationReason: input.retryValidationReason,
+    speech: input.speech,
+    reason: input.reason
   });
   const response = await input.client.request(frame);
   if (response.ok === false) {
@@ -989,6 +1187,59 @@ function parseAgentAction(text) {
   }
   return lastError ?? { error: "no_action_block" };
 }
+function parseStrictJsonAgentAction(text) {
+  if (typeof text !== "string" || text.length === 0) {
+    return { error: "no_action_block" };
+  }
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{")) {
+    return { error: "invalid_json", detail: "strict_json_object_required" };
+  }
+  const objectEnd = topLevelJsonObjectEnd(trimmed);
+  if (objectEnd === null) {
+    return { error: "invalid_json", detail: "strict_json_object_required" };
+  }
+  if (objectEnd !== trimmed.length - 1) {
+    return { error: "invalid_json", detail: "trailing_text_after_json" };
+  }
+  return parseActionJsonStrict(trimmed);
+}
+function topLevelJsonObjectEnd(text) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") {
+      depth += 1;
+      continue;
+    }
+    if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return i;
+      }
+      if (depth < 0) {
+        return null;
+      }
+    }
+  }
+  return null;
+}
 function parseActionJson(body) {
   let obj;
   try {
@@ -1017,7 +1268,38 @@ function parseActionJson(body) {
   }
   return {
     actionType: rec.actionType,
-    actionData: rec.actionData
+    actionData: rec.actionData,
+    ...typeof rec.speech === "string" ? { speech: rec.speech } : {},
+    ...typeof rec.reason === "string" ? { reason: rec.reason } : {}
+  };
+}
+function parseActionJsonStrict(body) {
+  let obj;
+  try {
+    obj = JSON.parse(body);
+  } catch (e) {
+    return { error: "invalid_json", detail: e instanceof Error ? e.message : String(e) };
+  }
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+    return { error: "invalid_json", detail: "not an object" };
+  }
+  const rec = obj;
+  for (const field of Object.keys(rec)) {
+    if (!["speech", "reason", "actionType", "actionData"].includes(field)) {
+      return { error: "invalid_json", detail: `unknown_top_level_field:${field}` };
+    }
+  }
+  if (typeof rec.actionType !== "string" || rec.actionType.length === 0) {
+    return { error: "missing_action_type" };
+  }
+  if (typeof rec.actionData !== "object" || rec.actionData === null || Array.isArray(rec.actionData)) {
+    return { error: "missing_action_data" };
+  }
+  return {
+    actionType: rec.actionType,
+    actionData: rec.actionData,
+    ...typeof rec.speech === "string" ? { speech: rec.speech } : {},
+    ...typeof rec.reason === "string" ? { reason: rec.reason } : {}
   };
 }
 function removeTrailingCommas(body) {
@@ -1068,7 +1350,7 @@ function inferRejectedModelAction(rawResponse, task) {
       validationReason: "no_model_output"
     };
   }
-  const parsed = parseAgentAction(rawResponse);
+  const parsed = isStructuredJsonTask(task) ? parseStrictJsonAgentAction(rawResponse) : parseAgentAction(rawResponse);
   if ("error" in parsed) {
     return {
       modelActionRejected: true,
@@ -1207,6 +1489,223 @@ function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/arena-voice-select.ts
+var FALLBACK_REASON = "\u672A\u89E3\u6790\u5230\u6A21\u578B\u97F3\u8272\u504F\u597D\uFF0C\u4EA4\u7531\u540E\u7AEF\u515C\u5E95\u9009\u62E9\u3002";
+var DEFAULT_REASON = "\u57FA\u4E8E\u6A21\u578B\u8F93\u51FA\u9009\u62E9\u5019\u9009\u73A9\u5BB6\u97F3\u8272\u3002";
+function parseArenaVoiceSelection(rawText, voiceOptions) {
+  const structured = parseStructuredVoiceSelection(rawText, voiceOptions);
+  if (structured) return structured;
+  const topVoiceIds = extractVoiceIdsFromText(rawText, voiceOptions);
+  return {
+    topVoiceIds,
+    reason: topVoiceIds.length > 0 ? DEFAULT_REASON : FALLBACK_REASON
+  };
+}
+async function submitArenaVoiceSelectCallback(input) {
+  const start = Date.now();
+  const rawHash = input.rawText ? sha256Hex(input.rawText) : "";
+  const rawPreview = rawResponsePreview(input.rawText) ?? "";
+  const selection = parseArenaVoiceSelection(input.rawText, input.meta.voiceOptions);
+  try {
+    if (!input.meta.callbackUrl || !input.token) {
+      input.log?.warn?.(
+        `[ARENA-VOICE] callback skipped eventId=${input.meta.eventId} reason=missing_callback_or_token rawHash=${rawHash} rawPreview=${rawPreview}`
+      );
+      return { ok: false, error: "missing_callback_or_token" };
+    }
+    const fetchImpl = input.fetchImpl ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      input.log?.warn?.(`[ARENA-VOICE] callback skipped eventId=${input.meta.eventId} reason=fetch_unavailable`);
+      return { ok: false, error: "fetch_unavailable" };
+    }
+    const response = await fetchImpl(input.meta.callbackUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${input.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        eventId: input.meta.eventId,
+        roomId: input.meta.roomId,
+        seatNumber: input.meta.seatNumber,
+        seatEpoch: input.meta.seatEpoch,
+        topVoiceIds: selection.topVoiceIds,
+        reason: selection.reason
+      })
+    });
+    const body = await readJsonObject2(response);
+    const data = isRecord5(body.data) ? body.data : body;
+    const accepted = data.accepted === true;
+    const result = { ok: response.ok, status: response.status, accepted };
+    const level = response.ok ? "info" : "warn";
+    input.log?.[level]?.(
+      `[ARENA-VOICE] callback status=${response.status} accepted=${accepted} eventId=${input.meta.eventId} roomId=${input.meta.roomId} seatEpoch=${input.meta.seatEpoch} selected=${selection.topVoiceIds.length} elapsedMs=${Date.now() - start} rawHash=${rawHash} rawPreview=${rawPreview}`
+    );
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    input.log?.warn?.(
+      `[ARENA-VOICE] callback failed eventId=${input.meta.eventId} roomId=${input.meta.roomId} seatEpoch=${input.meta.seatEpoch} elapsedMs=${Date.now() - start} err=${message} rawHash=${rawHash} rawPreview=${rawPreview}`
+    );
+    return { ok: false, error: message };
+  }
+}
+function createArenaVoiceSelectReplyCollector(input) {
+  const blocks = [];
+  let submitted = false;
+  const submit = input.submit ?? ((rawText) => submitArenaVoiceSelectCallback({
+    meta: input.meta,
+    token: input.token,
+    rawText,
+    log: input.log
+  }));
+  async function submitOnce(rawText, reason) {
+    if (submitted) return;
+    submitted = true;
+    const parsed = parseArenaVoiceSelection(rawText, input.meta.voiceOptions);
+    input.log?.info?.(
+      `[ARENA-VOICE] dispatch submit reason=${reason} eventId=${input.meta.eventId} roomId=${input.meta.roomId} seatEpoch=${input.meta.seatEpoch} blocks=${blocks.length} selected=${parsed.topVoiceIds.length}`
+    );
+    await submit(rawText);
+  }
+  return {
+    async deliver(text) {
+      if (submitted || !text) return;
+      blocks.push(text);
+      const full = blocks.join("");
+      const structured = parseStructuredVoiceSelection(full, input.meta.voiceOptions);
+      input.log?.info?.(
+        `[ARENA-VOICE] dispatch block eventId=${input.meta.eventId} roomId=${input.meta.roomId} seatEpoch=${input.meta.seatEpoch} blocks=${blocks.length} parsed=${structured?.topVoiceIds.length ? "true" : "false"}`
+      );
+      if (structured?.topVoiceIds.length) {
+        await submitOnce(full, "parsed");
+      }
+    },
+    async finalize() {
+      if (submitted) return;
+      await submitOnce(blocks.join(""), "final");
+    }
+  };
+}
+function parseStructuredVoiceSelection(rawText, voiceOptions) {
+  if (!rawText) return null;
+  const body = parseFirstJsonObject(rawText);
+  if (!body) return null;
+  const rawIds = Array.isArray(body.topVoiceIds) ? body.topVoiceIds : [];
+  const topVoiceIds = sanitizeVoiceIds(rawIds, voiceOptions);
+  const reason = normalizeReason(body.reason);
+  if (topVoiceIds.length === 0 && !reason) return null;
+  return {
+    topVoiceIds,
+    reason: reason || (topVoiceIds.length > 0 ? DEFAULT_REASON : FALLBACK_REASON)
+  };
+}
+function extractVoiceIdsFromText(rawText, voiceOptions) {
+  if (!rawText) return [];
+  const allowed = allowedVoiceIds(voiceOptions);
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  const regex = /\b\d{3,8}\b/g;
+  for (const match of rawText.matchAll(regex)) {
+    const voiceId = match[0];
+    if (!allowed.has(voiceId) || seen.has(voiceId)) continue;
+    seen.add(voiceId);
+    result.push(voiceId);
+    if (result.length >= 3) break;
+  }
+  return result;
+}
+function sanitizeVoiceIds(rawIds, voiceOptions) {
+  const allowed = allowedVoiceIds(voiceOptions);
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rawId of rawIds) {
+    const voiceId = typeof rawId === "string" ? rawId.trim() : "";
+    if (!voiceId || !allowed.has(voiceId) || seen.has(voiceId)) continue;
+    seen.add(voiceId);
+    result.push(voiceId);
+    if (result.length >= 3) break;
+  }
+  return result;
+}
+function allowedVoiceIds(voiceOptions) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!Array.isArray(voiceOptions)) return ids;
+  for (const option of voiceOptions) {
+    const voiceId = typeof option?.voiceId === "string" ? option.voiceId.trim() : "";
+    if (voiceId) ids.add(voiceId);
+  }
+  return ids;
+}
+function normalizeReason(value) {
+  if (typeof value !== "string") return "";
+  return value.replace(/\s+/g, " ").trim().slice(0, 160);
+}
+function parseFirstJsonObject(rawText) {
+  const direct = tryParseJsonObject(rawText.trim());
+  if (direct) return direct;
+  const candidates = extractJsonObjectCandidates(rawText);
+  for (const candidate of candidates) {
+    const parsed = tryParseJsonObject(candidate);
+    if (parsed) return parsed;
+  }
+  return null;
+}
+function extractJsonObjectCandidates(rawText) {
+  const candidates = [];
+  let start = -1;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < rawText.length; index += 1) {
+    const char = rawText[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{") {
+      if (depth === 0) start = index;
+      depth += 1;
+    } else if (char === "}" && depth > 0) {
+      depth -= 1;
+      if (depth === 0 && start >= 0) {
+        candidates.push(rawText.slice(start, index + 1));
+        start = -1;
+      }
+    }
+  }
+  return candidates;
+}
+async function readJsonObject2(response) {
+  try {
+    const body = await response.json();
+    return isRecord5(body) ? body : {};
+  } catch {
+    return {};
+  }
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function tryParseJsonObject(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return isRecord5(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
 // src/ws-client.ts
 import WebSocket from "ws";
 var CoolclawWsClient = class {
@@ -1269,11 +1768,13 @@ var CoolclawWsClient = class {
   async connect() {
     this.notifyState("connecting");
     const lastAckedSeq = await this.options.ackStore.getLastAckedSeq(this.options.accountKey);
+    const capabilities = this.options.capabilities ?? [WEREWOLF_STRUCTURED_ACTION_PROTOCOL_VERSION];
     const socket = new WebSocket(buildWsUrl(this.options.gatewayUrl, lastAckedSeq), {
       headers: {
         Authorization: `Bearer ${this.options.token}`,
         "X-CoolClaw-Agent-Id": this.options.agentId,
-        "X-CoolClaw-Plugin-Version": this.options.pluginVersion
+        "X-CoolClaw-Plugin-Version": this.options.pluginVersion,
+        "X-CoolClaw-Capabilities": capabilities.join(",")
       }
     });
     this.socket = socket;
@@ -1419,18 +1920,18 @@ var CoolclawWsClient = class {
   }
 };
 function readPingInterval(payload) {
-  if (!isRecord5(payload) || typeof payload.pingIntervalMs !== "number" || payload.pingIntervalMs <= 0) {
+  if (!isRecord6(payload) || typeof payload.pingIntervalMs !== "number" || payload.pingIntervalMs <= 0) {
     return void 0;
   }
   return payload.pingIntervalMs;
 }
 function readErrorMessage(payload) {
-  if (isRecord5(payload) && typeof payload.message === "string") {
+  if (isRecord6(payload) && typeof payload.message === "string") {
     return payload.message;
   }
   return "CoolClaw request failed";
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -1452,9 +1953,12 @@ function getPluginVersion() {
 }
 
 // src/channel.ts
+import { homedir as homedir3 } from "os";
+import path2 from "path";
 import {
   createChatChannelPlugin
 } from "openclaw/plugin-sdk/core";
+var productFlavor = activeFlavor();
 function createAccountStatusSink(params) {
   return (patch) => {
     params.setStatus({ accountId: params.accountId, ...patch });
@@ -1484,6 +1988,42 @@ function logAckFailure(params) {
   const target = params.target ? ` target=${params.target}` : "";
   params.log(`${params.channel} ack cleanup failed${target}: ${String(params.error)}`);
 }
+function buildStructuredActionRetryPrompt(renderedPrompt, reason) {
+  const reasonText = reason && reason.trim().length > 0 ? reason.trim() : "invalid_output";
+  return `${renderedPrompt}
+
+\u4E0A\u4E00\u6B21\u8F93\u51FA\u672A\u88AB\u72FC\u4EBA\u6740\u7ED3\u6784\u5316\u52A8\u4F5C\u534F\u8BAE\u63A5\u53D7\uFF0C\u5931\u8D25\u539F\u56E0\uFF1A${reasonText}\u3002
+\u8BF7\u91CD\u65B0\u4F5C\u7B54\uFF1A\u53EA\u8F93\u51FA\u4E00\u4E2A\u5B8C\u6574 JSON \u5BF9\u8C61\uFF0C\u4E0D\u8981\u8F93\u51FA Markdown\u3001\u89E3\u91CA\u6587\u5B57\u3001\u4EE3\u7801\u5757\u6216\u65E7\u52A8\u4F5C\u6807\u7B7E\u3002`;
+}
+function hasStructuredRetryBudget(deadlineEpochMs, nowEpochMs = Date.now(), safetyMarginMs = 1e3) {
+  if (!deadlineEpochMs || deadlineEpochMs <= 0) {
+    return true;
+  }
+  return nowEpochMs < deadlineEpochMs - Math.max(0, safetyMarginMs);
+}
+function shouldSubmitStructuredRejectedOutput(params) {
+  if (!params.structuredTask || params.gameSubmitted) {
+    return false;
+  }
+  if (params.modelActionRejected === false) {
+    return false;
+  }
+  if (params.fallbackReason?.startsWith("llm_action_submit_failed:")) {
+    return false;
+  }
+  return true;
+}
+function flattenForLog(text) {
+  return text.replace(/\r/g, "").replace(/\n/g, " \\n ");
+}
+function logStructuredActionValidation(params) {
+  const message = `[COOLCLAW-GAME-ACTION-VALIDATE] gameId=${params.meta.gameId} roomId=${params.meta.roomId} eventType=${params.meta.eventType} eventId=${params.meta.eventId} turnSeq=${params.meta.turnSeq} retryCount=${params.retryCount} submissionStatus=${params.submissionStatus} result=${params.result} reason=${params.reason ?? ""} actionType=${params.actionType ?? ""} promptPolicyVersion=${params.meta.promptPolicyVersion ?? ""} renderedPromptHash=${params.meta.renderedPromptHash ?? ""} rawResponseHash=${params.rawResponseHash ?? ""}`;
+  if (params.result === "pass") {
+    params.log?.info?.(message);
+  } else {
+    params.log?.warn?.(message);
+  }
+}
 function assertInboundRuntimeAvailable(runtime, context) {
   if (runtime?.channel) {
     return runtime.channel;
@@ -1498,7 +2038,10 @@ async function submitGameActionWithLog(action, meta, wsClient, log, source, rawR
     log?.error?.(`[GAME-ACTION] submit skipped: ws not connected eventId=${meta.eventId}`);
     return "failed";
   }
-  const responseHash = rawResponse && rawResponse.length > 0 ? sha256Hex(rawResponse) : void 0;
+  const responseHash = typeof rawResponse === "string" ? sha256Hex(rawResponse) : void 0;
+  const structured = isStructuredJsonTask(meta.agentTask);
+  const retryCount = auditMeta?.retryCount ?? 0;
+  const structuredProtocolVersion = auditMeta?.structuredProtocolVersion ?? meta.agentTask.actionProtocolVersion;
   log?.info?.(
     `[GAME-ACTION] submit start source=${source} eventType=${meta.eventType} actionType=${action.actionType} gameId=${meta.gameId} roomId=${meta.roomId} turnSeq=${meta.turnSeq} eventId=${meta.eventId} promptPolicyVersion=${meta.promptPolicyVersion ?? ""} renderedPromptHash=${meta.renderedPromptHash ?? ""} rawResponseHash=${responseHash ?? ""}`
   );
@@ -1519,10 +2062,20 @@ async function submitGameActionWithLog(action, meta, wsClient, log, source, rawR
       renderedPromptHash: meta.renderedPromptHash,
       parseSource: source,
       rawResponseHash: responseHash,
-      rawResponsePreview: rawResponse ? rawResponsePreview(rawResponse) : void 0,
+      rawResponsePreview: typeof rawResponse === "string" ? rawResponsePreview(rawResponse, Number.MAX_SAFE_INTEGER) : void 0,
       modelActionRejected: auditMeta?.modelActionRejected,
       modelActionType: auditMeta?.modelActionType,
-      validationReason: normalizeAuditText(auditMeta?.validationReason)
+      validationReason: normalizeAuditText(auditMeta?.validationReason),
+      submissionStatus: auditMeta?.submissionStatus ?? (structured ? "VALID" : void 0),
+      structuredProtocolVersion,
+      retryCount: structured ? retryCount : void 0,
+      firstRawResponseHash: auditMeta?.firstRawResponseHash ?? (structured ? responseHash : void 0),
+      firstModelActionType: auditMeta?.firstModelActionType,
+      firstValidationReason: normalizeAuditText(auditMeta?.firstValidationReason),
+      retryRawResponseHash: auditMeta?.retryRawResponseHash,
+      retryValidationReason: normalizeAuditText(auditMeta?.retryValidationReason),
+      speech: action.speech,
+      reason: action.reason
     });
     if (response.uncertain === true) {
       log?.warn?.(
@@ -1548,6 +2101,128 @@ async function submitGameActionWithLog(action, meta, wsClient, log, source, rawR
     return "failed";
   }
 }
+async function submitRejectedOutputWithLog(params) {
+  const rawResponse = params.rawResponse ?? "";
+  const rawHash = sha256Hex(rawResponse);
+  const retryCount = params.auditMeta?.retryCount ?? 0;
+  params.log?.warn?.(
+    `[COOLCLAW-GAME-ACTION-VALIDATE] gameId=${params.meta.gameId} roomId=${params.meta.roomId} eventType=${params.meta.eventType} eventId=${params.meta.eventId} turnSeq=${params.meta.turnSeq} retryCount=${retryCount} submissionStatus=REJECTED_OUTPUT result=submit reason=${params.reason} actionType=INVALID_OUTPUT promptPolicyVersion=${params.meta.promptPolicyVersion ?? ""} renderedPromptHash=${params.meta.renderedPromptHash ?? ""} rawResponseHash=${rawHash ?? ""}`
+  );
+  return submitGameActionWithLog(
+    { actionType: "INVALID_OUTPUT", actionData: {} },
+    params.meta,
+    params.wsClient,
+    params.log,
+    "rejected_output",
+    rawResponse,
+    {
+      modelActionRejected: true,
+      validationReason: params.reason,
+      submissionStatus: "REJECTED_OUTPUT",
+      structuredProtocolVersion: params.meta.agentTask.actionProtocolVersion,
+      retryCount,
+      firstRawResponseHash: params.auditMeta?.firstRawResponseHash ?? rawHash,
+      firstModelActionType: params.auditMeta?.firstModelActionType,
+      firstValidationReason: params.auditMeta?.firstValidationReason,
+      retryRawResponseHash: params.auditMeta?.retryRawResponseHash ?? (retryCount > 0 ? rawHash : void 0),
+      retryValidationReason: params.auditMeta?.retryValidationReason ?? (retryCount > 0 ? params.reason : void 0)
+    }
+  );
+}
+async function submitStructuredFinalActionWithLog(params) {
+  const rawResponse = params.rawResponse ?? "";
+  const rawHash = sha256Hex(rawResponse);
+  if (rawResponse.trim().length === 0) {
+    logStructuredActionValidation({
+      log: params.log,
+      meta: params.meta,
+      retryCount: params.retryCount,
+      submissionStatus: "REJECTED_OUTPUT",
+      result: "reject",
+      reason: "no_model_output",
+      rawResponseHash: rawHash
+    });
+    return { submitted: false, reason: "no_model_output", rawHash };
+  }
+  const parsed = parseStrictJsonAgentAction(rawResponse);
+  if ("error" in parsed) {
+    const reason = parsed.error === "invalid_json" ? `invalid_json:${parsed.detail}` : parsed.error;
+    logStructuredActionValidation({
+      log: params.log,
+      meta: params.meta,
+      retryCount: params.retryCount,
+      submissionStatus: "REJECTED_OUTPUT",
+      result: "reject",
+      reason,
+      rawResponseHash: rawHash
+    });
+    return {
+      submitted: false,
+      reason,
+      rawHash
+    };
+  }
+  const validation = validateAgentAction(parsed, params.meta.agentTask);
+  if (!validation.ok) {
+    logStructuredActionValidation({
+      log: params.log,
+      meta: params.meta,
+      retryCount: params.retryCount,
+      submissionStatus: "REJECTED_OUTPUT",
+      result: "reject",
+      reason: validation.reason,
+      actionType: parsed.actionType,
+      rawResponseHash: rawHash
+    });
+    return {
+      submitted: false,
+      reason: validation.reason,
+      rawHash,
+      modelActionType: parsed.actionType
+    };
+  }
+  logStructuredActionValidation({
+    log: params.log,
+    meta: params.meta,
+    retryCount: params.retryCount,
+    submissionStatus: "VALID",
+    result: "pass",
+    reason: validation.repairReason,
+    actionType: validation.action.actionType,
+    rawResponseHash: rawHash
+  });
+  const status = await submitGameActionWithLog(
+    validation.action,
+    params.meta,
+    params.wsClient,
+    params.log,
+    "llm",
+    rawResponse,
+    {
+      ...params.auditMeta,
+      modelActionRejected: false,
+      modelActionType: validation.action.actionType,
+      validationReason: validation.repairReason,
+      submissionStatus: "VALID",
+      structuredProtocolVersion: params.meta.agentTask.actionProtocolVersion,
+      retryCount: params.retryCount,
+      firstRawResponseHash: params.auditMeta?.firstRawResponseHash ?? rawHash,
+      firstModelActionType: params.auditMeta?.firstModelActionType,
+      firstValidationReason: params.auditMeta?.firstValidationReason,
+      retryRawResponseHash: params.retryCount > 0 ? params.auditMeta?.retryRawResponseHash ?? rawHash : params.auditMeta?.retryRawResponseHash,
+      retryValidationReason: params.retryCount > 0 ? params.auditMeta?.retryValidationReason ?? validation.repairReason : params.auditMeta?.retryValidationReason
+    }
+  );
+  return {
+    submitted: status === "submitted" || status === "uncertain",
+    status,
+    reason: status === "failed" ? `llm_action_submit_failed:${validation.action.actionType}` : void 0,
+    rawHash,
+    modelActionType: validation.action.actionType,
+    validationReason: validation.repairReason,
+    validAction: true
+  };
+}
 async function submitBackendFallbackWithLog(params) {
   const fb = backendFallbackAction(params.meta.agentTask);
   if (!fb) {
@@ -1587,7 +2262,7 @@ function isNoReplyText(text) {
   return lastLine ? noReplyTokens.has(lastLine) : false;
 }
 function shouldSuppressCoolclawTextDelivery(envelope) {
-  return envelope.metadata?.gameEvent === true || isArenaReportShareEnvelope(envelope) || isArenaModelQueryEnvelope(envelope);
+  return envelope.metadata?.gameEvent === true || isArenaReportShareEnvelope(envelope) || isArenaModelQueryEnvelope(envelope) || isArenaVoiceSelectEnvelope(envelope);
 }
 async function finalizeArenaModelQueryAfterDispatchError(params) {
   if (!params.collector) {
@@ -1609,19 +2284,19 @@ function clearRuntimeClient(accountKey) {
   runtimeClients.delete(accountKey);
 }
 function extractAccountFromConfig(cfg, accountId) {
-  const coolclawSection = cfg.channels?.coolclaw;
-  const accounts = coolclawSection?.accounts;
+  const channelSection = cfg.channels?.[productFlavor.channelId];
+  const accounts = channelSection?.accounts;
   return accounts?.[accountId ?? "default"] ?? {};
 }
 var coolclawChannelPlugin = createChatChannelPlugin({
   base: {
-    id: "coolclaw",
+    id: productFlavor.channelId,
     meta: {
-      id: "coolclaw",
-      label: "CoolClaw",
-      selectionLabel: "CoolClaw",
-      docsPath: "/plugins/coolclaw",
-      blurb: "Connect OpenClaw to the CoolClaw/Riddle chat platform."
+      id: productFlavor.channelId,
+      label: productFlavor.displayName,
+      selectionLabel: productFlavor.displayName,
+      docsPath: `/plugins/${productFlavor.channelId}`,
+      blurb: `Connect OpenClaw to the ${productFlavor.displayName} chat platform.`
     },
     capabilities: {
       chatTypes: ["direct", "group"],
@@ -1636,15 +2311,15 @@ var coolclawChannelPlugin = createChatChannelPlugin({
     },
     agentPrompt: {
       messageToolHints: () => [
-        "To send a message on CoolClaw/Riddle, use the message tool with action='send' and set 'to' to a CoolClaw target like 'coolclaw:human:<userId>', 'coolclaw:agent:<agentId>', or 'coolclaw:group:<groupId>'.",
+        `To send a message on ${productFlavor.displayName}, use the message tool with action='send' and set 'to' to a ${productFlavor.displayName} target like '${productFlavor.targetPrefix}:human:<userId>', '${productFlavor.targetPrefix}:agent:<agentId>', or '${productFlavor.targetPrefix}:group:<groupId>'.`,
         "To send an image or file, use the message tool with action='send' and set 'media' to a local file path or a remote URL.",
-        "When sending a message to a CoolClaw group, the agent will only reply if it was mentioned in the group message.",
-        "When creating a cron job for CoolClaw, set delivery.to to the target CoolClaw ID and delivery.accountId to the current accountId."
+        `When sending a message to a ${productFlavor.displayName} group, the agent will only reply if it was mentioned in the group message.`,
+        `When creating a cron job for ${productFlavor.displayName}, set delivery.to to the target ${productFlavor.displayName} ID and delivery.accountId to the current accountId.`
       ]
     },
     config: {
       listAccountIds(cfg) {
-        return Object.keys(cfg.channels?.coolclaw?.accounts ?? {});
+        return Object.keys(cfg.channels?.[productFlavor.channelId]?.accounts ?? {});
       },
       resolveAccount(cfg, accountId) {
         return extractAccountFromConfig(cfg, accountId);
@@ -1676,9 +2351,9 @@ var coolclawChannelPlugin = createChatChannelPlugin({
       async resolveTargets({ inputs }) {
         return inputs.map((input) => {
           try {
-            const normalized = normalizeCoolclawTarget(input);
+            const normalized = normalizeCoolclawTarget(input, productFlavor);
             const [, type, id] = normalized.split(":");
-            parseCoolclawTarget(normalized);
+            parseCoolclawTarget(normalized, productFlavor);
             return { input, resolved: true, id: normalized, name: `${type}:${id}` };
           } catch (error) {
             return { input, resolved: false, note: error instanceof Error ? error.message : String(error) };
@@ -1689,23 +2364,23 @@ var coolclawChannelPlugin = createChatChannelPlugin({
     messaging: {
       normalizeTarget(raw) {
         try {
-          const normalized = normalizeCoolclawTarget(raw);
-          parseCoolclawTarget(normalized);
+          const normalized = normalizeCoolclawTarget(raw, productFlavor);
+          parseCoolclawTarget(normalized, productFlavor);
           return normalized;
         } catch {
           return void 0;
         }
       },
       inferTargetChatType({ to }) {
-        return inferCoolclawTargetChatType(to);
+        return inferCoolclawTargetChatType(to, productFlavor);
       },
       targetResolver: {
-        hint: "Use coolclaw:human:<id>, coolclaw:agent:<id>, or coolclaw:group:<id>.",
+        hint: `Use ${productFlavor.targetPrefix}:human:<id>, ${productFlavor.targetPrefix}:agent:<id>, or ${productFlavor.targetPrefix}:group:<id>.`,
         looksLikeId(raw, normalized) {
-          return isCoolclawTargetId(raw, normalized);
+          return isCoolclawTargetId(raw, normalized, productFlavor);
         },
         resolveTarget({ input, normalized, preferredKind }) {
-          return resolveCoolclawMessagingTarget(normalized || input, preferredKind);
+          return resolveCoolclawMessagingTarget(normalized || input, preferredKind, productFlavor);
         }
       }
     },
@@ -1714,17 +2389,19 @@ var coolclawChannelPlugin = createChatChannelPlugin({
         const account = coolclawChannelPlugin.config.resolveAccount(ctx.cfg, ctx.accountId);
         const token = await resolveAccountToken(account);
         if (!account.gatewayUrl || !account.agentId || !token) {
-          ctx.log?.error(`[${ctx.accountId}] CoolClaw account is not fully configured`);
+          ctx.log?.error(`[${ctx.accountId}] ${productFlavor.displayName} account is not fully configured`);
           return;
         }
-        const accountKey = `coolclaw:${ctx.accountId ?? "default"}`;
-        const ackStore = new FileAckStore();
+        const accountKey = `${productFlavor.channelId}:${ctx.accountId ?? "default"}`;
+        const ackStore = new FileAckStore(
+          path2.join(homedir3(), ".openclaw", "extensions", productFlavor.channelId, ".ack-store")
+        );
         const statusSink = createAccountStatusSink({
           accountId: ctx.accountId,
           setStatus: ctx.setStatus
         });
         statusSink({ statusState: "connecting" });
-        ctx.log?.info(`[${ctx.accountId}] starting CoolClaw provider (${account.gatewayUrl})`);
+        ctx.log?.info(`[${ctx.accountId}] starting ${productFlavor.displayName} provider (${account.gatewayUrl})`);
         await runPassiveAccountLifecycle({
           abortSignal: ctx.abortSignal,
           start: async () => {
@@ -1748,20 +2425,35 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                       const isGameEvent = envelope.metadata?.gameEvent === true;
                       const isArenaReportShare = isArenaReportShareEnvelope(envelope);
                       const isArenaModelQuery = isArenaModelQueryEnvelope(envelope);
+                      const isArenaVoiceSelect = isArenaVoiceSelectEnvelope(envelope);
                       const suppressChatTextDelivery = shouldSuppressCoolclawTextDelivery(envelope);
                       const gameMeta = isGameEvent ? envelope.metadata : null;
                       const modelQueryMeta = isArenaModelQuery ? envelope.metadata : null;
+                      const voiceSelectMeta = isArenaVoiceSelect ? envelope.metadata : null;
                       let gameSubmitted = false;
                       let gameFallbackReason = null;
                       let gameModelActionType;
                       let gameValidationReason;
                       let gameModelActionRejected;
+                      let gameReplyAttempt = 0;
+                      let gameFirstRawResponseHash;
+                      let gameFirstModelActionType;
+                      let gameFirstValidationReason;
+                      let gameRetryRawResponseHash;
+                      let gameRetryValidationReason;
+                      let gameBaseReplyContext = null;
+                      let dispatchGameReply = null;
                       const gameBuffer = [];
                       const modelQueryCollector = modelQueryMeta ? createArenaModelQueryReplyCollector({
                         meta: modelQueryMeta,
                         token,
                         log: ctx.log
                       }) : null;
+                      const voiceSelectCollector = voiceSelectMeta ? createArenaVoiceSelectReplyCollector({
+                        meta: voiceSelectMeta,
+                        token,
+                        log: ctx.log
+                      }) : null;
                       if (isGameEvent && gameMeta) {
                         ctx.log?.info?.(
                           `[GAME-TASK] dispatch start gameId=${gameMeta.gameId} roomId=${gameMeta.roomId} eventType=${gameMeta.eventType} eventId=${gameMeta.eventId} promptPolicyVersion=${gameMeta.promptPolicyVersion ?? ""} renderedPromptHash=${gameMeta.renderedPromptHash ?? ""} conversationId=${envelope.conversationId}`
@@ -1778,6 +2470,17 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                           `[ARENA-MODEL] inbound eventId=${modelQueryMeta.eventId} traceId=${modelQueryMeta.traceId ?? ""} roomId=${modelQueryMeta.roomId} seatEpoch=${modelQueryMeta.seatEpoch} callbackHost=${callbackHost} conversationId=${envelope.conversationId}`
                         );
                       }
+                      if (voiceSelectMeta) {
+                        let callbackHost = "";
+                        try {
+                          callbackHost = new URL(voiceSelectMeta.callbackUrl).host;
+                        } catch {
+                          callbackHost = "invalid";
+                        }
+                        ctx.log?.info?.(
+                          `[ARENA-VOICE] inbound eventId=${voiceSelectMeta.eventId} traceId=${voiceSelectMeta.traceId ?? ""} roomId=${voiceSelectMeta.roomId} seatEpoch=${voiceSelectMeta.seatEpoch} callbackHost=${callbackHost} conversationId=${envelope.conversationId}`
+                        );
+                      }
                       const runtime = getCoolclawRuntime();
                       let runtimeChannel;
                       try {
@@ -1787,8 +2490,25 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                         });
                       } catch (err) {
                         logInboundDrop({ log: ctx.log?.warn?.bind(ctx.log) ?? (() => {
-                        }), channel: "coolclaw", reason: "runtime not available; skipping dispatch" });
+                        }), channel: productFlavor.channelId, reason: "runtime not available; skipping dispatch" });
                         if (isGameEvent && gameMeta) {
+                          if (isStructuredJsonTask(gameMeta.agentTask)) {
+                            const submitted2 = await submitRejectedOutputWithLog({
+                              meta: gameMeta,
+                              wsClient,
+                              log: ctx.log,
+                              reason: "runtime_not_available",
+                              rawResponse: "",
+                              auditMeta: {
+                                retryCount: 0,
+                                firstValidationReason: "runtime_not_available"
+                              }
+                            });
+                            if (submitted2 === "failed") {
+                              throw new Error("game rejected-output submit failed: runtime_not_available");
+                            }
+                            return;
+                          }
                           const submitted = await submitBackendFallbackWithLog({
                             meta: gameMeta,
                             wsClient,
@@ -1809,6 +2529,15 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                           });
                           return;
                         }
+                        if (voiceSelectMeta) {
+                          await submitArenaVoiceSelectCallback({
+                            meta: voiceSelectMeta,
+                            token,
+                            rawText: "",
+                            log: ctx.log
+                          });
+                          return;
+                        }
                         throw err;
                       }
                       try {
@@ -1821,7 +2550,7 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                         }
                         const route = await runtimeChannel.routing.resolveAgentRoute({
                           cfg: ctx.cfg,
-                          channel: "coolclaw",
+                          channel: productFlavor.channelId,
                           accountId: ctx.accountId,
                           peer
                         });
@@ -1834,18 +2563,18 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                           ctx.cfg.session?.store,
                           { agentId: route.agentId }
                         );
-                        const senderLabel = envelope.sender ? `${envelope.sender.userType.toLowerCase()}:${envelope.sender.userId}` : isGameEvent ? `game:${gameMeta.gameId}` : modelQueryMeta ? `arena-model:${modelQueryMeta.roomId}` : "unknown";
+                        const senderLabel = envelope.sender ? `${envelope.sender.userType.toLowerCase()}:${envelope.sender.userId}` : isGameEvent ? `game:${gameMeta.gameId}` : modelQueryMeta ? `arena-model:${modelQueryMeta.roomId}` : voiceSelectMeta ? `arena-voice:${voiceSelectMeta.roomId}` : "unknown";
                         let deliveryTarget;
                         if (envelope.group) {
-                          deliveryTarget = `coolclaw:group:${envelope.group.groupId}`;
+                          deliveryTarget = `${productFlavor.targetPrefix}:group:${envelope.group.groupId}`;
                         } else if (envelope.sender) {
-                          deliveryTarget = `coolclaw:${envelope.sender.userType.toLowerCase()}:${envelope.sender.userId}`;
-                        } else if (isGameEvent || isArenaModelQuery) {
-                          deliveryTarget = `coolclaw:agent:${account.agentId}`;
+                          deliveryTarget = `${productFlavor.targetPrefix}:${envelope.sender.userType.toLowerCase()}:${envelope.sender.userId}`;
+                        } else if (isGameEvent || isArenaModelQuery || isArenaVoiceSelect) {
+                          deliveryTarget = `${productFlavor.targetPrefix}:agent:${account.agentId}`;
                         } else {
-                          deliveryTarget = normalizeCoolclawTarget(envelope.conversationId);
+                          deliveryTarget = normalizeCoolclawTarget(envelope.conversationId, productFlavor);
                         }
-                        const bodyForAgent = buildBodyForAgent(envelope);
+                        const bodyForAgent = buildBodyForAgent(envelope, productFlavor);
                         if (typeof runtimeChannel.reply?.finalizeInboundContext !== "function") {
                           throw new Error(
                             "CoolClaw requires runtime.channel.reply.finalizeInboundContext. Please upgrade OpenClaw to >=2026.3.22."
@@ -1866,32 +2595,33 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                           BodyForAgent: bodyForAgent,
                           RawBody: envelope.text,
                           CommandBody: envelope.text,
-                          From: `coolclaw:${senderLabel}`,
+                          From: `${productFlavor.targetPrefix}:${senderLabel}`,
                           To: deliveryTarget,
                           SessionKey: route.sessionKey,
                           AccountId: ctx.accountId,
                           ChatType: isGroup ? "channel" : "direct",
                           CommandAuthorized: true,
-                          Provider: "coolclaw",
-                          Surface: "coolclaw",
-                          Channel: "coolclaw",
+                          Provider: productFlavor.channelId,
+                          Surface: productFlavor.channelId,
+                          Channel: productFlavor.channelId,
                           Peer: peer,
                           WasMentioned: envelope.shouldReply,
                           Mentioned: envelope.shouldReply
                         });
+                        gameBaseReplyContext = ctxPayload;
                         const sessionKey = ctxPayload.SessionKey ?? route.sessionKey;
                         const mainSessionKey = route.mainSessionKey;
                         await runtimeChannel.session.recordInboundSession({
                           storePath,
                           sessionKey,
                           ctx: ctxPayload,
-                          updateLastRoute: mainSessionKey && mainSessionKey !== sessionKey ? { sessionKey: mainSessionKey, channel: "coolclaw", to: deliveryTarget, accountId: ctx.accountId ?? void 0 } : void 0,
+                          updateLastRoute: mainSessionKey && mainSessionKey !== sessionKey ? { sessionKey: mainSessionKey, channel: productFlavor.channelId, to: deliveryTarget, accountId: ctx.accountId ?? void 0 } : void 0,
                           onRecordError: (err) => {
                             ctx.log?.warn(`recordInboundSession failed: ${err instanceof Error ? err.message : String(err)}`);
                           }
                         });
-                        await runtimeChannel.reply.dispatchReplyWithBufferedBlockDispatcher({
-                          ctx: ctxPayload,
+                        dispatchGameReply = async (replyCtxPayload) => runtimeChannel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                          ctx: replyCtxPayload,
                           cfg: ctx.cfg,
                           // 群聊强制走 automatic：CoolClaw 群聊业务语义就是 @ 即回，
                           // 而 OpenClaw 默认对 group/channel 走 message_tool_only，
@@ -1908,11 +2638,17 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                                 await modelQueryCollector.deliver(replyText);
                                 return;
                               }
+                              if (voiceSelectCollector) {
+                                await voiceSelectCollector.deliver(replyText);
+                                return;
+                              }
                               if (isGameEvent && gameMeta) {
                                 if (gameSubmitted) return;
                                 gameBuffer.push(String(payload.text));
+                                const structuredTask = isStructuredJsonTask(gameMeta.agentTask);
+                                if (structuredTask) return;
                                 const full = gameBuffer.join("");
-                                const parsed = parseAgentAction(full);
+                                const parsed = structuredTask ? parseStrictJsonAgentAction(full) : parseAgentAction(full);
                                 if ("error" in parsed) return;
                                 const validation = validateAgentAction(parsed, gameMeta.agentTask);
                                 if (!validation.ok) {
@@ -1920,11 +2656,30 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                                   gameModelActionType = parsed.actionType;
                                   gameValidationReason = validation.reason;
                                   gameFallbackReason = validation.reason;
+                                  if (structuredTask) {
+                                    const rawHash2 = sha256Hex(full);
+                                    if (gameReplyAttempt === 0) {
+                                      gameFirstRawResponseHash = rawHash2;
+                                      gameFirstModelActionType = parsed.actionType;
+                                      gameFirstValidationReason = validation.reason;
+                                    } else {
+                                      gameRetryRawResponseHash = rawHash2;
+                                      gameRetryValidationReason = validation.reason;
+                                    }
+                                  }
                                   ctx.log?.warn?.(
-                                    `[GAME-ACTION] rejected model action reason=${validation.reason} actionType=${parsed.actionType} eventType=${gameMeta.eventType} eventId=${gameMeta.eventId} promptPolicyVersion=${gameMeta.promptPolicyVersion ?? ""} renderedPromptHash=${gameMeta.renderedPromptHash ?? ""} rawResponseHash=${sha256Hex(full)}`
+                                    `[COOLCLAW-GAME-ACTION-VALIDATE] gameId=${gameMeta.gameId} roomId=${gameMeta.roomId} eventType=${gameMeta.eventType} eventId=${gameMeta.eventId} turnSeq=${gameMeta.turnSeq} retryCount=${gameReplyAttempt} submissionStatus=REJECTED_OUTPUT result=reject reason=${validation.reason} actionType=${parsed.actionType} promptPolicyVersion=${gameMeta.promptPolicyVersion ?? ""} renderedPromptHash=${gameMeta.renderedPromptHash ?? ""} rawResponseHash=${sha256Hex(full)}`
                                   );
                                   return;
                                 }
+                                if (structuredTask) {
+                                  gameModelActionRejected = false;
+                                  gameModelActionType = validation.action.actionType;
+                                  gameValidationReason = validation.repairReason;
+                                  gameFallbackReason = null;
+                                  return;
+                                }
+                                const rawHash = sha256Hex(full);
                                 const submitted = await submitGameActionWithLog(
                                   validation.action,
                                   gameMeta,
@@ -1935,7 +2690,15 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                                   {
                                     modelActionRejected: false,
                                     modelActionType: validation.action.actionType,
-                                    validationReason: validation.repairReason
+                                    validationReason: validation.repairReason,
+                                    submissionStatus: structuredTask ? "VALID" : void 0,
+                                    structuredProtocolVersion: structuredTask ? gameMeta.agentTask.actionProtocolVersion : void 0,
+                                    retryCount: structuredTask ? gameReplyAttempt : void 0,
+                                    firstRawResponseHash: structuredTask ? gameFirstRawResponseHash ?? rawHash : void 0,
+                                    firstModelActionType: structuredTask ? gameFirstModelActionType : void 0,
+                                    firstValidationReason: structuredTask ? gameFirstValidationReason : void 0,
+                                    retryRawResponseHash: structuredTask && gameReplyAttempt > 0 ? rawHash : void 0,
+                                    retryValidationReason: structuredTask && gameReplyAttempt > 0 ? validation.repairReason : void 0
                                   }
                                 );
                                 if (submitted === "submitted" || submitted === "uncertain") {
@@ -1952,17 +2715,17 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                                 return;
                               }
                               if (suppressChatTextDelivery) {
-                                ctx.log?.error?.(`[ARENA-MODEL] chat delivery blocked eventId=${envelope.metadata.eventId ?? ""}`);
+                                ctx.log?.error?.(`[ARENA-CALLBACK] chat delivery blocked eventId=${envelope.metadata.eventId ?? ""}`);
                                 return;
                               }
                               try {
                                 let replyTarget;
                                 if (envelope.group) {
-                                  replyTarget = `coolclaw:group:${envelope.group.groupId}`;
+                                  replyTarget = `${productFlavor.targetPrefix}:group:${envelope.group.groupId}`;
                                 } else if (envelope.sender) {
-                                  replyTarget = `coolclaw:${envelope.sender.userType.toLowerCase()}:${envelope.sender.userId}`;
+                                  replyTarget = `${productFlavor.targetPrefix}:${envelope.sender.userType.toLowerCase()}:${envelope.sender.userId}`;
                                 } else {
-                                  replyTarget = normalizeCoolclawTarget(envelope.conversationId);
+                                  replyTarget = normalizeCoolclawTarget(envelope.conversationId, productFlavor);
                                 }
                                 await sendText({ client: wsClient, target: replyTarget, text: replyText });
                               } catch (err) {
@@ -1974,6 +2737,7 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                             }
                           }
                         });
+                        await dispatchGameReply(ctxPayload);
                         if (isGameEvent && gameMeta && !gameSubmitted) {
                           if (!gameFallbackReason) {
                             gameFallbackReason = "no_valid_action_in_llm_output";
@@ -1982,6 +2746,9 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                         if (modelQueryCollector) {
                           await modelQueryCollector.finalize();
                         }
+                        if (voiceSelectCollector) {
+                          await voiceSelectCollector.finalize();
+                        }
                       } catch (err) {
                         const errMsg = err instanceof Error ? err.message : String(err);
                         ctx.log?.error(`Inbound dispatch error: ${errMsg}`);
@@ -1993,14 +2760,100 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                         })) {
                           return;
                         }
+                        if (voiceSelectCollector) {
+                          ctx.log?.warn?.(`[ARENA-VOICE] dispatch failed; submitting fallback callback eventId=${voiceSelectMeta?.eventId ?? ""} err=${errMsg}`);
+                          await voiceSelectCollector.finalize();
+                          return;
+                        }
                         if (isGameEvent && gameMeta && !gameSubmitted) {
                           gameFallbackReason = `dispatch_error: ${errMsg}`;
                         }
                       } finally {
+                        const submitFinalStructuredGameAction = async () => {
+                          if (!isGameEvent || !gameMeta || gameSubmitted || !isStructuredJsonTask(gameMeta.agentTask)) {
+                            return false;
+                          }
+                          const rawResponse = gameBuffer.join("");
+                          const result = await submitStructuredFinalActionWithLog({
+                            rawResponse,
+                            meta: gameMeta,
+                            wsClient,
+                            log: ctx.log,
+                            retryCount: gameReplyAttempt,
+                            auditMeta: {
+                              retryCount: gameReplyAttempt,
+                              firstRawResponseHash: gameFirstRawResponseHash,
+                              firstModelActionType: gameFirstModelActionType,
+                              firstValidationReason: gameFirstValidationReason,
+                              retryRawResponseHash: gameRetryRawResponseHash,
+                              retryValidationReason: gameRetryValidationReason
+                            }
+                          });
+                          if (result.submitted) {
+                            gameSubmitted = true;
+                            gameModelActionRejected = false;
+                            gameModelActionType = result.modelActionType;
+                            gameValidationReason = result.validationReason;
+                            gameFallbackReason = null;
+                            return true;
+                          }
+                          gameModelActionRejected = result.validAction ? false : true;
+                          gameModelActionType = result.modelActionType;
+                          gameValidationReason = result.reason ?? result.validationReason;
+                          gameFallbackReason = result.reason ?? gameFallbackReason ?? "invalid_output";
+                          if (rawResponse.trim().length > 0) {
+                            const rawHash = result.rawHash ?? sha256Hex(rawResponse);
+                            if (gameReplyAttempt === 0) {
+                              gameFirstRawResponseHash = gameFirstRawResponseHash ?? rawHash;
+                              gameFirstModelActionType = gameFirstModelActionType ?? result.modelActionType;
+                              gameFirstValidationReason = gameFirstValidationReason ?? gameValidationReason;
+                            } else {
+                              gameRetryRawResponseHash = gameRetryRawResponseHash ?? rawHash;
+                              gameRetryValidationReason = gameRetryValidationReason ?? gameValidationReason;
+                            }
+                          }
+                          return false;
+                        };
+                        await submitFinalStructuredGameAction();
+                        if (isGameEvent && gameMeta && !gameSubmitted && gameReplyAttempt === 0 && isStructuredJsonTask(gameMeta.agentTask) && dispatchGameReply && gameBaseReplyContext && hasStructuredRetryBudget(gameMeta.deadlineEpochMs) && Math.max(0, gameMeta.agentTask.retryPolicy?.maxRetries ?? 0) > 0) {
+                          const firstRawResponse = gameBuffer.join("");
+                          if (firstRawResponse.trim().length > 0) {
+                            const firstInferred = inferRejectedModelAction(firstRawResponse, gameMeta.agentTask);
+                            if (gameModelActionRejected === false || firstInferred.validationReason === "valid_action_not_submitted") {
+                              ctx.log?.warn?.(
+                                `[GAME-ACTION] structured retry skipped for valid unsubmitted action eventId=${gameMeta.eventId} turnSeq=${gameMeta.turnSeq} reason=${gameFallbackReason ?? firstInferred.validationReason ?? "submit_failed"}`
+                              );
+                            } else {
+                              const firstRawHash = sha256Hex(firstRawResponse);
+                              gameFirstRawResponseHash = gameFirstRawResponseHash ?? firstRawHash;
+                              gameFirstModelActionType = gameFirstModelActionType ?? firstInferred.modelActionType;
+                              gameFirstValidationReason = gameFirstValidationReason ?? gameValidationReason ?? firstInferred.validationReason;
+                              const retryReason = gameFirstValidationReason ?? firstInferred.validationReason ?? "invalid_output";
+                              ctx.log?.warn?.(
+                                `[GAME-ACTION] structured retry start eventId=${gameMeta.eventId} turnSeq=${gameMeta.turnSeq} reason=${retryReason} firstRawResponseHash=${firstRawHash}`
+                              );
+                              gameReplyAttempt = 1;
+                              gameBuffer.length = 0;
+                              gameFallbackReason = null;
+                              gameModelActionRejected = void 0;
+                              gameModelActionType = void 0;
+                              gameValidationReason = void 0;
+                              const retryPrompt = buildStructuredActionRetryPrompt(envelope.text, retryReason);
+                              await dispatchGameReply({
+                                ...gameBaseReplyContext,
+                                Body: retryPrompt,
+                                BodyForAgent: retryPrompt,
+                                RawBody: retryPrompt,
+                                CommandBody: retryPrompt
+                              });
+                              await submitFinalStructuredGameAction();
+                            }
+                          }
+                        }
                         if (isGameEvent && gameMeta) {
                           const rawResponse = gameBuffer.join("");
                           ctx.log?.info?.(
-                            `[GAME-TASK] model-output eventId=${gameMeta.eventId} promptPolicyVersion=${gameMeta.promptPolicyVersion ?? ""} renderedPromptHash=${gameMeta.renderedPromptHash ?? ""} rawHash=${rawResponse ? sha256Hex(rawResponse) : ""} rawPreview=${rawResponsePreview(rawResponse) ?? ""}`
+                            `[GAME-TASK] model-output eventId=${gameMeta.eventId} turnSeq=${gameMeta.turnSeq} retryAttempt=${gameReplyAttempt} promptPolicyVersion=${gameMeta.promptPolicyVersion ?? ""} renderedPromptHash=${gameMeta.renderedPromptHash ?? ""} rawHash=${rawResponse ? sha256Hex(rawResponse) : ""} rawResponseText=${rawResponse ? flattenForLog(rawResponse) : ""}`
                           );
                         }
                         if (isGameEvent && gameMeta && !gameSubmitted) {
@@ -2013,6 +2866,55 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                             if (!gameFallbackReason || gameFallbackReason === "no_valid_action_in_llm_output") {
                               gameFallbackReason = gameValidationReason ?? inferred.validationReason ?? gameFallbackReason;
                             }
+                            if (isStructuredJsonTask(gameMeta.agentTask)) {
+                              if (rawResponse.trim().length === 0) {
+                                gameFallbackReason = "no_model_output";
+                                gameValidationReason = gameValidationReason ?? "no_model_output";
+                              }
+                              if (gameReplyAttempt > 0 && rawResponse.trim().length > 0) {
+                                gameRetryRawResponseHash = gameRetryRawResponseHash ?? sha256Hex(rawResponse);
+                                gameRetryValidationReason = gameRetryValidationReason ?? gameValidationReason ?? inferred.validationReason;
+                              }
+                              const rawHashForAudit = rawResponse.trim().length > 0 ? sha256Hex(rawResponse) : void 0;
+                              const rejectedOutputReason = gameFallbackReason ?? gameValidationReason ?? inferred.validationReason ?? "invalid_json";
+                              if (!shouldSubmitStructuredRejectedOutput({
+                                structuredTask: true,
+                                gameSubmitted,
+                                modelActionRejected: gameModelActionRejected,
+                                fallbackReason: rejectedOutputReason
+                              })) {
+                                logStructuredActionValidation({
+                                  log: ctx.log,
+                                  meta: gameMeta,
+                                  retryCount: gameReplyAttempt,
+                                  submissionStatus: "VALID",
+                                  result: "submit_failed_no_rejected_output",
+                                  reason: rejectedOutputReason,
+                                  actionType: gameModelActionType,
+                                  rawResponseHash: rawHashForAudit
+                                });
+                                return;
+                              }
+                              const submitted2 = await submitRejectedOutputWithLog({
+                                meta: gameMeta,
+                                wsClient,
+                                log: ctx.log,
+                                reason: rejectedOutputReason,
+                                rawResponse,
+                                auditMeta: {
+                                  retryCount: gameReplyAttempt,
+                                  firstRawResponseHash: gameFirstRawResponseHash ?? rawHashForAudit,
+                                  firstModelActionType: gameFirstModelActionType ?? gameModelActionType,
+                                  firstValidationReason: gameFirstValidationReason ?? gameValidationReason ?? inferred.validationReason,
+                                  retryRawResponseHash: gameRetryRawResponseHash,
+                                  retryValidationReason: gameRetryValidationReason
+                                }
+                              });
+                              if (submitted2 === "failed") {
+                                throw new Error(`game rejected-output submit failed: ${gameFallbackReason ?? "unknown"}`);
+                              }
+                              return;
+                            }
                             const submitted = await submitBackendFallbackWithLog({
                               meta: gameMeta,
                               wsClient,
@@ -2043,7 +2945,7 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                         ctx.log?.debug?.(`ACK sent: type=${ackFrame.type} lastAckedSeq=${ackFrame.payload?.lastAckedSeq}`);
                       } catch (err) {
                         logAckFailure({ log: ctx.log?.warn?.bind(ctx.log) ?? (() => {
-                        }), channel: "coolclaw", error: err });
+                        }), channel: productFlavor.channelId, error: err });
                         throw err;
                       }
                     }
@@ -2056,7 +2958,7 @@ var coolclawChannelPlugin = createChatChannelPlugin({
             await client.start();
             setRuntimeClient(accountKey, client);
             statusSink({ statusState: "connected" });
-            ctx.log?.info(`[${ctx.accountId}] CoolClaw provider connected`);
+            ctx.log?.info(`[${ctx.accountId}] ${productFlavor.displayName} provider connected`);
             return client;
           },
           stop: async (client) => {
@@ -2065,25 +2967,25 @@ var coolclawChannelPlugin = createChatChannelPlugin({
           },
           onStop: () => {
             statusSink({ statusState: "disconnected" });
-            ctx.log?.info(`[${ctx.accountId}] CoolClaw provider stopped`);
+            ctx.log?.info(`[${ctx.accountId}] ${productFlavor.displayName} provider stopped`);
           }
         });
       },
       /** 显式停止账户连接，清理 WebSocket 客户端资源 */
       async stopAccount(ctx) {
-        const accountKey = `coolclaw:${ctx.accountId ?? "default"}`;
+        const accountKey = `${productFlavor.channelId}:${ctx.accountId ?? "default"}`;
         const client = getRuntimeClient(accountKey);
         if (client) {
           await client.stop();
           clearRuntimeClient(accountKey);
-          ctx.log?.info(`[${ctx.accountId}] CoolClaw client stopped via stopAccount`);
+          ctx.log?.info(`[${ctx.accountId}] ${productFlavor.displayName} client stopped via stopAccount`);
         }
       }
     }
   },
   security: {
     dm: {
-      channelKey: "coolclaw",
+      channelKey: productFlavor.channelId,
       resolvePolicy: (account) => account.dmPolicy ?? "allowlist",
       resolveAllowFrom: (account) => account.allowFrom ?? [],
       defaultPolicy: "allowlist",
@@ -2092,10 +2994,10 @@ var coolclawChannelPlugin = createChatChannelPlugin({
   },
   pairing: {
     text: {
-      idLabel: "CoolClaw user ID",
+      idLabel: `${productFlavor.displayName} user ID`,
       message: "You are not authorized to message this agent. Send this pairing code to verify:",
       notify: async ({ id, message }) => {
-        const client = getRuntimeClient("coolclaw:default");
+        const client = getRuntimeClient(`${productFlavor.channelId}:default`);
         if (client) {
           await sendText({
             client,
@@ -2114,11 +3016,11 @@ var coolclawChannelPlugin = createChatChannelPlugin({
       deliveryMode: "direct",
       resolveTarget({ to }) {
         if (!to) {
-          return { ok: false, error: new Error("CoolClaw target is required") };
+          return { ok: false, error: new Error(`${productFlavor.displayName} target is required`) };
         }
         try {
-          const normalized = normalizeCoolclawTarget(to);
-          parseCoolclawTarget(normalized);
+          const normalized = normalizeCoolclawTarget(to, productFlavor);
+          parseCoolclawTarget(normalized, productFlavor);
           return { ok: true, to: normalized };
         } catch (error) {
           return { ok: false, error: error instanceof Error ? error : new Error(String(error)) };
@@ -2126,14 +3028,14 @@ var coolclawChannelPlugin = createChatChannelPlugin({
       }
     },
     attachedResults: {
-      channel: "coolclaw",
+      channel: productFlavor.channelId,
       async sendText(ctx) {
         const account = coolclawChannelPlugin.config.resolveAccount(ctx.cfg, ctx.accountId);
         const token = await resolveAccountToken(account);
         if (!account.gatewayUrl || !account.agentId || !token) {
-          throw new Error("CoolClaw account is not fully configured");
+          throw new Error(`${productFlavor.displayName} account is not fully configured`);
         }
-        const accountKey = `coolclaw:${ctx.accountId ?? "default"}`;
+        const accountKey = `${productFlavor.channelId}:${ctx.accountId ?? "default"}`;
         let client = getRuntimeClient(accountKey);
         if (!client || !client.isConnected()) {
           client = new CoolclawWsClient({
@@ -2159,9 +3061,9 @@ var coolclawChannelPlugin = createChatChannelPlugin({
         const account = coolclawChannelPlugin.config.resolveAccount(ctx.cfg, ctx.accountId);
         const token = await resolveAccountToken(account);
         if (!account.gatewayUrl || !account.agentId || !token) {
-          throw new Error("CoolClaw account is not fully configured");
+          throw new Error(`${productFlavor.displayName} account is not fully configured`);
         }
-        const accountKey = `coolclaw:${ctx.accountId ?? "default"}`;
+        const accountKey = `${productFlavor.channelId}:${ctx.accountId ?? "default"}`;
         let client = getRuntimeClient(accountKey);
         if (!client || !client.isConnected()) {
           client = new CoolclawWsClient({
@@ -2186,13 +3088,17 @@ var coolclawChannelPlugin = createChatChannelPlugin({
     }
   }
 });
-function buildBodyForAgent(envelope) {
+function buildBodyForAgent(envelope, flavorInput) {
+  const flavor = resolveFlavor(flavorInput);
+  if (isArenaVoiceSelectEnvelope(envelope)) {
+    return buildArenaVoiceSelectBodyForAgent(envelope, flavor);
+  }
   if (isArenaReportShareEnvelope(envelope)) {
-    return buildArenaReportShareBodyForAgent(envelope);
+    return buildArenaReportShareBodyForAgent(envelope, flavor);
   }
   if (!envelope.group) {
     if (envelope.sender && envelope.recipient) {
-      return buildPrivateBodyForAgent(envelope);
+      return buildPrivateBodyForAgent(envelope, flavor);
     }
     const hints = [
       envelope.metadata?.securityHint,
@@ -2203,7 +3109,7 @@ function buildBodyForAgent(envelope) {
   const sender = formatUserRef(envelope.sender, "\u672A\u77E5\u53D1\u9001\u4EBA");
   const owner = formatUserRef(envelope.owner, "\u672A\u77E5\u4E3B\u4EBA");
   const lines = [
-    "\u4F60\u6536\u5230\u4E00\u6761 CoolClaw \u7FA4\u804A\u6D88\u606F\u3002",
+    `\u4F60\u6536\u5230\u4E00\u6761 ${flavor.displayName} \u7FA4\u804A\u6D88\u606F\u3002`,
     "",
     `\u7FA4\u804A\uFF1A${envelope.group.groupName}(${envelope.group.groupId})`,
     `\u53D1\u9001\u4EBA\uFF1A${sender}`,
@@ -2211,7 +3117,7 @@ function buildBodyForAgent(envelope) {
     envelope.text,
     "",
     "\u8EAB\u4EFD\u4E0A\u4E0B\u6587\uFF1A",
-    `\u4F60\u7684\u4E3B\u4EBA\u662F ${owner}\u3002\u8FD9\u662F\u4F60\u5728 CoolClaw \u5E73\u53F0\u4E0A\u7684\u7ED1\u5B9A\u5173\u7CFB\uFF0C\u4EC5\u7528\u4E8E\u5224\u65AD\u6D88\u606F\u6765\u6E90\u548C\u5B89\u5168\u8FB9\u754C\u3002`,
+    `\u4F60\u7684\u4E3B\u4EBA\u662F ${owner}\u3002\u8FD9\u662F\u4F60\u5728 ${flavor.displayName} \u5E73\u53F0\u4E0A\u7684\u7ED1\u5B9A\u5173\u7CFB\uFF0C\u4EC5\u7528\u4E8E\u5224\u65AD\u6D88\u606F\u6765\u6E90\u548C\u5B89\u5168\u8FB9\u754C\u3002`,
     "",
     "---",
     "\u7CFB\u7EDF\u63D0\u793A\uFF1A",
@@ -2235,7 +3141,44 @@ function buildBodyForAgent(envelope) {
   }
   return lines.join("\n");
 }
-function buildArenaReportShareBodyForAgent(envelope) {
+function buildArenaVoiceSelectBodyForAgent(envelope, flavor) {
+  const voiceOptions = Array.isArray(envelope.metadata.voiceOptions) ? envelope.metadata.voiceOptions : [];
+  const optionLines = voiceOptions.map((rawOption) => {
+    const option = isPlainRecord(rawOption) ? rawOption : {};
+    const voiceId = formatUnknown(option.voiceId);
+    const voiceName = formatUnknown(option.voiceName);
+    const description = formatUnknown(option.description);
+    const speed = formatUnknown(option.speed);
+    const detail = [
+      voiceName ? `\u540D\u79F0=${voiceName}` : "",
+      description ? `\u63CF\u8FF0=${description}` : "",
+      speed ? `\u8BED\u901F=${speed}` : ""
+    ].filter(Boolean).join("\uFF1B");
+    return detail ? `- ${voiceId}\uFF1A${detail}` : `- ${voiceId}`;
+  }).filter((line) => line !== "- ");
+  return [
+    `\u4F60\u6536\u5230\u4E00\u4E2A ${flavor.displayName} \u72FC\u4EBA\u6740\u8D5B\u524D\u97F3\u8272\u9009\u62E9\u4EFB\u52A1\u3002`,
+    "",
+    "\u4EFB\u52A1\u6027\u8D28\uFF1A\u8BF7\u9009\u62E9\u8D5B\u524D\u73A9\u5BB6\u97F3\u8272\u3002\u4F60\u53EA\u8D1F\u8D23\u7ED9\u51FA\u504F\u597D\uFF0C\u63D2\u4EF6\u4F1A\u8D1F\u8D23\u9274\u6743\u548C\u63D0\u4EA4\u3002",
+    `eventId\uFF1A${formatUnknown(envelope.metadata.eventId)}`,
+    `roomId\uFF1A${formatUnknown(envelope.metadata.roomId)}`,
+    `seatNumber\uFF1A${formatUnknown(envelope.metadata.seatNumber)}`,
+    `seatEpoch\uFF1A${formatUnknown(envelope.metadata.seatEpoch)}`,
+    "",
+    "\u53EF\u9009\u73A9\u5BB6\u97F3\u8272\uFF1A",
+    ...optionLines.length > 0 ? optionLines : ["- \u65E0"],
+    "",
+    "\u8F93\u51FA\u8981\u6C42\uFF1A",
+    "\u53EA\u8F93\u51FA\u4E00\u4E2A JSON \u5BF9\u8C61\uFF0C\u4E0D\u8981\u8F93\u51FA Markdown\uFF0C\u4E0D\u8981\u8C03\u7528\u63A5\u53E3\uFF0C\u4E0D\u8981\u4F7F\u7528\u5DE5\u5177\uFF0C\u4E0D\u8981\u89E3\u91CA\u63D0\u4EA4\u8FC7\u7A0B\u3002",
+    '{"topVoiceIds":["4139","4172","5977"],"reason":"\u4E00\u53E5\u8BDD\u8BF4\u660E\u6574\u4F53\u9009\u62E9\u503E\u5411"}',
+    "",
+    "\u7EA6\u675F\uFF1A",
+    "1. topVoiceIds \u53EA\u80FD\u5305\u542B\u4E0A\u65B9\u53EF\u9009\u5217\u8868\u91CC\u7684 voiceId \u5B57\u7B26\u4E32\uFF0C\u6700\u591A 3 \u4E2A\uFF0C\u6309\u504F\u597D\u6392\u5E8F\u3002",
+    "2. \u4E0D\u8981\u628A voiceId \u8F6C\u6210\u6570\u5B57\u3002",
+    "3. \u97F3\u8272\u53EA\u5F71\u54CD\u53D1\u58F0\u98CE\u683C\uFF0C\u4E0D\u4EE3\u8868\u4F60\u7684\u6E38\u620F\u8EAB\u4EFD\u3001\u63A8\u7406\u4F9D\u636E\u6216\u53EF\u4FE1\u5EA6\u3002"
+  ].join("\n");
+}
+function buildArenaReportShareBodyForAgent(envelope, flavor) {
   const payload = isPlainRecord(envelope.metadata.reportPayload) ? envelope.metadata.reportPayload : {};
   const gameId = formatUnknown(payload.gameId);
   const roomId = formatUnknown(payload.roomId);
@@ -2248,7 +3191,7 @@ function buildArenaReportShareBodyForAgent(envelope) {
   const eventId = formatUnknown(envelope.metadata.eventId);
   const traceId = formatUnknown(envelope.metadata.traceId);
   return [
-    "\u4F60\u6536\u5230\u4E00\u4E2A CoolClaw \u7ADE\u6280\u573A\u6218\u62A5\u5206\u4EAB\u59D4\u6258\u4EFB\u52A1\u3002",
+    `\u4F60\u6536\u5230\u4E00\u4E2A ${flavor.displayName} \u7ADE\u6280\u573A\u6218\u62A5\u5206\u4EAB\u59D4\u6258\u4EFB\u52A1\u3002`,
     "",
     "\u4EFB\u52A1\u6027\u8D28\uFF1A\u8FD9\u662F\u4E3B\u4EBA\u59D4\u6258\u4F60\u6267\u884C\u7684\u7ADE\u6280\u573A\u6218\u62A5\u5206\u4EAB\u4EFB\u52A1\uFF0C\u4E0D\u662F\u666E\u901A\u8BC4\u8BBA\u901A\u77E5\uFF0C\u4E5F\u4E0D\u662F\u804A\u5929\u56DE\u590D\u3002",
     `eventId\uFF1A${eventId}`,
@@ -2264,14 +3207,14 @@ function buildArenaReportShareBodyForAgent(envelope) {
     `result\uFF1A${result}`,
     "",
     "\u6267\u884C\u6B65\u9AA4\uFF1A",
-    "1. \u8BFB\u53D6\u5F53\u524D CoolClaw channel/plugin \u914D\u7F6E\u7684 Gateway Base URL\uFF1B\u4F18\u5148\u4F7F\u7528 channels.coolclaw.accounts.default.gatewayUrl\uFF0C\u5176\u6B21\u4F7F\u7528 COOLCLAW_GATEWAY_URL \u73AF\u5883\u53D8\u91CF\u3002",
+    `1. \u8BFB\u53D6\u5F53\u524D ${flavor.displayName} channel/plugin \u914D\u7F6E\u7684 Gateway Base URL\uFF1B\u4F18\u5148\u4F7F\u7528 channels.${flavor.channelId}.accounts.default.gatewayUrl\uFF0C\u5176\u6B21\u4F7F\u7528 ${flavor.envPrefix}_GATEWAY_URL \u73AF\u5883\u53D8\u91CF\u3002`,
     "2. \u5982\u679C\u65E0\u6CD5\u89E3\u6790 Gateway Base URL\uFF0C\u505C\u6B62\u4EFB\u52A1\u5E76\u62A5\u544A\u914D\u7F6E\u7F3A\u5931\uFF1B\u4E0D\u8981\u81C6\u9020\u57DF\u540D\u3002",
     `3. \u4F7F\u7528 Gateway Base URL \u62FC\u63A5 replayApiPath=${replayApiPath} \u8BFB\u53D6\u672C\u5C40\u6218\u62A5\u3002`,
     `4. \u4F7F\u7528\u540C\u4E00\u4E2A Gateway Base URL \u62FC\u63A5 boardListApiPath=${boardListApiPath} \u67E5\u8BE2\u5185\u5BB9\u5E7F\u573A\u677F\u5757\uFF0C\u4F18\u5148\u9009\u62E9\u201C\u7ADE\u6280\u573A\u6218\u62A5 & \u590D\u76D8\u201D\u3002`,
     `5. \u4F7F\u7528\u540C\u4E00\u4E2A Gateway Base URL \u62FC\u63A5 createPostApiPath=${createPostApiPath} \u53D1\u5E03\u5E16\u5B50\u3002`,
     "6. \u53D1\u5E16\u6807\u9898\u548C\u6B63\u6587\u7531\u4F60\u57FA\u4E8E\u6218\u62A5\u5185\u5BB9\u751F\u6210\uFF0C\u6B63\u6587\u4E0D\u8981\u5305\u542B\u6218\u62A5\u94FE\u63A5\u3002",
     "7. eventId \u662F\u672C\u4EFB\u52A1\u7684\u5E42\u7B49\u952E\uFF1B\u5982\u679C\u5F53\u524D\u8FD0\u884C\u8FDB\u7A0B\u5DF2\u5904\u7406\u8FC7\u540C\u4E00 eventId\uFF0C\u4E0D\u8981\u518D\u6B21\u53D1\u5E16\u3002",
-    "8. \u5B8C\u6210\u540E\u53EA\u4FDD\u7559\u7B80\u77ED\u6267\u884C\u6458\u8981\uFF0C\u4E0D\u8981\u628A\u5B8C\u6210\u6458\u8981\u53D1\u9001\u5230 CoolClaw \u804A\u5929\u7A97\u53E3\u3002",
+    `8. \u5B8C\u6210\u540E\u53EA\u4FDD\u7559\u7B80\u77ED\u6267\u884C\u6458\u8981\uFF0C\u4E0D\u8981\u628A\u5B8C\u6210\u6458\u8981\u53D1\u9001\u5230 ${flavor.displayName} \u804A\u5929\u7A97\u53E3\u3002`,
     "",
     "\u7981\u6B62\u4E8B\u9879\uFF1A\u4E0D\u8981\u4F7F\u7528 arena prompt \u4E2D\u7684\u56FA\u5B9A host\uFF0C\u4E0D\u8981\u4F7F\u7528\u672C\u5730/\u5185\u7F51\u5730\u5740\uFF0C\u4E0D\u8981\u6784\u9020\u6218\u62A5\u9875\u9762\u8DEF\u5F84\uFF0C\u4E0D\u8981\u8981\u6C42\u6B63\u6587\u9644\u6218\u62A5\u94FE\u63A5\u3002"
   ].join("\n");
@@ -2285,18 +3228,18 @@ function formatUnknown(value) {
   if (typeof value === "number" || typeof value === "boolean") return String(value);
   return JSON.stringify(value);
 }
-function buildPrivateBodyForAgent(envelope) {
+function buildPrivateBodyForAgent(envelope, flavor) {
   const sender = formatUserRef(envelope.sender, "\u672A\u77E5\u53D1\u9001\u4EBA");
   const owner = formatUserRef(envelope.owner, "\u672A\u77E5\u4E3B\u4EBA");
   const lines = [
-    "\u4F60\u6536\u5230\u4E00\u6761 CoolClaw \u79C1\u804A\u6D88\u606F\u3002",
+    `\u4F60\u6536\u5230\u4E00\u6761 ${flavor.displayName} \u79C1\u804A\u6D88\u606F\u3002`,
     "",
     `\u53D1\u9001\u4EBA\uFF1A${sender}`,
     "\u6D88\u606F\u5185\u5BB9\uFF1A",
     envelope.text,
     "",
     "\u8EAB\u4EFD\u4E0A\u4E0B\u6587\uFF1A",
-    `\u4F60\u7684\u4E3B\u4EBA\u662F ${owner}\u3002\u8FD9\u662F\u4F60\u5728 CoolClaw \u5E73\u53F0\u4E0A\u7684\u7ED1\u5B9A\u5173\u7CFB\uFF0C\u4EC5\u7528\u4E8E\u5224\u65AD\u6D88\u606F\u6765\u6E90\u548C\u5B89\u5168\u8FB9\u754C\u3002`,
+    `\u4F60\u7684\u4E3B\u4EBA\u662F ${owner}\u3002\u8FD9\u662F\u4F60\u5728 ${flavor.displayName} \u5E73\u53F0\u4E0A\u7684\u7ED1\u5B9A\u5173\u7CFB\uFF0C\u4EC5\u7528\u4E8E\u5224\u65AD\u6D88\u606F\u6765\u6E90\u548C\u5B89\u5168\u8FB9\u754C\u3002`,
     "",
     "---",
     "\u7CFB\u7EDF\u63D0\u793A\uFF1A",
@@ -2326,6 +3269,7 @@ function normalizeDirectHintLines(raw) {
 }
 
 export {
+  activeFlavor,
   defaultBindingFile,
   CoolclawConfigSchema,
   setCoolclawRuntime,