oh-my-customcode 2.0.7 → 2.0.8

package/templates/.claude/hooks/scripts/omcustom-auto-update.sh

@@ -30,8 +30,20 @@ if ! [ -c /dev/tty ] 2>/dev/null; then
 fi
 
 # --- Configuration ---
-CACHE_DIR="$HOME/.oh-my-customcode"
-CACHE_FILE="${CACHE_DIR}/self-update-cache.json"
+# Cache location. Deliberate difference from the TS resolver (src/utils/home.ts
+# resolveHomeDir, which falls back to the OS/passwd home): when HOME is unset, empty or not
+# an absolute path, this hook SKIPS the cache entirely (no read, no write, no mkdir) rather
+# than resolving to "/.oh-my-customcode" or a passwd home (#1775).
+CACHE_ENABLED=true
+CACHE_DIR=""
+CACHE_FILE=""
+case "${HOME:-}" in
+  /*)
+    CACHE_DIR="$HOME/.oh-my-customcode"
+    CACHE_FILE="${CACHE_DIR}/self-update-cache.json"
+    ;;
+  *) CACHE_ENABLED=false ;;
+esac
 CACHE_MAX_AGE=3600  # 1 hour in seconds
 NPM_TIMEOUT=3       # seconds for npm view
 INPUT_TIMEOUT=10     # seconds for user prompt
@@ -69,10 +81,12 @@ LATEST_VERSION=""
 CACHE_HIT=false
 
 # Ensure cache directory exists
-mkdir -p "$CACHE_DIR" 2>/dev/null
+if [ "$CACHE_ENABLED" = true ]; then
+  mkdir -p "$CACHE_DIR" 2>/dev/null
+fi
 
 # Check cache freshness
-if [ -f "$CACHE_FILE" ]; then
+if [ "$CACHE_ENABLED" = true ] && [ -f "$CACHE_FILE" ]; then
   CACHE_TIMESTAMP=$(grep -o '"timestamp"[[:space:]]*:[[:space:]]*[0-9]*' "$CACHE_FILE" 2>/dev/null | grep -o '[0-9]*$')
   CACHED_VERSION=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$CACHE_FILE" 2>/dev/null | grep -o '"[^"]*"$' | tr -d '"')
 
@@ -93,7 +107,7 @@ if [ "$CACHE_HIT" = false ]; then
     LATEST_VERSION=$(timeout "$NPM_TIMEOUT" npm view "$PACKAGE_NAME" version 2>/dev/null || echo "")
 
     # Update cache on successful fetch
-    if [ -n "$LATEST_VERSION" ]; then
+    if [ -n "$LATEST_VERSION" ] && [ "$CACHE_ENABLED" = true ]; then
       NOW=$(date +%s)
       cat > "$CACHE_FILE" << EOF
 {

package/templates/.claude/hooks/scripts/rule-deletion-guard.sh

@@ -9,7 +9,31 @@
 # destructive verb, destructive verb in a non-head position, unresolvable expansion in a target,
 # opaque constructs such as eval / sh -c / $(...) / backticks / source, parse errors, unknown cwd,
 # analyzer exceptions) -> strict legacy regex check (blocks if the pre-#1782 logic would block).
+# Opaque markers are looked for outside quoted text (#1859): markers inside a quoted string whose last
+# path component contains whitespace no longer force the fallback (the shell does not run them as a
+# command); single-quoted `$(`/backticks are likewise ignored. `$(` and backticks inside double quotes,
+# and any other quoted string (it may be the command, e.g. "eval", "/my dir/bash"), stay opaque.
+# The fallback fires only if the raw command AND its masked copy both match.
 # No python3: legacy regex check (needs jq). Neither python3 nor jq: fail-open (exit 0).
+#
+# Intended limitation (#1784): the blocked set is the one modelled above (v1.1.95, #1782: rm/unlink/
+# rmdir/shred/truncate, mv, find, xargs, git rm|mv|clean, writing redirects); the exclusion of the
+# overwrite/interpreter forms is recorded at
+# https://github.com/baekenough/oh-my-customcode/issues/1784#issuecomment-6405528206 . Content-overwrite
+# forms (cp /dev/null, tee, dd of=, sed -i, ln -sf, install, rsync --delete, tar --remove-files,
+# git checkout -- / restore / stash), interpreter one-liners (perl -e, python -c, node -e) and shell
+# aliases and git clean -f without -d run from an ancestor of a rule dir (e.g. the project root, where it can still remove untracked files inside the rule dirs; a target or cwd inside a rule dir is blocked) are NOT blocked: they are edit-class or interpreter forms whose blocking
+# would raise false positives like #1859, and git history is the recovery path.
+#
+# Residual limits accepted with the #1859 change: (a) a quoted payload that carries an opaque marker
+# and is handed to an executor the analyzer does not model (ssh, su -c, script -c, ..., or stdin piped
+# to a shell: `| bash`, `| sh`) is no longer forced to the fallback, so it is not inspected - the same
+# as such payloads without a marker always were; `env -S` / `--split-string` is likewise not parsed:
+# unwrap() sends it to the legacy regex check only; (b) the quoted-option gap predates it: `bash "-c"
+# ...` is not recognised as `-c`, because the marker pattern needs whitespace right before an unquoted
+# `-`; (c) a quoted string is treated as text
+# only when its last path component (after the final `/`) contains whitespace, so a lone quoted word
+# or path to a binary stays visible and still falls back (conservative).
 
 set -uo pipefail
 
@@ -259,6 +283,97 @@ def low(s):
     return s.lower()
 
 
+def _blank_quoted(body, double):
+    """Blank the inside of one quoted string for the OPAQUE scan (#1859).
+
+    A string whose last path component (after the final `/`) contains whitespace cannot name a shell
+    binary or `eval`/`source`, so the markers in it are not run as a command by that shell: everything
+    is blanked, except `$(` and backticks inside double quotes (the shell expands those). This does
+    not make the text safe: a payload handed to another executor (ssh, su -c, ...) is not inspected.
+    Any other string may BE the command (`"eval"`, `'sh'`, `"/my dir/bash"`), so it stays visible;
+    only the `$(`/backtick of a single-quoted one, which the shell never expands, is neutralised.
+    """
+    if not any(ch.isspace() for ch in body.rsplit('/', 1)[-1]):
+        return body if double else body.replace('$(', '_(').replace('`', '_')
+    if not double:
+        return '_' * len(body)
+    res, k = [], 0
+    while k < len(body):
+        if body.startswith('$(', k):
+            res.append('$(')
+            k += 2
+        else:
+            res.append(body[k] if body[k] == '`' else '_')
+            k += 1
+    return ''.join(res)
+
+
+def mask_quoted(s):
+    """Copy of `s` for the OPAQUE scan with non-executable quoted text blanked (#1859).
+
+    Mirrors the quote handling of lex(). When unsure (heredoc operator, unterminated quote) the rest
+    of the text is returned unmasked, so the scan is then at least as strict as on the raw command.
+    Unquoted text, comments and `$'...'` strings are never touched.
+    """
+    out, n, i = [], len(s), 0
+    wordstart = True
+    while i < n:
+        c = s[i]
+        if c in ' \t\n':
+            out.append(c)
+            i += 1
+            wordstart = True
+        elif s.startswith('<<<', i):
+            out.append('<<<')
+            i += 3
+            wordstart = True
+        elif s.startswith('<<', i):
+            return ''.join(out) + s[i:]  # heredoc body is skipped by lex(): quote state is unknowable
+        elif c in ';&|<>()':
+            out.append(c)
+            i += 1
+            wordstart = True
+        elif c == '#' and wordstart:
+            j = s.find('\n', i)
+            j = n if j < 0 else j
+            out.append(s[i:j])
+            i = j
+        elif c == '\\':
+            out.append(s[i:i + 2])
+            i += 2
+            wordstart = False
+        elif c == '$' and s.startswith("$'", i):
+            j = i + 2
+            while j < n and s[j] != "'":
+                j += 2 if s[j] == '\\' else 1
+            if j >= n:
+                return ''.join(out) + s[i:]
+            out.append(s[i:j + 1])
+            i = j + 1
+            wordstart = False
+        elif c == "'":
+            j = s.find("'", i + 1)
+            if j < 0:
+                return ''.join(out) + s[i:]
+            out.append("'" + _blank_quoted(s[i + 1:j], False) + "'")
+            i = j + 1
+            wordstart = False
+        elif c == '"':
+            j = i + 1
+            while j < n and s[j] != '"':
+                j += 2 if s[j] == '\\' and j + 1 < n and s[j + 1] in '$`"\\\n' else 1
+            if j >= n:
+                return ''.join(out) + s[i:]
+            out.append('"' + _blank_quoted(s[i + 1:j], True) + '"')
+            i = j + 1
+            wordstart = False
+        else:
+            out.append(c)
+            i += 1
+            wordstart = False
+    return ''.join(out)
+
+
 def main(d, cmd):
     start = d.get('cwd')
     if isinstance(start, str) and os.path.isdir(start):
@@ -280,7 +395,9 @@ def main(d, cmd):
             low(os.path.join(root, 'templates', '.claude', 'rules'))]
 
     cmd = cmd.replace('\r', '').replace('\\\n', '')
-    if OPAQUE.search(cmd):
+    # Fall back only when BOTH scans match: masking must never add a fallback the raw scan lacks
+    # (blanking `; | & \n` inside quotes can otherwise create an `sh ... -c` match, #1859 review F1).
+    if OPAQUE.search(cmd) and OPAQUE.search(mask_quoted(cmd)):
         return 3
     try:
         toks = lex(cmd)

package/templates/.claude/hooks/scripts/session-env-check.sh

@@ -99,7 +99,14 @@ fi
 
 # Drift Detection: compare git HEAD between sessions
 DRIFT_STATUS="not-git"
-if command -v git >/dev/null 2>&1 && git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+# When HOME is unset, empty or not an absolute path, skip the session-state write entirely
+# (no mkdir, no state file; drift stays "not-git") instead of aborting under set -eu or
+# writing to "/.claude/..." (#1775; same rule as the self-update cache below).
+HOME_ABSOLUTE=false
+case "${HOME:-}" in
+  /*) HOME_ABSOLUTE=true ;;
+esac
+if [ "$HOME_ABSOLUTE" = true ] && command -v git >/dev/null 2>&1 && git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
   SESSION_STATE_DIR="$HOME/.claude/session-state"
   mkdir -p "$SESSION_STATE_DIR"
 
@@ -132,8 +139,10 @@ if command -v git >/dev/null 2>&1 && git rev-parse --is-inside-work-tree >/dev/n
 fi
 
 # --- CI Status Check ---
-# Check last CI run status if gh CLI is available
-if command -v gh &>/dev/null; then
+# Check last CI run status if gh CLI is available.
+# Skipped when HOME is not absolute (HOME_ABSOLUTE, set above): external CLIs keep state under
+# $HOME and would write it into the cwd (the project dir) instead (#1775).
+if [ "$HOME_ABSOLUTE" = true ] && command -v gh &>/dev/null; then
   ci_status=$(gh run list --limit 1 --json conclusion -q '.[0].conclusion' 2>/dev/null || echo "unknown")
   ci_name=$(gh run list --limit 1 --json name -q '.[0].name' 2>/dev/null || echo "unknown")
   if [ "$ci_status" = "failure" ]; then
@@ -179,8 +188,14 @@ fi
 # the hard-coded "latestVersion" lookup matched nothing. Read `latestVersion` first, then fall
 # back to `version`. The `"version"` pattern includes the opening quote, so it cannot
 # accidentally match the tail of `"latestVersion"`.
-CACHE_FILE="$HOME/.oh-my-customcode/self-update-cache.json"
-if [ -f "$CACHE_FILE" ]; then
+# Deliberate difference from the TS resolver (src/utils/home.ts resolveHomeDir falls back to
+# the OS/passwd home): when HOME is unset, empty or not an absolute path, skip the cache
+# entirely instead of reading "/.oh-my-customcode/..." (#1775).
+CACHE_FILE=""
+case "${HOME:-}" in
+  /*) CACHE_FILE="$HOME/.oh-my-customcode/self-update-cache.json" ;;
+esac
+if [ -n "$CACHE_FILE" ] && [ -f "$CACHE_FILE" ]; then
   CACHED_LATEST=$(json_string_field "$CACHE_FILE" "latestVersion")
   if [ -z "$CACHED_LATEST" ]; then
     CACHED_LATEST=$(json_string_field "$CACHE_FILE" "version")

package/templates/.claude/hooks/scripts/stall-detection-advisor.sh

@@ -11,9 +11,11 @@ set -euo pipefail
 # array/scalar payloads gave rc=5 (unguarded `jq` agent_type extraction); a well-formed payload with a
 # 300KB `.description` gave rc=141 (5/5; 70KB rc=0; boundary near 81,920 bytes here, platform-dependent; `| head -c 80` SIGPIPE under pipefail). CC sends objects and
 # SubagentStop has no `.description`, so these paths are not reached at runtime.
-# Start-record `start_epoch`: "abc" gives rc=1 (`set -u`: "abc: unbound variable"); arithmetic-syntax
-# values ("1792939922.5", "09") print an error and give rc=1 (`set -u`: "duration_seconds: unbound
-# variable"); "" gives rc=0.
+# Start-record `start_epoch` (also the still-running-agent `running_start`): a value that is not a
+# positive decimal integer without a leading zero ("", "0", "null", "abc", "1792939922.5", "09", "-5")
+# is treated as no start record: rc=0, nothing recorded for the completing agent, and the loop skips
+# that running entry (measured on bash 3.2; before this check "abc"/"1792939922.5"/"09" gave rc=1 and
+# "" recorded now_epoch, about 1.79e9, as the duration).
 
 # ORDERING: This hook MUST run AFTER task-outcome-recorder.sh in hooks.json SubagentStop array.
 # Reason: This script removes consumed entries from AGENT_START_FILE; task-outcome-recorder reads them first.
@@ -36,7 +38,9 @@ description=$(printf '%s\n' "$input" | jq -r '.description // ""' | head -c 80)
 # --- 2. Calculate duration from start record ---
 start_epoch=$(grep -F "\"agent_type\":\"${agent_type}\"" "$AGENT_START_FILE" 2>/dev/null | tail -1 | jq -r '.start_epoch // "0"' 2>/dev/null || echo "0")
 
-if [ "$start_epoch" = "0" ] || [ "$start_epoch" = "null" ]; then
+# Only a positive decimal integer without a leading zero is a usable epoch; anything else
+# ("", "0", "null", "abc", "1792939922.5", "09", negatives) is treated as no start record.
+if ! [[ "$start_epoch" =~ ^[1-9][0-9]*$ ]]; then
   printf '%s\n' "$input"
   exit 0
 fi
@@ -70,7 +74,7 @@ if [ "$completed_count" -ge 1 ]; then
         running_desc=$(printf '%s\n' "$line" | jq -r '.description // ""' 2>/dev/null || true)
         running_model=$(printf '%s\n' "$line" | jq -r '.model // "inherit"' 2>/dev/null || true)
 
-        if [ "$running_start" = "0" ] || [ "$running_start" = "null" ]; then continue; fi
+        if ! [[ "$running_start" =~ ^[1-9][0-9]*$ ]]; then continue; fi
 
         elapsed=$((now_epoch - running_start))
 

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

@@ -545,6 +545,7 @@ extraction_mode=$(printf '%s' "$input" | jq -er '
   elif ((.tool_name // "unknown" | type) != "string") then "legacy"
   elif ((.tool_input != null) and ((.tool_input | type) != "object")) then "legacy"
   elif ((.tool_output != null) and ((.tool_output | type) != "object")) then "legacy"
+  elif ((.tool_response != null) and ((.tool_response | type) != "object")) then "legacy"
   elif ((.tool_input.file_path // "" | type) != "string")
     or ((.tool_input.command // "" | type) != "string")
     or ((.tool_input.old_string // .tool_input.content // .tool_input.new_string // "" | type) != "string")
@@ -579,6 +580,22 @@ _read_stuck_fields() {
 
 TARGET_KEY_CAP=1000
 
+# PostToolUse carries "tool_response", never "tool_output" (#1775; probe: CC
+# 2.1.310, "claude -p", one run, model haiku). Measured Bash shape: object
+# {interrupted,isImage,noOutputExpected,stderr,stdout}; no measured PostToolUse
+# shape has is_error. Bash failures arrive via PostToolUseFailure (a Bash exit 3
+# produced PostToolUseFailure with error "Exit code 3"), which this hook is not
+# wired to, so the is_error path stays inert for Bash. Read tool_response first;
+# ".tool_output" is a legacy fallback only. A non-object tool_response routes to
+# the "legacy" extraction path (see extraction_mode) and is used as text only
+# when it is a string.
+JQ_IS_ERROR='((.tool_response | if type == "object" then .is_error else null end) // .tool_output.is_error // false)'
+JQ_OUTPUT_PREVIEW='((.tool_response) as $r
+  | if ($r | type) == "object" and (($r.stdout | type) == "string") then $r.stdout
+    elif ($r | type) == "string" then $r
+    else (.tool_output.output // "") end
+  | tostring)[0:200]'
+
 truncate_key() {
   local v="$1"
   if [ "${#v}" -gt "$TARGET_KEY_CAP" ]; then
@@ -595,7 +612,7 @@ if [ "$extraction_mode" = "batched" ]; then
     (if (.tool_name // "unknown") == "Bash"
       then (.tool_input.command // .tool_input.file_path // "")
       else (.tool_input.file_path // "") end), "\u0000",
-    (.tool_output.is_error // false), "\u0000"'
+    '"$JQ_IS_ERROR"', "\u0000"'
   [ "${#STUCK_FIELDS[@]}" -eq 3 ] || exit 1
   tool_name="${STUCK_FIELDS[0]}"
   if [ "$tool_name" = "Bash" ]; then
@@ -608,7 +625,7 @@ if [ "$extraction_mode" = "batched" ]; then
   fi
   is_error="${STUCK_FIELDS[2]}"
   output_preview=$(printf '%s' "$input" \
-    | jq -r '(.tool_output.output // "" | tostring)[0:200]' \
+    | jq -r "$JQ_OUTPUT_PREVIEW" \
     | head -c 200 || true)
   _read_stuck_fields '(.tool_input.command // ""), "\u0000",
     (if (.tool_name == "Edit" or .tool_name == "Write")
@@ -653,7 +670,7 @@ else
   file_path=$(printf '%s' "$file_path_full" | head -c "$TARGET_KEY_CAP" || true)
   target_key=$(truncate_key "$file_path_full")
 fi
-is_error=$(printf '%s' "$input" | jq -r '.tool_output.is_error // false')
+is_error=$(printf '%s' "$input" | jq -r "$JQ_IS_ERROR")
 # "head -c 200" closes the pipe after 200 bytes. Once tool_output.output is
 # larger than the pipe buffer (~64 KB), jq keeps writing, dies of SIGPIPE
 # (exit 141), and "set -o pipefail" + "set -e" aborted the ENTIRE hook before
@@ -664,7 +681,7 @@ is_error=$(printf '%s' "$input" | jq -r '.tool_output.is_error // false')
 # enforced by head (jq slices by codepoint, head by byte, and 200 codepoints
 # are always >= 200 bytes, so the resulting bytes are unchanged).
 output_preview=$(printf '%s' "$input" \
-  | jq -r '(.tool_output.output // "" | tostring)[0:200]' \
+  | jq -r "$JQ_OUTPUT_PREVIEW" \
   | head -c 200 || true)
 raw_command=$(printf '%s' "$input" | jq -r '.tool_input.command // ""')
 

package/templates/.claude/hooks/scripts/subagent-failure-advisor.sh

@@ -5,38 +5,57 @@ set -euo pipefail
 command -v jq >/dev/null 2>&1 || exit 0
 
 # Subagent Failure Advisor Hook
-# Trigger: SubagentStop
-# Purpose: Advisory-only replacement for the removed `type: "prompt"` SubagentStop hook
-#   (#1631). The prompt hook asked an LLM judge whether the CURRENT session's own
-#   background_tasks entry had transitioned to "completed" before allowing Stop —
-#   but that transition only happens AFTER the SubagentStop hook chain resolves, so the
-#   judgment was structurally always "not yet completed" for a subagent evaluating its
-#   OWN stop. That produced a self-referential `Stop hook feedback:` re-injection loop
-#   with no dedup, observed to repeat 8-10x per session before manual override.
-# Fix: replace the blocking LLM judge with a plain stderr-only warning that never
-#   triggers the Stop-hook-feedback re-injection path. No block, no LLM call, no loop.
-# Protocol: stdin JSON -> read tool_output.is_error -> stderr warning if failed -> pass through -> exit 0
-# Exit status (MEASURED, bash 3.2, `set -euo pipefail`): rc=0 in every probe (well-formed payload,
-# is_error=true payload, malformed JSON, empty stdin, array/scalar payloads) except one synthetic case:
-# the jq calls for is_error and agent_type are guarded with `|| echo`, but the error_summary pipeline
-# (`jq ... | head -c 200`) is not; with is_error=true and a 300KB `tool_output.output` it gave rc=141
-# (SIGPIPE under pipefail, 3/3). SubagentStop payloads have no `tool_output`, so is_error is always
-# false there and that path is unreachable at runtime.
+# Trigger: PostToolUseFailure (matcher: Agent / Task tool)
+# Purpose: Advisory-only. When an Agent/Task tool call fails, tell the model not to
+#   auto-continue as if the subagent had succeeded. Replaces the removed
+#   `type: "prompt"` SubagentStop hook (#1631), whose LLM judge was structurally
+#   always "not yet completed" and produced a Stop-hook-feedback re-injection loop.
+# Why not SubagentStop (#1775): the SubagentStop payload has no tool_response /
+#   tool_output / is_error (measured keys on CC 2.1.310, `claude -p`, haiku, one run, see
+#   https://github.com/baekenough/oh-my-customcode/issues/1775#issuecomment-6404861043: agent_id, agent_transcript_path, agent_type,
+#   background_tasks, cwd, effort, hook_event_name, last_assistant_message,
+#   permission_mode, prompt_id, session_crons, session_id, stop_hook_active,
+#   transcript_path), so a failure check there can never fire.
+# Input (PostToolUseFailure; measured on CC 2.1.310, `claude -p`, haiku, one run, unknown
+#   subagent_type; additionalContext delivery evidence is weak because the probe prompt named
+#   the marker; measured fields only: tool_name, is_interrupt, error (string), see
+#   https://github.com/baekenough/oh-my-customcode/issues/1775#issuecomment-6405197553).
+#   Other fields (tool_input sub-fields, duration_ms, tool_use_id, hook_event_name, ...) come from
+#   the PostToolUseFailure input table in https://code.claude.com/docs/en/hooks.md, not measured.
+# Output: stdout JSON {"hookSpecificOutput":{"hookEventName":"PostToolUseFailure",
+#   "additionalContext": "..."}} -- observed as delivered to the model (weak evidence, see above).
+#   Never a `decision` field; the only explicit exit is exit 0. Silent for interrupts, non-Agent/Task tools,
+#   missing error, or non-object stdin.
 
 input=$(cat)
 
-is_error=$(printf '%s\n' "$input" | jq -r '.tool_output.is_error // false' 2>/dev/null || echo "false")
+# Single jq pass; any parse failure or non-object stdin -> silent exit 0.
+fields=$(printf '%s' "$input" | jq -r '
+  if type == "object" then
+    [ (.tool_name // ""),
+      (if .is_interrupt == true then "1" else "0" end),
+      ((.tool_input.subagent_type // "unknown") | tostring | .[0:80]),
+      ((.tool_input.description // "") | tostring | gsub("[\n\r\t]"; " ") | .[0:120]),
+      ((.error // "") | tostring | gsub("[\n\r\t]"; " ") | .[0:200])
+    ] | join("\u001f")
+  else empty end' 2>/dev/null || true)
 
-if [ "$is_error" = "true" ]; then
-  agent_type=$(printf '%s\n' "$input" | jq -r '.tool_input.subagent_type // .agent_type // "unknown"' 2>/dev/null || echo "unknown")
-  error_summary=$(printf '%s\n' "$input" | jq -r '.tool_output.output // ""' 2>/dev/null | head -c 200)
-  echo "" >&2
-  echo "--- [Subagent Failure Advisor] background subagent (${agent_type}) reported an error ---" >&2
-  echo "  ${error_summary}" >&2
-  echo "  If it FAILED, do NOT auto-continue -- report the failure and wait for user input." >&2
-  echo "-----------------------------------------------------------------------------------" >&2
-fi
+[ -n "$fields" ] || exit 0
 
-# Always pass through -- advisory only, never blocks, never triggers Stop hook feedback re-injection
-printf '%s\n' "$input"
+IFS=$'\x1f' read -r tool_name is_interrupt subagent_type description error_text <<EOT
+$fields
+EOT
+
+case "$tool_name" in
+  Agent|Task) ;;
+  *) exit 0 ;;
+esac
+[ "$is_interrupt" = "0" ] || exit 0
+[ -n "$error_text" ] || exit 0
+
+msg="[Subagent Failure Advisor] ${tool_name} call failed (subagent_type=${subagent_type}"
+[ -z "$description" ] || msg="${msg}, description=${description}"
+msg="${msg}): ${error_text}. Fix the arguments (e.g. the subagent_type) and retry once; if the failure is a permission denial or repeats, report it and do not pretend the subagent ran."
+
+jq -n --arg ctx "$msg" '{hookSpecificOutput:{hookEventName:"PostToolUseFailure",additionalContext:$ctx}}' 2>/dev/null || true
 exit 0

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

@@ -10,9 +10,10 @@ command -v jq >/dev/null 2>&1 || exit 0
 # Protocol: stdin JSON -> process -> stdout pass-through
 # Exit status (MEASURED, bash 3.2, `set -euo pipefail`): the only explicit exits are `exit 0`, but
 # there is no trap, so it is NOT guaranteed. rc=0 for a well-formed payload, malformed JSON, empty
-# stdin, array/scalar payloads and a corrupt AGENT_START_FILE, with start_epoch exceptions: "abc" gives
-# rc=1 (`set -u`: "abc: unbound variable"); arithmetic-syntax values ("1792939922.5", "09") print an
-# error but give rc=0 (bash 3.2 drops the line; duration stays 0); "" gives rc=0.
+# stdin, array/scalar payloads and a corrupt AGENT_START_FILE. A start_epoch that is not a positive
+# decimal integer without a leading zero ("", "0", "null", "abc", "1792939922.5", "09", "-5") is
+# treated as no start record: rc=0 and duration_seconds 0 (measured on bash 3.2; before this check
+# "abc" gave rc=1 and "" recorded now_epoch, about 1.79e9, as the duration).
 #
 # MEASURED SubagentStop payload (CC 2.1.259 embedded hook schema; #1656 B):
 #   session_id, transcript_path, cwd, prompt_id?, permission_mode?, effort?,
@@ -35,8 +36,8 @@ command -v jq >/dev/null 2>&1 || exit 0
 # Outcome caveat: SubagentStop exposes no failure signal, so entries recorded
 # from that event are always outcome=success. There is no working hand-off for
 # that gap today: SubagentStop payload carries no failure signal;
-# subagent-failure-advisor.sh currently reads `.tool_output.is_error`, which is
-# absent here, so failure detection on this path is 0 until #1656 G is resolved.
+# subagent-failure-advisor.sh reads `.error` from PostToolUseFailure (Agent/Task) payloads,
+# not from SubagentStop, so this recorder still has no failure hand-off (#1656 G, #1775).
 
 input=$(cat)
 
@@ -65,8 +66,11 @@ description=$(printf '%s\n' "$input" | jq -r '
 
 # Extract skill name from description or prompt
 skill_name=""
-# `|| true`: a no-match grep exits 1 and `set -euo pipefail` would abort the hook
-# (this line's guard: rc=1 when text passes the gate below but not the name pattern; the later guard: rc=1 on {"agent_type":"X"}).
+# `|| true`: a no-match grep exits 1 and `set -euo pipefail` would abort the hook.
+# Two guards follow. The `|| true` at the end of the `grep -oiE '[a-z]+-[a-z]+...'` line inside the
+# `if` below covers the case where the text passes the `grep -qiE` gate but not the name pattern.
+# The `|| true` at the end of the later `grep -oiE 'Skill:...'` line covers a payload with no
+# "Skill:" text, e.g. {"agent_type":"X"} (rc=1 without it).
 # Empty stdin now exits at the non-object guard above.
 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 || true)
@@ -159,7 +163,10 @@ AGENT_START_FILE="/tmp/.claude-agent-starts-${PPID}"
 duration_seconds=0
 if [ -f "$AGENT_START_FILE" ]; then
   start_epoch=$(grep -F "\"agent_type\":\"${agent_type}\"" "$AGENT_START_FILE" 2>/dev/null | tail -1 | jq -r '.start_epoch // "0"' 2>/dev/null || echo "0")
-  if [ "$start_epoch" != "0" ] && [ "$start_epoch" != "null" ]; then
+  # Only a positive decimal integer without a leading zero is a usable epoch. Anything else
+  # ("", "0", "null", "abc", "1792939922.5", "09", negatives) takes the no-start-record path
+  # (duration 0): bash arithmetic would otherwise read "" as 0 and record now_epoch as the duration.
+  if [[ "$start_epoch" =~ ^[1-9][0-9]*$ ]]; then
     now_epoch=$(date +%s)
     duration_seconds=$((now_epoch - start_epoch))
   fi

package/templates/.claude/ontology/agents.yaml

@@ -9,16 +9,16 @@ classes:
     agents: [lang-golang-expert, lang-python-expert, lang-rust-expert, lang-kotlin-expert, lang-typescript-expert, lang-java-expert]
     description: "Programming language specialists"
   BackendExpert:
-    agents: [be-fastapi-expert, be-springboot-expert, be-go-backend-expert, be-express-expert, be-nestjs-expert]
+    agents: [be-fastapi-expert, be-springboot-expert, be-go-backend-expert, be-express-expert, be-nestjs-expert, be-django-expert]
     description: "Backend framework specialists"
   FrontendExpert:
-    agents: [fe-vercel-agent, fe-vuejs-agent, fe-svelte-agent, fe-flutter-agent]
+    agents: [fe-vercel-agent, fe-vuejs-agent, fe-svelte-agent, fe-flutter-agent, fe-design-expert]
     description: "Frontend framework specialists"
   DataEngineer:
     agents: [de-airflow-expert, de-dbt-expert, de-spark-expert, de-kafka-expert, de-snowflake-expert, de-pipeline-expert]
     description: "Data engineering specialists"
   DatabaseExpert:
-    agents: [db-postgres-expert, db-redis-expert, db-supabase-expert]
+    agents: [db-postgres-expert, db-redis-expert, db-supabase-expert, db-alembic-expert]
     description: "Database specialists"
   ToolingExpert:
     agents: [tool-npm-expert, tool-optimizer, tool-bun-expert]
@@ -103,14 +103,14 @@ agents:
 
   lang-java-expert:
     class: LanguageExpert
-    description: "Expert Java 21 developer for modern Java with Virtual Threads, Pattern Matching, Record Patterns, and Sequenced Collections. Use for Java files (*.java, pom.xml, build.gradle), Java-related keywords, high-concurrency systems, data-centric APIs with Records, and migrating from older Java versions."
+    description: "Expert Java 25 LTS developer for modern Java with Virtual Threads, Pattern Matching, Record Patterns, and Sequenced Collections. Use for Java files (*.java, pom.xml, build.gradle), Java-related keywords, high-concurrency systems, data-centric APIs with Records, and migrating from older Java versions."
     model: sonnet
     memory: project
     effort: high
-    skills: []
+    skills: [java-best-practices]
     tools: [Read, Write, Edit, Grep, Glob, Bash]
-    summary: "Java 21 expert for modern features including virtual threads and pattern matching"
-    keywords: [java, java21, virtual-threads, pattern-matching, records, sequenced-collections]
+    summary: "Java 25 LTS expert for modern features including virtual threads and pattern matching"
+    keywords: [java, java25, virtual-threads, pattern-matching, records, sequenced-collections]
     file_patterns: ["*.java", "pom.xml", "build.gradle", "build.gradle.kts"]
 
   be-fastapi-expert:
@@ -544,3 +544,67 @@ agents:
     summary: "Task tracker with proactive reminders for TODO management"
     keywords: [todo, tasks, reminders, tracking, deadlines, project-momentum]
     file_patterns: ["TODO.md", "*.todo"]
+
+  agora-runner:
+    description: "Executes exactly one agora session step (start, one round, or finish) via the skill scripts and returns only a verdict summary. Never returns reviewer text, vendor attribution or sealed paths."
+    model: claude-sonnet-5-5
+    skills: [agora]
+    tools: [Bash, Read, Write, Glob]
+
+  be-django-expert:
+    class: BackendExpert
+    description: "Expert Django developer for production-ready Python web applications. Use for Django projects, models/views/templates, Django REST Framework, authentication, admin customization, and deployment optimization."
+    model: claude-sonnet-5-5
+    memory: local
+    effort: high
+    skills: [django-best-practices]
+    tools: [Read, Write, Edit, Grep, Glob, Bash]
+
+  db-alembic-expert:
+    class: DatabaseExpert
+    description: "Alembic migration specialist for generating, reviewing, fixing, and advising on SQLAlchemy database migrations"
+    model: claude-opus-5-5
+    memory: local
+    effort: high
+    skills: [alembic-best-practices, postgres-best-practices]
+    tools: [Read, Write, Edit, Grep, Glob, Bash]
+
+  fe-design-expert:
+    class: FrontendExpert
+    description: "Use for design system review, typography audit, color palette evaluation, motion design, and AI-generated design quality assessment"
+    model: claude-sonnet-5-5
+    memory: local
+    effort: medium
+    skills: [impeccable-design, web-design-guidelines, diagram-design]
+    tools: [Read, Write, Edit, Grep, Glob]
+
+  sec-codeql-expert:
+    description: "Expert security code analyst using CodeQL for vulnerability detection, call graph analysis, and SARIF output. Use for security audits, CVE triage, code pattern analysis, and vulnerability validation."
+    model: claude-opus-5-5
+    memory: local
+    effort: high
+    skills: [cve-triage, adversarial-review]
+    tools: [Read, Write, Grep, Bash]
+
+  slack-cli-expert:
+    description: "Expert Slack CLI developer for Slack app management, deployment, triggers, and workspace automation"
+    model: claude-sonnet-5-5
+    effort: medium
+    skills: []
+    tools: [Read, Write, Edit, Grep, Glob, Bash]
+
+  tracker-checkpoint:
+    description: "Pipeline execution state tracker with checkpoint persistence. Reads/writes /tmp/.claude-pipeline-*-{PPID}.json state files and validates state transitions. Used by dag-orchestration for resume-after-failure and pipeline-guards for quality gate state."
+    model: haiku
+    memory: local
+    effort: medium
+    skills: [dag-orchestration, pipeline-guards]
+    tools: [Read, Write, Edit, Bash, Glob, Grep]
+
+  wiki-curator:
+    description: "Dedicated wiki page CRUD agent — creates, updates, and maintains wiki/ markdown pages for the codebase knowledge base"
+    model: claude-sonnet-5-5
+    memory: local
+    effort: medium
+    skills: []
+    tools: [Read, Write, Edit, Glob, Grep, Bash]