oh-my-customcode 1.1.61 → 1.1.62

package/dist/cli/index.js

@@ -243,7 +243,7 @@ var init_package = __esm(() => {
     workspaces: [
       "packages/*"
     ],
-    version: "1.1.61",
+    version: "1.1.62",
     description: "Batteries-included agent harness for Claude Code",
     type: "module",
     bin: {

package/dist/index.js

@@ -2539,7 +2539,7 @@ var package_default = {
   workspaces: [
     "packages/*"
   ],
-  version: "1.1.61",
+  version: "1.1.62",
   description: "Batteries-included agent harness for Claude Code",
   type: "module",
   bin: {

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "1.1.61",
+  "version": "1.1.62",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {

package/templates/.claude/hooks/scripts/agent-start-recorder.sh

@@ -10,6 +10,10 @@ command -v jq >/dev/null 2>&1 || { cat; exit 0; }
 
 input=$(cat)
 
+# Guard: non-object stdin (non-JSON / JSON array / empty) — swallow and exit 0.
+# Hooks must never crash (R021); jq parse errors would otherwise abort under `set -e`. (#1650)
+printf '%s' "$input" | jq -e 'type=="object"' >/dev/null 2>&1 || exit 0
+
 agent_type=$(printf '%s\n' "$input" | jq -r '.agent_type // "unknown"')
 model=$(printf '%s\n' "$input" | jq -r '.model // "inherit"')
 description=$(printf '%s\n' "$input" | jq -r '.description // ""' | head -c 80)

package/templates/.claude/hooks/scripts/agent-teams-advisor.sh

@@ -11,6 +11,10 @@ command -v jq >/dev/null 2>&1 || exit 0
 
 input=$(cat)
 
+# Guard: non-object stdin (non-JSON / JSON array / empty) — swallow and exit 0.
+# Hooks must never crash (R021); jq parse errors would otherwise abort under `set -e`. (#1650)
+printf '%s' "$input" | jq -e 'type=="object"' >/dev/null 2>&1 || exit 0
+
 # Skip unless Agent Teams is CONFIRMED active.
 # session-env-check.sh writes one of: disabled | env-set | enabled (#1588).
 #   `env-set` = the env var is set but TeamCreate presence is UNVERIFIED — R018 is dormant,
@@ -43,8 +47,8 @@ if [ -f "$RELEASE_PLAN" ]; then
 fi
 
 # Extract task info from input
-agent_type=$(printf '%s\n' "$input" | jq -r '.tool_input.subagent_type // "unknown"')
-prompt_preview=$(printf '%s\n' "$input" | jq -r '.tool_input.description // ""' | head -c 60)
+agent_type=$(printf '%s\n' "$input" | jq -r '.tool_input.subagent_type? // "unknown"')
+prompt_preview=$(printf '%s\n' "$input" | jq -r '.tool_input.description? // ""' | head -c 60)
 
 # Session-scoped counter using parent PID as session identifier
 COUNTER_FILE="/tmp/.claude-task-count-${PPID}"

package/templates/.claude/hooks/scripts/audit-log.sh

@@ -13,12 +13,29 @@ command -v jq >/dev/null 2>&1 || exit 0
 
 input=$(cat)
 
+# Guard: non-object stdin (non-JSON / JSON array / empty) — swallow and exit 0.
+# Hooks must never crash (R021); jq parse errors would otherwise abort under `set -e`. (#1650)
+printf '%s' "$input" | jq -e 'type=="object"' >/dev/null 2>&1 || exit 0
+
 # Extract fields from hook input
 tool_name=$(printf '%s\n' "$input" | jq -r '.tool_name // "unknown"')
-file_path=$(printf '%s\n' "$input" | jq -r '.tool_input.file_path // .tool_input.command // ""' | head -c 200)
+file_path=$(printf '%s\n' "$input" | jq -r '.tool_input.file_path? // .tool_input.command? // ""' | head -c 200)
 agent_type=$(printf '%s\n' "$input" | jq -r '.agent_type // "unknown"')
 model=$(printf '%s\n' "$input" | jq -r '.model // "unknown"')
-is_error=$(printf '%s\n' "$input" | jq -r '.tool_output.is_error // false')
+# Outcome signal. PostToolUse carries the result under `tool_response`, not
+# `tool_output` (measured 2026-09-03: 1764/1764 PostToolUse payloads had
+# `tool_response`, 0/1764 had `tool_output`), so the old `.tool_output.is_error`
+# read was always absent and every entry was logged as outcome=success.
+# Measured failure signals: `.tool_response.is_error` (generic) and
+# `.tool_response.interrupted` (present on every Bash response).
+# jq's `//` treats both null and false as absent, so this chain is an OR:
+# the result is true iff at least one signal is true.
+is_error=$(printf '%s\n' "$input" | jq -r '
+  (.tool_response?.is_error?
+    // .tool_response?.interrupted?
+    // .tool_output?.is_error?
+    // false) | tostring
+' 2>/dev/null) || is_error="false"
 timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 
 # Determine outcome

package/templates/.claude/hooks/scripts/content-hash-validator.sh

@@ -12,6 +12,10 @@ command -v jq >/dev/null 2>&1 || exit 0
 
 input=$(cat)
 
+# Guard: non-object stdin (non-JSON / JSON array / empty) — swallow and exit 0.
+# Hooks must never crash (R021); jq parse errors would otherwise abort under `set -e`. (#1650)
+printf '%s' "$input" | jq -e 'type=="object"' >/dev/null 2>&1 || exit 0
+
 # Hash store (PPID-scoped, session-only)
 HASH_STORE="/tmp/.claude-content-hashes-${PPID}"
 
@@ -20,7 +24,7 @@ tool_name=$(printf '%s\n' "$input" | jq -r '.tool_name // "unknown"')
 case "$tool_name" in
   "Read")
     # Store content hash for the file that was just read
-    file_path=$(printf '%s\n' "$input" | jq -r '.tool_input.file_path // ""')
+    file_path=$(printf '%s\n' "$input" | jq -r '.tool_input.file_path? // ""')
 
     if [ -n "$file_path" ] && [ -f "$file_path" ]; then
       content_hash=$(md5 -q "$file_path" 2>/dev/null || md5sum "$file_path" 2>/dev/null | cut -d' ' -f1 || echo "unknown")
@@ -43,7 +47,7 @@ case "$tool_name" in
 
   "Edit")
     # Validate that file hasn't changed since last Read
-    file_path=$(printf '%s\n' "$input" | jq -r '.tool_input.file_path // ""')
+    file_path=$(printf '%s\n' "$input" | jq -r '.tool_input.file_path? // ""')
 
     if [ -n "$file_path" ] && [ -f "$HASH_STORE" ] && [ -f "$file_path" ]; then
       stored_hash=$(grep "\"path\":\"${file_path}\"" "$HASH_STORE" 2>/dev/null | tail -1 | jq -r '.hash // ""' 2>/dev/null || echo "")

package/templates/.claude/hooks/scripts/model-escalation-advisor.sh

@@ -11,9 +11,13 @@ command -v jq >/dev/null 2>&1 || exit 0
 
 input=$(cat)
 
+# Guard: non-object stdin (non-JSON / JSON array / empty) — swallow and exit 0.
+# Hooks must never crash (R021); jq parse errors would otherwise abort under `set -e`. (#1650)
+printf '%s' "$input" | jq -e 'type=="object"' >/dev/null 2>&1 || exit 0
+
 # Extract current task info
-agent_type=$(printf '%s\n' "$input" | jq -r '.tool_input.subagent_type // "unknown"')
-current_model=$(printf '%s\n' "$input" | jq -r '.tool_input.model // "inherit"')
+agent_type=$(printf '%s\n' "$input" | jq -r '.tool_input.subagent_type? // "unknown"')
+current_model=$(printf '%s\n' "$input" | jq -r '.tool_input.model? // "inherit"')
 
 # Session-scoped outcome log
 OUTCOME_FILE="/tmp/.claude-task-outcomes-${PPID}"

package/templates/.claude/hooks/scripts/playwright-compress.sh

@@ -7,7 +7,30 @@
 set -euo pipefail
 
 input=$(cat)
-tool_output=$(printf '%s\n' "$input" | jq -r '.tool_output // ""')
+
+# Guard: non-object stdin (non-JSON / JSON array / empty) — swallow and exit 0.
+# Hooks must never crash (R021); jq parse errors would otherwise abort under `set -e`. (#1650)
+printf '%s' "$input" | jq -e 'type=="object"' >/dev/null 2>&1 || exit 0
+# PostToolUse carries the tool result under `tool_response`, not `tool_output`
+# (measured 2026-09-03: 1764/1764 PostToolUse payloads had `tool_response`,
+# 0/1764 had `tool_output`), so the previous `.tool_output` read always yielded
+# "" and this hook never compressed anything. MCP responses arrive either as a
+# bare string or as `{content: [{type:"text", text:...}]}`; `.tool_output` is
+# kept as a fallback for events still using the older shape.
+tool_output=$(printf '%s\n' "$input" | jq -r '
+  [
+    (.tool_response?   | if type == "string" then . else empty end),
+    (.tool_response?.content? | strings),
+    (.tool_response?.content? | if type == "array"
+                                then map(.text? | strings) | join("\n")
+                                else empty end),
+    (.tool_response?.stdout?  | strings),
+    (.tool_response?.file?.content? | strings),
+    (.tool_output?     | if type == "string" then . else empty end),
+    (.tool_output?.output?    | strings)
+  ]
+  | map(select(. != "")) | join("\n")
+' 2>/dev/null) || tool_output=""
 
 # Skip if output is small (< 3000 chars)
 output_len=${#tool_output}
@@ -47,4 +70,4 @@ fi
 compressed_len=${#summary}
 savings=$(( (output_len - compressed_len) * 100 / output_len ))
 printf '%s\n' "$input" | jq --arg summary "$summary" --arg savings "${savings}% reduced (${output_len}→${compressed_len} chars)" \
-  '.tool_output = $summary | .["updatedMCPToolOutput"] = $summary'
+  '.tool_response = $summary | .tool_output = $summary | .["updatedMCPToolOutput"] = $summary'

package/templates/.claude/hooks/scripts/r007-r008-drift-advisor.sh

@@ -22,6 +22,11 @@
 #
 # Advisory-only: ALWAYS exits 0, NEVER blocks.
 #
+# Scope gate (#1650 D): the advisor judges the ORCHESTRATOR's turns only. When the hook fires
+# from INSIDE a subagent session (the payload carries `agent_id`) it exits immediately — see
+# the measured rationale at the gate itself. SubagentStart/SubagentStop are exempt because
+# `agent_id` is a required TARGET identifier there, not an in-subagent marker.
+#
 # ── Transcript schema (MEASURED 2026-08-05, #1553) ────────────────────────────────────
 # Claude Code JSONL lines do NOT carry a TOP-LEVEL `role`/`content`. The measured top-level
 # key set is:
@@ -134,15 +139,58 @@ if ! command -v jq >/dev/null 2>&1; then
 fi
 
 # ── 입력 필드 추출 (jq 1회 fork) ──
-meta=$(printf '%s' "$input" | jq -r '[(.session_id // ""), (.hook_event_name // ""), (.transcript_path // "")] | @tsv' 2>/dev/null) || exit 0
+# stdin 가드: 비-JSON이면 jq가 실패해 `|| exit 0`으로 무음 종료하고, 유효 JSON이지만 객체가
+# 아니면(배열/문자열/숫자) `select(type == "object")`가 걸러 빈 출력 → session_id 공백 → exit 0.
+# 두 경로 모두 추가 fork 없이 기존 1회 fork 안에서 처리한다(PostToolUse는 매 도구 호출마다 발화).
+meta=$(printf '%s' "$input" | jq -r 'select(type == "object") | [(.session_id // ""), (.hook_event_name // ""), (.transcript_path // ""), (.agent_id // "")] | @tsv' 2>/dev/null) || exit 0
 session_id=$(printf '%s' "$meta" | cut -f1)
 hook_event_name=$(printf '%s' "$meta" | cut -f2)
 transcript_in=$(printf '%s' "$meta" | cut -f3)
+agent_id=$(printf '%s' "$meta" | cut -f4)
 
 if [ -z "$session_id" ]; then
   exit 0
 fi
 
+# ── 서브에이전트 세션이면 즉시 종료 (#1650 D) ────────────────────────────────────────────
+# settings 훅은 서브에이전트 세션에서도 발화한다(서브에이전트의 매 도구 호출마다 PostToolUse).
+# 그 발화가 남기는 advisory 피드백이 서브에이전트의 마지막 턴들을 잠식해 완료 보고를 대체하는
+# 현상이 관측됐다(R020 8항 — 훅 피드백 잠식).
+#
+# 판별 신호 실측 (CC 2.1.259 바이너리의 훅 입력 zod 스키마 원문):
+#   agent_id: optional — "Subagent identifier. Present only when the hook fires from within a
+#   subagent (e.g., a tool called by an AgentTool worker). Absent for the main thread, even in
+#   --agent sessions. Use this field (not agent_type) to distinguish subagent calls from
+#   main-thread calls."
+# 그리고 공통 페이로드 빌더가 모든 훅 이벤트에 `agent_id: o?.agentId`를 실어 보낸다.
+# 즉 플랫폼이 명시적으로 지정한 판별 필드다. `agent_type`은 쓰지 않는다 — 같은 스키마가
+# "--agent로 시작한 세션의 메인 스레드에도(agent_id 없이) 존재한다"고 못박고 있다.
+#
+# 다른 두 후보가 왜 작동하지 않는지(실측):
+#   * 트랜스크립트의 isSidechain / agentId 레코드 필드 — 서브에이전트 전용 파일
+#     agent-<hex>.jsonl의 전 레코드에 존재하지만(실측 65/65, 3/3), 공통 빌더는
+#     `transcript_path: Lp(e.id)`로 **세션 id**에서 경로를 만들고 서브에이전트는 부모의
+#     session id를 공유한다(실측: agent-*.jsonl의 sessionId == 부모 UUID). 따라서 서브에이전트
+#     안에서 발화한 훅이 읽는 파일은 **부모의 메인 트랜스크립트**이고, 그 파일에는 isSidechain
+#     true도 agentId도 없다. 이것이 바로 잠식 경로다.
+#   * transcript_path의 `agent-*.jsonl` 경로 패턴 — 같은 이유로 그 경로가 오지 않는다
+#     (`agent_transcript_path`는 SubagentStop 페이로드에만 추가되는 별도 필드다).
+#
+# SubagentStart/SubagentStop은 예외다: 두 이벤트의 스키마는 agent_id를 **필수**로 두고 그 값은
+# "대상 서브에이전트"의 식별자다(`Ae().and({hook_event_name:"SubagentStop", agent_id, ...})`).
+# 즉 이 두 이벤트에서 agent_id는 "서브에이전트 안에서 발화했다"는 표지가 아니므로, 여기서
+# 게이트를 걸면 #1545 자율 루프 커버리지가 통째로 사라진다.
+case "$hook_event_name" in
+  SubagentStart|SubagentStop)
+    : # agent_id는 대상 식별자 — 판별 신호로 쓰지 않는다
+    ;;
+  *)
+    if [ -n "$agent_id" ]; then
+      exit 0
+    fi
+    ;;
+esac
+
 # hook_event_name이 없으면 hookSpecificOutput.hookEventName을 정확히 채울 수 없다.
 # 잘못된 기본값은 출력을 무효화하므로 추측하지 않고 즉시 종료한다 (fallback 제거).
 if [ -z "$hook_event_name" ]; then
@@ -221,9 +269,31 @@ split("\n")
        else 1 end) as $r007
     | ([ $blocks[] | select(.type? == "text") | (.text? // "") ] | join("\n") | split("\n")) as $lines
     | ([ $lines[] | select(test("\\[.+\\]\\[.+\\] ?(→|->|—>) ?Tool:")) ] | length) as $an_tool
+    # Core Rule 접두사 중 Agent 스폰을 가리키는 것만 따로 센다 — 아래 스폰 표기 중복 차감용.
+    | ([ $lines[] | select(test("\\[.+\\]\\[.+\\] ?(→|->|—>) ?Tool: ?Agent")) ] | length) as $an_tool_agent
     | ([ $lines[] | select(test("^[[:space:]]*\\[[0-9]+\\][[:space:]].*(→|->|—>)")) ] | length) as $an_spawn_item
+    # 단일 스폰 표기 (#1650 E): R008 §"Agent Tool Format"이 규정하는 `subagent_type:model → desc`
+    # 라인. 같은 절의 Parallel Spawn Prefix Rule은 **단일 스폰을 `[N]` 접두사에서 명시적으로
+    # 면제**하므로, 번호 없는 이 형태가 단일 스폰의 정규 표기다. $an_spawn_item은 번호 형태만
+    # 세므로 이 라인은 announce에 0을 기여했고, Agent tool_use가 그대로 위반으로 계상됐다.
+    # 줄 시작 앵커(선행 공백만 허용)는 필수다 — `- mgr-x:sonnet → ...` 같은 리스트 산문이나
+    # 문장 중간 인용이 announce로 계상되면 forward 판정(max(0, ntools - announce))에서 실제
+    # 누락을 가려버린다.
+    | ([ $lines[] | select(test("^[[:space:]]*[a-z][a-z0-9-]*:(haiku|sonnet|opus|fable|inherit)[[:space:]]*(→|->|—>)")) ] | length) as $an_spawn_single
     | ([ $lines[] | select(test("\\[.+\\]\\[.+\\] ?(→|->|—>) ?Spawning:")) ] | length) as $an_spawn_hdr
-    | ($an_tool + (if $an_spawn_item > 0 then $an_spawn_item else $an_spawn_hdr end)) as $announce
+    # 스폰 표기의 단위는 세분화된 것 우선: 번호 라인 > 단일 스폰 라인 > Spawning 헤더.
+    | (if $an_spawn_item > 0 then $an_spawn_item
+       elif $an_spawn_single > 0 then $an_spawn_single
+       else $an_spawn_hdr end) as $an_spawn
+    # 중복 계수 차감 (#1650 E): 같은 턴에 Core Rule `→ Tool: Agent` 접두사가 함께 있으면 스폰
+    # 표기 라인은 **같은 호출의 동반 라인**이다 — `→ Target:`이 `→ Tool:`의 동반 라인이라 세지
+    # 않는 것과 동일한 논리다. 더해버리면 한 호출이 2로 계상돼, 같은 턴의 다른 진짜 누락을
+    # 가린다(forward는 max(0, ntools - announce)라 과대 announce는 조용한 마스킹이 된다).
+    # 그래서 스폰 기여분에서 `→ Tool: Agent` 라인 수를 빼되 0에서 바닥을 친다 — 빼기만 하므로
+    # announce가 늘지 않아 신규 오탐은 생기지 않는다. 대신 구식의 과대 announce(접두사 +
+    # 항목 이중 계수)가 가리던 진짜 누락 — 예: 접두사 1 + [1] 항목 1 + tools=(Agent, Read)에서
+    # 미announce Read — 은 새로 발화한다(의도된 동작, v1.1.62 적대적 리뷰 재현 C1/C2).
+    | ($an_tool + (if $an_spawn > $an_tool_agent then $an_spawn - $an_tool_agent else 0 end)) as $announce
     | ([ $blocks[] | select((.type? == "tool_use") and ((.name? // "") != "Skill")) ] | length) as $ntools
     # 전체 tool_use(Skill 포함)가 0건인 턴은 forward 판정을 무조건 0으로 고정한다(#1625
     # 찐빠 #3, 이슈 제안 그대로). $ntools(Skill 제외) 기반 산식은 정상 입력에서는 이미

package/templates/.claude/hooks/scripts/schema-validator.sh

@@ -12,9 +12,14 @@ command -v jq >/dev/null 2>&1 || exit 0
 
 input=$(cat)
 
-# Extract tool info
-tool_name=$(printf '%s\n' "$input" | jq -r '.tool_name // "unknown"')
-tool_input=$(printf '%s\n' "$input" | jq -r '.tool_input // {}')
+# Non-object stdin guard (#1650 B): a hook must never crash on garbage stdin.
+# jq's parse error propagates through `set -euo pipefail` as rc=5 without this.
+printf '%s' "$input" | jq -e 'type=="object"' >/dev/null 2>&1 || exit 0
+
+# Extract tool info — `?` suppresses errors when tool_input arrives as a scalar
+tool_name=$(printf '%s\n' "$input" | jq -r '.tool_name? // "unknown"')
+tool_input=$(printf '%s\n' "$input" | jq -c 'if (.tool_input? | type) == "object" then .tool_input else {} end' 2>/dev/null) || tool_input='{}'
+[ -n "$tool_input" ] || tool_input='{}'
 
 SCHEMA_FILE=".claude/schemas/tool-inputs.json"
 
@@ -28,8 +33,8 @@ warnings=()
 
 case "$tool_name" in
   "Write")
-    file_path=$(printf '%s\n' "$tool_input" | jq -r '.file_path // ""')
-    content=$(printf '%s\n' "$tool_input" | jq -r '.content // ""')
+    file_path=$(printf '%s\n' "$tool_input" | jq -r '.file_path? // ""')
+    content=$(printf '%s\n' "$tool_input" | jq -r '.content? // ""')
 
     if [ -z "$file_path" ]; then
       warnings+=("[Schema] Write: file_path is empty or missing")
@@ -40,9 +45,9 @@ case "$tool_name" in
     ;;
 
   "Edit")
-    file_path=$(printf '%s\n' "$tool_input" | jq -r '.file_path // ""')
-    old_string=$(printf '%s\n' "$tool_input" | jq -r '.old_string // ""')
-    new_string=$(printf '%s\n' "$tool_input" | jq -r '.new_string // ""')
+    file_path=$(printf '%s\n' "$tool_input" | jq -r '.file_path? // ""')
+    old_string=$(printf '%s\n' "$tool_input" | jq -r '.old_string? // ""')
+    new_string=$(printf '%s\n' "$tool_input" | jq -r '.new_string? // ""')
 
     if [ -z "$file_path" ]; then
       warnings+=("[Schema] Edit: file_path is empty or missing")
@@ -56,7 +61,7 @@ case "$tool_name" in
     ;;
 
   "Bash")
-    command=$(printf '%s\n' "$tool_input" | jq -r '.command // ""')
+    command=$(printf '%s\n' "$tool_input" | jq -r '.command? // ""')
 
     if [ -z "$command" ]; then
       warnings+=("[Schema] Bash: command is empty")

package/templates/.claude/hooks/scripts/secret-filter.sh

@@ -12,9 +12,51 @@ command -v jq >/dev/null 2>&1 || exit 0
 
 input=$(cat)
 
-# Extract output to scan
-tool_name=$(printf '%s\n' "$input" | jq -r '.tool_name // "unknown"')
-output=$(printf '%s\n' "$input" | jq -r '.tool_output.output // ""')
+# Non-object stdin guard (#1650 B) — rejects ONLY non-object stdin, which carries
+# no scannable payload anyway; a well-formed object always reaches the scan below.
+printf '%s' "$input" | jq -e 'type=="object"' >/dev/null 2>&1 || exit 0
+
+tool_name=$(printf '%s\n' "$input" | jq -r '.tool_name? // "unknown"')
+
+# Collect every text-bearing field of the payload into one scan buffer.
+#
+# PostToolUse carries the result under `tool_response`, NOT `tool_output`
+# (measured 2026-09-03: 1764 PostToolUse payloads echoed into this project's
+# session transcripts had `tool_response` 1764/1764 and `tool_output` 0/1764;
+# the CC 2.1.259 embedded hook reference documents `"tool_response": {...}
+# // PostToolUse only`). Reading `.tool_output.output` therefore always yielded
+# "" and the scan below never ran — every AWS key, private key and PAT passed
+# through unflagged.
+#
+# Measured text-bearing fields, by tool:
+#   Bash   .tool_response.stdout / .stderr
+#   Read   .tool_response.file.content
+#   Write  .tool_response.content
+#   Agent  .tool_response.prompt
+#   MCP    .tool_response (string) or .tool_response.content[].text
+# `.tool_output.output` and a string-shaped `.tool_output` are kept as
+# fallbacks for events that still use the older shape (e.g. SubagentStop).
+#
+# `?` suppresses jq path errors when a field is a scalar rather than an object;
+# every branch is optional, so an unexpected shape degrades to "" instead of
+# aborting the hook under `set -euo pipefail`.
+output=$(printf '%s\n' "$input" | jq -r '
+  [
+    (.tool_response?      | if type == "string" then . else empty end),
+    (.tool_response?.stdout?        | strings),
+    (.tool_response?.stderr?        | strings),
+    (.tool_response?.content?       | strings),
+    (.tool_response?.content?       | if type == "array"
+                                      then map(.text? | strings) | join("\n")
+                                      else empty end),
+    (.tool_response?.file?.content? | strings),
+    (.tool_response?.prompt?        | strings),
+    (.tool_response?.output?        | strings),
+    (.tool_output?        | if type == "string" then . else empty end),
+    (.tool_output?.output?          | strings)
+  ]
+  | map(select(. != "")) | join("\n")
+' 2>/dev/null) || output=""
 
 # Skip if no output
 if [ -z "$output" ] || [ "$output" = "null" ]; then
@@ -44,7 +86,7 @@ if echo "$output" | grep -qE 'ghp_[a-zA-Z0-9]{36}'; then
 fi
 
 # Private Key
-if echo "$output" | grep -qE '-----BEGIN.*PRIVATE KEY-----'; then
+if echo "$output" | grep -qE -- '-----BEGIN.*PRIVATE KEY-----'; then
   echo "[Security] Potential private key detected in ${tool_name} output" >&2
   detected=true
 fi

package/templates/.claude/hooks/scripts/session-reflection.sh

@@ -13,6 +13,10 @@ set -euo pipefail
 # ── Stop hook 프로토콜: stdin을 먼저 읽음 ──
 input=$(cat)
 
+# ── 비객체 stdin 가드 (#1650 B) — 없으면 jq 파싱 오류가 pipefail로 rc=5 전파.
+# worker의 `.message.role` 트랜스크립트 파서 경로는 그대로 유지된다.
+printf '%s' "$input" | jq -e 'type=="object"' >/dev/null 2>&1 || exit 0
+
 # ── Opt-out 체크 ──
 if [ "${OMCUSTOM_SESSION_REFLECTION:-}" = "off" ]; then
   printf '%s\n' "$input"
@@ -40,7 +44,7 @@ bg_tasks_count=$(printf '%s\n' "$bg_tasks_json" | jq 'length' 2>/dev/null || ech
 session_crons_count=$(printf '%s\n' "$session_crons_json" | jq 'length' 2>/dev/null || echo 0)
 
 # 미완료 백그라운드 태스크: running/pending/in_progress 상태 카운트
-bg_dangling_count=$(printf '%s\n' "$bg_tasks_json" | jq '[.[] | select(.status == "running" or .status == "pending" or .status == "in_progress")] | length' 2>/dev/null || echo 0)
+bg_dangling_count=$(printf '%s\n' "$bg_tasks_json" | jq '[.[] | select(.status? == "running" or .status? == "pending" or .status? == "in_progress")] | length' 2>/dev/null || echo 0)
 
 # ── 경로 결정 (환경변수 override 지원) ──
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

package/templates/.claude/hooks/scripts/stuck-detector.sh

@@ -204,17 +204,34 @@ _strip_heredoc_bodies() {
   local text="$1"
   local out="" line tok delim="" in_body=0
   local before_op dq sq
+  # A literal single quote cannot be written inside the bracket expression of
+  # the quote-counting expansion below, so hold one in a variable.
+  local sq_char="'"
   while IFS= read -r line; do
     if [ "$in_body" -eq 1 ]; then
       # "<<-" allows leading tabs before the terminator; accept leading
-      # whitespace for either form.
-      tok="$(printf '%s' "$line" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')"
+      # whitespace for either form. The trim is pure parameter expansion: as
+      # "printf | sed" it cost TWO forks on every BODY line, which is the
+      # dominant cost of a long heredoc (measured: a 1000-line body took
+      # 1.8 s of hook latency, #1650 A).
+      tok="${line#"${line%%[![:space:]]*}"}"
+      tok="${tok%"${tok##*[![:space:]]}"}"
       if [ "$tok" = "$delim" ]; then
         in_body=0
       fi
       continue
     fi
     out="${out}${line}"$'\n'
+    # A line with no "<<" can open no heredoc, so neither the forgery guard nor
+    # the delimiter scan below has anything to find on it. Skipping them keeps
+    # the extraction "sed" off every ordinary line, which used to run
+    # unconditionally — two more forks per line (#1650 A). "delim" must still be
+    # cleared here, or a delimiter captured on an EARLIER line would re-open a
+    # body on this one.
+    case "$line" in
+      *'<<'*) ;;
+      *) delim=""; continue ;;
+    esac
     # A DELIMITER FORGERY guard: the extraction below has no idea whether the
     # "<<" it finds is shell syntax or literal text inside a quoted string, so
     # `echo "a << EOF"` followed by `rm -rf x` and a line reading `EOF` used to
@@ -226,14 +243,15 @@ _strip_heredoc_bodies() {
     # as a write. "${line%<<*}" strips the shortest matching suffix, i.e. it
     # yields the text before the LAST "<<" — the same occurrence the greedy
     # extraction regex below settles on.
-    if [ "$line" != "${line%<<*}" ]; then
-      before_op="${line%<<*}"
-      dq="$(printf '%s' "$before_op" | tr -cd '"' | wc -c | tr -d '[:space:]')"
-      sq="$(printf '%s' "$before_op" | tr -cd "'" | wc -c | tr -d '[:space:]')"
-      if [ $((dq % 2)) -eq 1 ] || [ $((sq % 2)) -eq 1 ]; then
-        printf '%s' "${out}__QUOTED_HEREDOC_OPENER__"$'\n'
-        return 0
-      fi
+    # The quote counts are parameter expansions rather than
+    # "printf | tr | wc | tr" (four more forks per opener line): "${v//[^X]/}"
+    # deletes everything that is not X, so the remaining LENGTH is the count.
+    before_op="${line%<<*}"
+    dq="${before_op//[^\"]/}"
+    sq="${before_op//[^$sq_char]/}"
+    if [ $(( ${#dq} % 2 )) -eq 1 ] || [ $(( ${#sq} % 2 )) -eq 1 ]; then
+      printf '%s' "${out}__QUOTED_HEREDOC_OPENER__"$'\n'
+      return 0
     fi
     delim="$(printf '%s' "$line" \
       | sed -n -E "s/^.*[^<]<<-?[[:space:]]*[\"']?([A-Za-z_][A-Za-z0-9_]*)[\"']?.*\$/\\1/p")"
@@ -453,7 +471,12 @@ is_readonly_bash_command() {
     normalized="${normalized//|/$'\n'}"
     local seg
     while IFS= read -r seg; do
-      seg="$(printf '%s' "$seg" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')"
+      # Pure parameter expansion, not "printf | sed": each segment is a single
+      # line, so the two forms trim identically, but the sed form spent two
+      # forks on EVERY segment of a multi-line command (measured: 300
+      # newline-separated segments took 0.8 s of hook latency, #1650 A).
+      seg="${seg#"${seg%%[![:space:]]*}"}"
+      seg="${seg%"${seg##*[![:space:]]}"}"
       if [ -z "$seg" ]; then
         echo "false"
         return 0
@@ -472,6 +495,15 @@ is_readonly_bash_command() {
 
 input=$(cat)
 
+# A hook must never crash the tool call it observes. stdin that is not a JSON
+# OBJECT — empty, a bare scalar, a JSON array, truncated, or not JSON at all —
+# carries no tool record, and the very first "jq -r" below died on it; with
+# "set -euo pipefail" that took the WHOLE hook down with rc=5 (#1650 B).
+# Swallow it instead: exit 0 with no stdout, exactly as if the hook had not
+# run. "jq -e" exits non-zero both for a parse error and for a false/null
+# result, so one guard covers every non-object shape.
+printf '%s' "$input" | jq -e 'type == "object"' >/dev/null 2>&1 || exit 0
+
 # Extract tool info
 tool_name=$(printf '%s' "$input" | jq -r '.tool_name // "unknown"')
 # Bash commands are NOT files. Feeding tool_input.command into file_path made

package/templates/.claude/hooks/scripts/task-outcome-recorder.sh

@@ -11,28 +11,35 @@ command -v jq >/dev/null 2>&1 || exit 0
 
 input=$(cat)
 
-# Extract task info — support both PostToolUse (tool_input.*) and SubagentStop (top-level) shapes
-agent_type=$(printf '%s\n' "$input" | jq -r '.tool_input.subagent_type // .agent_type // "unknown"')
-model=$(printf '%s\n' "$input" | jq -r '.tool_input.model // .model // "inherit"')
-description=$(printf '%s\n' "$input" | jq -r '.tool_input.description // .description // ""' | head -c 80)
+# Non-object stdin guard (#1650 B): a hook must never crash on garbage stdin.
+# jq's parse error propagates through `set -euo pipefail` as rc=5 without this.
+printf '%s' "$input" | jq -e 'type=="object"' >/dev/null 2>&1 || exit 0
+
+# Extract task info — support both PostToolUse (tool_input.*) and SubagentStop (top-level) shapes.
+# `?` suppresses "Cannot index string with ..." when tool_input arrives as a scalar.
+agent_type=$(printf '%s\n' "$input" | jq -r '.tool_input.subagent_type? // .agent_type? // "unknown"')
+model=$(printf '%s\n' "$input" | jq -r '.tool_input.model? // .model? // "inherit"')
+description=$(printf '%s\n' "$input" | jq -r '.tool_input.description? // .description? // ""' | head -c 80)
 
 # Extract skill name from description or prompt
 skill_name=""
+# `|| true`: a no-match grep exits 1 and `set -euo pipefail` would abort the hook
+# (measured rc=1 on empty stdin AND on a well-formed object with no skill name).
 if echo "$description" | grep -qiE '(skill:|routing|→.*skill)'; then
-  skill_name=$(echo "$description" | grep -oiE '[a-z]+-[a-z]+(-[a-z]+)*-?(routing|skill|practices|detection|decomposition|orchestration|pipeline|guards|cycle|plan|review|refactor|publish|version|audit|exec|analyze|bundle|report|setup|watch|lists|status|help|save|recall)' | head -1)
+  skill_name=$(echo "$description" | grep -oiE '[a-z]+-[a-z]+(-[a-z]+)*-?(routing|skill|practices|detection|decomposition|orchestration|pipeline|guards|cycle|plan|review|refactor|publish|version|audit|exec|analyze|bundle|report|setup|watch|lists|status|help|save|recall)' | head -1 || true)
 fi
 # Fallback: check prompt field for "Skill: {name}" pattern
 if [ -z "$skill_name" ]; then
-  prompt=$(printf '%s\n' "$input" | jq -r '.tool_input.prompt // ""' | head -c 500)
-  skill_name=$(echo "$prompt" | grep -oiE 'Skill:\s*[a-z]+-[a-z]+(-[a-z]+)*' | sed 's/[Ss]kill:\s*//' | head -1)
+  prompt=$(printf '%s\n' "$input" | jq -r '.tool_input.prompt? // ""' | head -c 500)
+  skill_name=$(echo "$prompt" | grep -oiE 'Skill:\s*[a-z]+-[a-z]+(-[a-z]+)*' | sed 's/[Ss]kill:\s*//' | head -1 || true)
 fi
 
 # Determine outcome
-is_error=$(printf '%s\n' "$input" | jq -r '.tool_output.is_error // false')
+is_error=$(printf '%s\n' "$input" | jq -r '.tool_output.is_error? // false')
 
 if [ "$is_error" = "true" ]; then
   outcome="failure"
-  error_summary=$(printf '%s\n' "$input" | jq -r '.tool_output.output // ""' | head -c 200)
+  error_summary=$(printf '%s\n' "$input" | jq -r '.tool_output.output? // ""' | head -c 200)
 else
   outcome="success"
   error_summary=""

package/templates/.claude/rules/MUST-enforcement-policy.md

@@ -16,7 +16,7 @@ oh-my-customcode uses an **advisory-first enforcement model**. Most rules are en
 | Soft Block | Stop hook prompt | R011 session-end saves | Auto-performs then approves |
 | Conversation Block | PostToolUse hook + `continueOnBlock` (CC v2.1.139+), exit 2 | stuck-detector, context-budget-advisor, cost-cap-advisor | Feeds rejection reason into conversation; Claude continues with awareness |
 | Advisory | PostToolUse hooks | R007, R008, R009, R010, R018 | Warns via stderr, never blocks |
-| Advisory (proactive) | UserPromptSubmit + SubagentStop + PostToolUse hooks | R007, R008 (`r007-r008-drift-advisor.sh` — #1229 UserPromptSubmit, #1545 SubagentStop, #1553 PostToolUse) | Reads last assistant turn; emits advisory if header/prefix absent. SubagentStop wiring (#1545) closes the no-user-input autonomous-loop gap (`/fsd`); PostToolUse (#1553) covers the orchestrator-only stretch before the first subagent spawn. Complements retroactive Stop-hook (`session-reflection.sh`, #1190). **v1.1.43부터 실제 발화 — 아래 각주 참조.** v1.1.49부터 역방향(announce > tool_use) 신호 포함, 기본 off 옵트인 (#1595 #6). |
+| Advisory (proactive) | UserPromptSubmit + SubagentStop + PostToolUse hooks | R007, R008 (`r007-r008-drift-advisor.sh` — #1229 UserPromptSubmit, #1545 SubagentStop, #1553 PostToolUse) | Reads last assistant turn; emits advisory if header/prefix absent. SubagentStop wiring (#1545) closes the no-user-input autonomous-loop gap (`/fsd`); PostToolUse (#1553) covers the orchestrator-only stretch before the first subagent spawn. Complements retroactive Stop-hook (`session-reflection.sh`, #1190). **v1.1.43부터 실제 발화 — 아래 각주 참조.** v1.1.49부터 역방향(announce > tool_use) 신호 포함, 기본 off 옵트인 (#1595 #6). **v1.1.62(#1650 D)부터 서브에이전트 세션에서는 침묵**: hook stdin의 `agent_id`(CC 스키마상 서브에이전트 내부 발화에만 존재)가 있으면 exit 0 — 단 `SubagentStart`/`SubagentStop`은 `agent_id`가 대상 식별자라 예외(판정 수행). 중첩 서브에이전트 안의 SubagentStop은 억제 못 함(R010 정책상 도달 불가 경로). 완료 보고가 advisory 응답으로 대체되던 훅 피드백 잠식(R020 8항, #1652 #3)의 advisory 계열 차단. |
 | Advisory (telemetry) | PostToolUseFailure hook | — (계측 전용, 규칙 강제 없음) | `failure-ledger.sh` (#1561, v1.1.44) — 도구 실패를 JSONL 원장에 append. stdout/stderr 무출력이라 모델에 도달하지 않으며 절대 차단하지 않음 |
 | Advisory (proactive) | UserPromptSubmit hook | R020 (원인 진단) | `fail-axis-cause-advisor.sh` (#1561, v1.1.44) — 원장에 실패 기록이 있는데 원인 진술 없는 재촉 프롬프트가 오면 `hookSpecificOutput.additionalContext`로 "원인 가설 되묻기" advisory 전달. 원장 부재 시 조용히 통과 |
 | Prompt-based | CLAUDE.md + rules/ + `SessionStart` 재주입(matcher `*`; PostCompact 이벤트 배선은 유지되나 효과 미보장[^postcompact]) | All MUST rules | Behavioral guidance in context |

package/templates/.claude/rules/MUST-tool-identification.md

@@ -78,7 +78,7 @@ Agent(description: "[2] Python code review", subagent_type: "lang-python-expert"
 
 Single agent spawns do NOT use the `[N]` prefix.
 
-**단일 스폰도 Core Rule 접두사 필수 (Origin: #1652 #3-3)**: 단일 Agent 스폰은 `[N]` 항목 형식 대신 Core Rule 형식의 접두사 라인(에이전트·모델 대괄호 + 화살표 + Tool 표기 + `Agent`)을 호출 직전에 출력한다. advisor(`.claude/hooks/scripts/r007-r008-drift-advisor.sh`)가 announce로 계수하는 것은 3종 — Tool 표기 라인, Spawning 헤더 라인(대괄호 번호 항목이 0개일 때 폴백으로 계수), 대괄호 번호가 붙은 spawn 항목 — 이며, **대괄호 번호 없이 에이전트타입:모델 다음에 화살표와 설명만 이어붙인 단독 라인은 계수하지 않는다** — Tool 표기 라인도 Spawning 헤더도 없이 그 단독 라인만 쓰면 규칙을 지킨 응답이 R008 누락 1건으로 계상된다(v1.1.60 세션 실측 — advisory가 반복돼 세션 중 접두사 형식을 바꿔야 했다; v1.1.61 적대적 리뷰가 합성 트랜스크립트 양성/음성 짝으로 재현). 정합 방향은 **규칙 문구 쪽**으로 확정한다. advisor 정규식 쪽 대안(번호 없는 단독 라인을 spawn 항목으로 계수)은 `.claude/hooks/**` 승인 사안이라 **#1650 E 항목**으로 이월했으며, 적용 시 이 조항의 advisor 동작 서술을 같은 커밋에서 갱신한다(R016 Rule Wiring Check).
+**단일 스폰도 Core Rule 접두사 필수 (Origin: #1652 #3-3, advisor 정합 #1650 E)**: 단일 Agent 스폰은 `[N]` 항목 형식 대신 Core Rule 형식의 접두사 라인(에이전트·모델 대괄호 + 화살표 + Tool 표기 + `Agent`)을 호출 직전에 출력한다. advisor(`.claude/hooks/scripts/r007-r008-drift-advisor.sh`)가 announce로 계수하는 것은 4종 — Tool 표기 라인, 대괄호 번호가 붙은 spawn 항목, **대괄호 번호 없이 에이전트타입:모델 다음에 화살표와 설명이 이어지는 단독 라인**(#1650 E에서 추가), Spawning 헤더 라인 — 이며 스폰 표기 3종은 **번호 항목 > 단독 라인 > Spawning 헤더** 순으로 하나만 채택된다. 단독 라인만 쓴 응답이 R008 누락으로 오계상되던 결함은 v1.1.62에서 해소됐다(v1.1.60 세션 실측 → v1.1.61 적대적 리뷰 재현 → #1650 E 적용). **다만 규칙이 요구하는 형식은 여전히 Core Rule 접두사 라인이다** — 단독 라인 계수는 오탐 제거이지 표기 승격이 아니다. 접두사 라인과 단독 라인이 함께 있으면 advisor는 단독 라인을 **동반 라인으로 보아 차감**하므로(Target 라인과 동일 취급) 병기해도 이중 계수되지 않는다. **단독 라인은 반드시 줄 시작(선행 공백만 허용)이어야 한다** — 리스트 마커가 앞에 붙으면 계수되지 않는다. advisor 판정식을 바꿀 때 이 문단을 같은 커밋에서 갱신한다(R016 Rule Wiring Check).
 
 ```
 [claude][opus] → Tool: Agent

package/templates/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.61",
+  "version": "1.1.62",
   "lastUpdated": "2026-09-03",
   "omcustomMinClaudeCode": "2.1.121",
   "omcustomMinClaudeCodeReason": "Sensitive-path direct Write/Edit on .claude/** under bypassPermissions (R010 deprecation, #1101)",