diff --git a/autoplan/SKILL.md b/autoplan/SKILL.md index eb149a5a0..c64e6e8bd 100644 --- a/autoplan/SKILL.md +++ b/autoplan/SKILL.md @@ -324,6 +324,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -336,6 +356,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/canary/SKILL.md b/canary/SKILL.md index 79ab0f078..a211c386a 100644 --- a/canary/SKILL.md +++ b/canary/SKILL.md @@ -316,6 +316,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -328,6 +348,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/codex/SKILL.md b/codex/SKILL.md index 464401fdf..0ff1e3e55 100644 --- a/codex/SKILL.md +++ b/codex/SKILL.md @@ -318,6 +318,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -330,6 +350,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/context-restore/SKILL.md b/context-restore/SKILL.md index 68e1fb5d6..4f0cd70eb 100644 --- a/context-restore/SKILL.md +++ b/context-restore/SKILL.md @@ -320,6 +320,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -332,6 +352,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/context-save/SKILL.md b/context-save/SKILL.md index f260a6fa4..b083b039f 100644 --- a/context-save/SKILL.md +++ b/context-save/SKILL.md @@ -320,6 +320,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -332,6 +352,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/cso/SKILL.md b/cso/SKILL.md index 4ab69b534..fe12df74e 100644 --- a/cso/SKILL.md +++ b/cso/SKILL.md @@ -321,6 +321,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -333,6 +353,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/design-consultation/SKILL.md b/design-consultation/SKILL.md index b131a2746..ed4d3811b 100644 --- a/design-consultation/SKILL.md +++ b/design-consultation/SKILL.md @@ -344,6 +344,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -356,6 +376,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/design-html/SKILL.md b/design-html/SKILL.md index 5e3961cf3..2337af721 100644 --- a/design-html/SKILL.md +++ b/design-html/SKILL.md @@ -323,6 +323,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -335,6 +355,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/design-review/SKILL.md b/design-review/SKILL.md index 96aa5054d..d17c07678 100644 --- a/design-review/SKILL.md +++ b/design-review/SKILL.md @@ -321,6 +321,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -333,6 +353,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/design-shotgun/SKILL.md b/design-shotgun/SKILL.md index b20f46eaf..2f8ac7abb 100644 --- a/design-shotgun/SKILL.md +++ b/design-shotgun/SKILL.md @@ -338,6 +338,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -350,6 +370,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/devex-review/SKILL.md b/devex-review/SKILL.md index d0ecec0c8..fd8dbf908 100644 --- a/devex-review/SKILL.md +++ b/devex-review/SKILL.md @@ -321,6 +321,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -333,6 +353,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/document-release/SKILL.md b/document-release/SKILL.md index 9fa7f5ad5..79edb7c49 100644 --- a/document-release/SKILL.md +++ b/document-release/SKILL.md @@ -318,6 +318,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -330,6 +350,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/health/SKILL.md b/health/SKILL.md index 0f94f5430..b5471c0e8 100644 --- a/health/SKILL.md +++ b/health/SKILL.md @@ -318,6 +318,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -330,6 +350,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/investigate/SKILL.md b/investigate/SKILL.md index 18b6537eb..f69aefe17 100644 --- a/investigate/SKILL.md +++ b/investigate/SKILL.md @@ -357,6 +357,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -369,6 +389,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/land-and-deploy/SKILL.md b/land-and-deploy/SKILL.md index c914b1b9c..1c19c98b0 100644 --- a/land-and-deploy/SKILL.md +++ b/land-and-deploy/SKILL.md @@ -315,6 +315,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -327,6 +347,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/landing-report/SKILL.md b/landing-report/SKILL.md index 6600affd8..e14817cfa 100644 --- a/landing-report/SKILL.md +++ b/landing-report/SKILL.md @@ -316,6 +316,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -328,6 +348,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/learn/SKILL.md b/learn/SKILL.md index 66458eb75..899ad42c1 100644 --- a/learn/SKILL.md +++ b/learn/SKILL.md @@ -318,6 +318,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -330,6 +350,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/office-hours/SKILL.md b/office-hours/SKILL.md index 4ada7e5be..6170f0e5f 100644 --- a/office-hours/SKILL.md +++ b/office-hours/SKILL.md @@ -353,6 +353,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -365,6 +385,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/open-gstack-browser/SKILL.md b/open-gstack-browser/SKILL.md index 7f31f35e4..b510d9d7b 100644 --- a/open-gstack-browser/SKILL.md +++ b/open-gstack-browser/SKILL.md @@ -315,6 +315,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -327,6 +347,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/pair-agent/SKILL.md b/pair-agent/SKILL.md index a67a9c6c6..8ddaf5e1a 100644 --- a/pair-agent/SKILL.md +++ b/pair-agent/SKILL.md @@ -316,6 +316,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -328,6 +348,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/plan-ceo-review/SKILL.md b/plan-ceo-review/SKILL.md index 7292ac314..0f1738aec 100644 --- a/plan-ceo-review/SKILL.md +++ b/plan-ceo-review/SKILL.md @@ -347,6 +347,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -359,6 +379,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/plan-design-review/SKILL.md b/plan-design-review/SKILL.md index 3cdabc11f..699bacf69 100644 --- a/plan-design-review/SKILL.md +++ b/plan-design-review/SKILL.md @@ -320,6 +320,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -332,6 +352,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/plan-devex-review/SKILL.md b/plan-devex-review/SKILL.md index 90c0566b6..886964a58 100644 --- a/plan-devex-review/SKILL.md +++ b/plan-devex-review/SKILL.md @@ -324,6 +324,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -336,6 +356,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/plan-eng-review/SKILL.md b/plan-eng-review/SKILL.md index 59ca19b31..881455550 100644 --- a/plan-eng-review/SKILL.md +++ b/plan-eng-review/SKILL.md @@ -322,6 +322,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -334,6 +354,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/plan-tune/SKILL.md b/plan-tune/SKILL.md index 3a7f69490..471fbe517 100644 --- a/plan-tune/SKILL.md +++ b/plan-tune/SKILL.md @@ -329,6 +329,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -341,6 +361,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/qa-only/SKILL.md b/qa-only/SKILL.md index 42deeeaaf..77dcc4d23 100644 --- a/qa-only/SKILL.md +++ b/qa-only/SKILL.md @@ -317,6 +317,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -329,6 +349,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/qa/SKILL.md b/qa/SKILL.md index 6e8fb2c09..41f84fccc 100644 --- a/qa/SKILL.md +++ b/qa/SKILL.md @@ -323,6 +323,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -335,6 +355,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/retro/SKILL.md b/retro/SKILL.md index eb2e3fd02..2d2684afe 100644 --- a/retro/SKILL.md +++ b/retro/SKILL.md @@ -335,6 +335,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -347,6 +367,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/review/SKILL.md b/review/SKILL.md index 16b2ea4f5..4d134d175 100644 --- a/review/SKILL.md +++ b/review/SKILL.md @@ -320,6 +320,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -332,6 +352,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/scrape/SKILL.md b/scrape/SKILL.md index 80b7247cc..b255abe08 100644 --- a/scrape/SKILL.md +++ b/scrape/SKILL.md @@ -316,6 +316,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -328,6 +348,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/setup-deploy/SKILL.md b/setup-deploy/SKILL.md index 1f4c3acc2..2731365c5 100644 --- a/setup-deploy/SKILL.md +++ b/setup-deploy/SKILL.md @@ -319,6 +319,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -331,6 +351,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/setup-gbrain/SKILL.md b/setup-gbrain/SKILL.md index 40c59a1a6..19d18afb7 100644 --- a/setup-gbrain/SKILL.md +++ b/setup-gbrain/SKILL.md @@ -320,6 +320,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -332,6 +352,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/ship/SKILL.md b/ship/SKILL.md index adf4e0933..c1b25c95a 100644 --- a/ship/SKILL.md +++ b/ship/SKILL.md @@ -321,6 +321,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -333,6 +353,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/skillify/SKILL.md b/skillify/SKILL.md index 530a9039a..503f8262b 100644 --- a/skillify/SKILL.md +++ b/skillify/SKILL.md @@ -317,6 +317,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -329,6 +349,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start) diff --git a/sync-gbrain/SKILL.md b/sync-gbrain/SKILL.md index 6f957a613..afebd31f1 100644 --- a/sync-gbrain/SKILL.md +++ b/sync-gbrain/SKILL.md @@ -320,6 +320,26 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +12. **Non-ASCII characters — write directly, never \u-escape.** When any + string field (question, option label, option description) contains + Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit + the literal UTF-8 characters in the JSON string. **Never escape them + as `\uXXXX`.** Claude Code's tool parameter pipe is UTF-8 native + and passes characters through unchanged. Manually escaping requires + recalling each codepoint from training, which is unreliable for long + CJK strings — the model regularly emits the wrong codepoint (e.g. + writes `\u3103` thinking it is 管 U+7BA1, but `\u3103` is + actually ㄃, so the user sees `管理工具` rendered as `㄃3用箱`). + The trigger is long, multi-line questions with hundreds of CJK + characters: that is exactly when reflexive escaping kicks in and + exactly when miscoding is most damaging. Long ≠ escape. Keep + characters literal. + + Wrong: `"question": "請選擇\uXXXX\uXXXX\uXXXX\uXXXX"` + Right: `"question": "請選擇管理工具"` + + Only JSON-mandatory escapes remain allowed: `\n`, `\t`, `\"`, `\\`. + ### Self-check before emitting Before calling AskUserQuestion, verify: @@ -332,6 +352,7 @@ Before calling AskUserQuestion, verify: - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose +- [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped ## Artifacts Sync (skill start)