@humwick/runner 0.130.4 → 0.130.6

package/plugins/claude/hooks/relay-status.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 # POST a JSON body over stdin. A curl argv argument is capped by the kernel (~128 KiB), and a
-# prompt or assistant message can exceed it; curl then never starts and the report is lost (#2664).
+# prompt or assistant message can exceed it; curl then never starts and the report is lost.
 relay_post_json() {
   local port="$1" path="$2" max_time="${3:-}"
   curl -fsS ${max_time:+--max-time "$max_time"} -X POST "http://127.0.0.1:${port}${path}" \
@@ -21,11 +21,11 @@ relay_post_status() {
   # responsible for producing valid JSON (see relay_background_task_metadata). Empty/unset
   # omits the field entirely so ordinary status posts are unaffected.
   local metadata_json="${9:-}"
-  local port="${AGENT_RELAY_RUNNER_PORT:-}"
+  local port="${HUMWICK_RUNNER_PORT:-}"
   [ -z "$port" ] && return 0
   [ -z "$status" ] && return 0
   local body="{\"status\":\"$(relay_json_escape "$status")\""
-  [ -n "${AGENT_RELAY_PROVIDER_SESSION_ID:-}" ] && body="${body},\"providerSessionId\":\"$(relay_json_escape "$AGENT_RELAY_PROVIDER_SESSION_ID")\""
+  [ -n "${HUMWICK_PROVIDER_SESSION_ID:-}" ] && body="${body},\"providerSessionId\":\"$(relay_json_escape "${HUMWICK_PROVIDER_SESSION_ID-}")\""
   [ -n "$reason" ] && body="${body},\"reason\":\"$(relay_json_escape "$reason")\""
   [ -n "$clear_kind" ] && body="${body},\"clear\":[\"$(relay_json_escape "$clear_kind")\"]"
   [ -n "$timeline_status" ] && body="${body},\"timeline\":{\"status\":\"$(relay_json_escape "$timeline_status")\"}"
@@ -42,7 +42,7 @@ relay_post_status_clearing_subagents() {
   relay_post_status "$1" "${2:-}" "${3:-}" "${4:-}" "${5:-}" "${6:-}" subagent
 }
 
-# #502/#539: count user background shells still running at turn end.
+# count user background shells still running at turn end.
 # Claude's Stop payload carries a `background_tasks` array (CC v2.1.157+) listing
 # shells launched with run_in_background that have not yet finished. It can also
 # include the long-lived Humwick monitor; that monitor is notification
@@ -56,9 +56,9 @@ relay_background_task_count() {
     n="$(printf '%s' "$input" | jq -r '
       (.background_tasks // [])
       | map(select(
-          (.name // "") != "agent-relay-runner-monitor"
+          ((.name // "") | test("^(humwick|agent-relay)-runner-monitor$") | not)
           and ((.command // "") | contains("relay-monitor.ts") | not)
-          and ((.command // "") | contains("agent-relay-runner-monitor") | not)
+          and ((.command // "") | test("(humwick|agent-relay)-runner-monitor") | not)
         ))
       | length
     ' 2>/dev/null)"
@@ -69,7 +69,7 @@ relay_background_task_count() {
   local compact
   compact="$(printf '%s' "$input" | tr -d '[:space:]')"
   if printf '%s' "$compact" | grep -q '"background_tasks":\[{'; then
-    if printf '%s' "$compact" | grep -qE '("name":"agent-relay-runner-monitor"|relay-monitor\.ts)' \
+    if printf '%s' "$compact" | grep -qE '("name":"(humwick|agent-relay)-runner-monitor"|relay-monitor\.ts)' \
       && ! printf '%s' "$compact" | grep -q '},{'; then
       printf '0'
       return 0
@@ -80,7 +80,7 @@ relay_background_task_count() {
   fi
 }
 
-# #2034 (#2031 L3): cap on the per-task detail list — bounds task count and per-command
+# cap on the per-task detail list — bounds task count and per-command
 # length so a pathological Stop payload (a runaway number of concurrent background shells,
 # or an absurdly long command string) can never bloat the persisted work record.
 # relay_background_task_count above (the busy/label signal) stays uncapped; only this
@@ -88,7 +88,7 @@ relay_background_task_count() {
 RELAY_BACKGROUND_TASK_LIST_MAX=20
 RELAY_BACKGROUND_TASK_COMMAND_MAX=200
 
-# #2034 (#2031 L3): shape Claude's Stop-payload background_tasks[] into the compact
+# shape Claude's Stop-payload background_tasks[] into the compact
 # {id, command} detail list the runner keeps as the background-script work record's
 # `metadata.backgroundTasks` — the per-task identity a watchdog can name directly instead
 # of just a count. The runner (not this hook) stamps startedAt: each hook invocation is a
@@ -105,9 +105,9 @@ relay_background_task_list() {
     --argjson cmdmax "$RELAY_BACKGROUND_TASK_COMMAND_MAX" '
     (.background_tasks // [])
     | map(select(
-        (.name // "") != "agent-relay-runner-monitor"
+        ((.name // "") | test("^(humwick|agent-relay)-runner-monitor$") | not)
         and ((.command // "") | contains("relay-monitor.ts") | not)
-        and ((.command // "") | contains("agent-relay-runner-monitor") | not)
+        and ((.command // "") | test("(humwick|agent-relay)-runner-monitor") | not)
       ))
     | map({
         id: ((.id // "") | tostring),
@@ -120,7 +120,7 @@ relay_background_task_list() {
 
 # Wrap a capped task list into the `metadata` object relay_post_status expects, or print
 # nothing when there is nothing to report (no task list, empty list, or jq-less host) so an
-# ordinary background-script status post is byte-for-byte what it was before #2034.
+# ordinary background-script status post is byte-for-byte what it was before.
 relay_background_task_metadata() {
   local list_json="${1:-}"
   case "$list_json" in
@@ -129,14 +129,14 @@ relay_background_task_metadata() {
   esac
 }
 
-# #502: end the provider turn (idle) clearing any stale subagent work — the
-# critical path (#199) — then report the live background-script snapshot so an
+# end the provider turn (idle) clearing any stale subagent work — the
+# critical path — then report the live background-script snapshot so an
 # agent whose turn ended while a `run_in_background` shell keeps running stays
 # busy instead of falsely reading idle. A single full-snapshot post per turn-end:
 # >0 → busy(background-script); 0 → idle(background-script) which clears any prior.
 relay_post_turn_end_status() {
   local bg_count="${1:-0}"
-  # #2034: the capped {id, command} detail list (see relay_background_task_list) — only
+  # the capped {id, command} detail list (see relay_background_task_list) — only
   # relevant on the busy branch; a bg_count of 0 always resolves to idle regardless.
   local bg_tasks_json="${2:-[]}"
   local bg_metadata
@@ -149,7 +149,7 @@ relay_post_turn_end_status() {
   esac
 }
 
-# Report a provider usage/rate-limit hold to the runner (#286). The runner turns
+# Report a provider usage/rate-limit hold to the runner. The runner turns
 # this into a `providerState: blocked` (reason rate_limit), posts a chat notice,
 # and auto-resumes the agent once the window resets. reset_time (unix seconds,
 # only "if available" per CC StopFailure docs) drives the resume; the runner falls
@@ -158,7 +158,7 @@ relay_post_rate_limit() {
   local error_type="${1:-}"
   local reset_time="${2:-}"
   local error_message="${3:-}"
-  local port="${AGENT_RELAY_RUNNER_PORT:-}"
+  local port="${HUMWICK_RUNNER_PORT:-}"
   [ -z "$port" ] && return 0
   local body="{\"errorType\":\"$(relay_json_escape "$error_type")\""
   case "$reset_time" in ''|*[!0-9]*) ;; *) body="${body},\"resetTime\":${reset_time}" ;; esac
@@ -179,7 +179,7 @@ relay_post_session_turn() {
   local transcript_path="${1:-}"
   local last_assistant_message="${2:-}"
   local prompt_id="${3:-}"
-  local port="${AGENT_RELAY_RUNNER_PORT:-}"
+  local port="${HUMWICK_RUNNER_PORT:-}"
   [ -z "$port" ] && return 0
   # transcript_path is the primary capture source, but the Stop payload can omit it
   # (known CC edge case). last_assistant_message is the fallback for exactly that —
@@ -191,7 +191,7 @@ relay_post_session_turn() {
     [ "$body" != "{" ] && body="${body},"
     body="${body}\"lastAssistantMessage\":${last_assistant_message}"
   fi
-  # prompt_id (#1086): Claude's native turn identifier — the stable id the runner
+  # prompt_id: Claude's native turn identifier — the stable id the runner
   # uses instead of a minted random UUID, and the deterministic key it slices the
   # transcript by for full-mode enrichment.
   if [ -n "$prompt_id" ]; then
@@ -202,11 +202,11 @@ relay_post_session_turn() {
   printf '%s' "$body" | relay_post_json "$port" /session-turn >/dev/null 2>&1 || true
 }
 
-# Forward a hook's raw stdin JSON unchanged, stamped with when the hook ran (#2664). No jq: a
+# Forward a hook's raw stdin JSON unchanged, stamped with when the hook ran. No jq: a
 # missing jq must not silence the prompt hook the runner confirms submits by.
 relay_forward_hook_payload() {
   local path="${1:-}" payload="${2:-}" fired_at="${3:-}"
-  local port="${AGENT_RELAY_RUNNER_PORT:-}"
+  local port="${HUMWICK_RUNNER_PORT:-}"
   [ -z "$port" ] && return 0
   case "$fired_at" in ''|*[!0-9]*) fired_at="" ;; esac
   printf '%s' "$payload" | relay_post_json "$port" "${path}${fired_at:+?firedAt=${fired_at}}" 3 >/dev/null 2>&1 || true
@@ -223,13 +223,13 @@ relay_post_user_prompt() {
 }
 
 relay_post_session_boundary() {
-  # Pre-destroy seam (#183): tell the runner a context reset or termination is imminent
-  # (compact/clear/logout/…) so it can run end-of-session work — the #184 context-gathering
+  # Pre-destroy seam: tell the runner a context reset or termination is imminent
+  # (compact/clear/logout/…) so it can run end-of-session work — the context-gathering
   # ratio capture — from the full transcript before the invasive op. Fire-and-forget; the
   # transcript path is optional (the runner falls back to the last path it saw).
   local transcript_path="${1:-}"
   local reason="${2:-}"
-  local port="${AGENT_RELAY_RUNNER_PORT:-}"
+  local port="${HUMWICK_RUNNER_PORT:-}"
   [ -z "$port" ] && return 0
   local body="{"
   [ -n "$transcript_path" ] && body="${body}\"transcriptPath\":\"$(relay_json_escape "$transcript_path")\""
@@ -241,14 +241,14 @@ relay_post_session_boundary() {
   printf '%s' "$body" | relay_post_json "$port" /session-boundary 3 >/dev/null 2>&1 || true
 }
 
-# --- Hook FATAL surfacing (#198) -------------------------------------------
+# --- Hook FATAL surfacing -------------------------------------------
 # A hook that dies unexpectedly must never be silent. relay_install_hook_guard
 # arms an ERR trap that reports the failure FATAL to the runner control port,
 # which logs it to the dashboard-surfaced per-agent log. Best-effort and bounded
 # (--max-time 2) so the report itself can never blow the hook's timeout budget.
 relay_hook_fatal_report() {
   local hook="${1:-unknown}" detail="${2:-}"
-  local port="${AGENT_RELAY_RUNNER_PORT:-}"
+  local port="${HUMWICK_RUNNER_PORT:-}"
   [ -z "$port" ] && return 0
   local body="{\"hook\":\"$(relay_json_escape "$hook")\",\"error\":\"$(relay_json_escape "$detail")\"}"
   printf '%s' "$body" | relay_post_json "$port" /hook-fatal 2 >/dev/null 2>&1 || true
@@ -258,7 +258,7 @@ relay_install_hook_guard() {
   RELAY_HOOK_NAME="${1:-unknown}"
   # The pipe adapter owns native turn boundaries and final-result reporting.
   # Permission and safety hooks still run; TUI lifecycle hooks must not compete.
-  if [ "${AGENT_RELAY_CLAUDE_TRANSPORT:-}" = "stream-json" ]; then
+  if [ "${HUMWICK_CLAUDE_TRANSPORT:-}" = "stream-json" ]; then
     case "$RELAY_HOOK_NAME" in
       user-prompt-submit|stop|stop-failure|session-end|pre-compact|post-compact|subagent-start|subagent-stop) exit 0 ;;
     esac
@@ -271,12 +271,12 @@ relay_install_hook_guard() {
 }
 
 relay_pending_reply_stop_decision() {
-  local port="${AGENT_RELAY_RUNNER_PORT:-}"
+  local port="${HUMWICK_RUNNER_PORT:-}"
   [ -z "$port" ] && return 0
   local response
   # --max-time guards the Claude Stop hook's 5s budget: a slow runner/server (e.g. an
   # un-indexed obligation query) must never block past the timeout, or Claude SIGKILLs
-  # the hook before it clears the turn -> stuck "busy" (#199). On timeout: no block.
+  # the hook before it clears the turn -> stuck "busy". On timeout: no block.
   response="$(curl -fsS --max-time 2 "http://127.0.0.1:${port}/reply-obligations/claude-stop" 2>/dev/null || true)"
   case "$response" in
     *'"decision":"block"'*|*'"decision": "block"'*) ;;
@@ -337,10 +337,10 @@ relay_json_escape() {
 # an isolated workspace whose branch has committed work not yet integrated into
 # base. Prints nothing otherwise — so plain chat, shared-mode, and no-change
 # sessions never pay context/token cost. Reads the workspace from
-# AGENT_RELAY_WORKSPACE_JSON (set by the orchestrator at spawn) and does a local,
+# HUMWICK_WORKSPACE_JSON (set by the orchestrator at spawn) and does a local,
 # network-free git count. Always returns 0 (never aborts its caller).
 relay_review_reminder_text() {
-  local ws="${AGENT_RELAY_WORKSPACE_JSON:-}"
+  local ws="${HUMWICK_WORKSPACE_JSON:-}"
   [ -z "$ws" ] && return 0
   local mode worktree base id branch ahead
   mode="$(relay_json_string_field mode "$ws")"
@@ -356,7 +356,7 @@ relay_review_reminder_text() {
   ahead="$(git -C "$worktree" rev-list --count "${base}..HEAD" 2>/dev/null || echo 0)"
   case "$ahead" in ''|*[!0-9]*) ahead=0 ;; esac
   [ "$ahead" -gt 0 ] || return 0
-  printf '[agent-relay] You have %s committed change(s) on `%s` that are not yet integrated into base. If your task is complete, request review so Humwick can auto-land it: POST /api/workspaces/%s/actions with {"action":"request-review"}. If you are still working, ignore this — it only appears while there is unmerged committed work.' \
+  printf '[humwick] You have %s committed change(s) on `%s` that are not yet integrated into base. If your task is complete, request review so Humwick can auto-land it: POST /api/workspaces/%s/actions with {"action":"request-review"}. If you are still working, ignore this — it only appears while there is unmerged committed work.' \
     "$ahead" "${branch:-this branch}" "$id"
   return 0
 }

package/plugins/claude/hooks/session-end.sh

@@ -11,7 +11,7 @@ case "$reason" in
   clear)
     relay_post_timeline_status idle provider-turn subagent clearing-context
     # /clear wipes the context — the most common work boundary for a long-lived agent.
-    # Capture this segment's Insights (#183/#184) before it's gone.
+    # Capture this segment's Insights before it's gone.
     relay_post_session_boundary "$transcript_path" clear
     ;;
   resume)
@@ -19,7 +19,7 @@ case "$reason" in
     ;;
   logout|prompt_input_exit|bypass_permissions_disabled|other|*)
     relay_post_status_clearing_subagents offline
-    # Real session termination: capture end-of-session Insights (#183/#184). Order after the
+    # Real session termination: capture end-of-session Insights. Order after the
     # status post is arbitrary — the runner reads the transcript file regardless.
     relay_post_session_boundary "$transcript_path" "$reason"
     ;;

package/plugins/claude/hooks/session-start.sh

@@ -2,7 +2,7 @@
 set -euo pipefail
 source "${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}/hooks/relay-status.sh"
 relay_install_hook_guard session-start
-# #2664 — a stamped check-in proves the hook path works before the first prompt is submitted.
+# a stamped check-in proves the hook path works before the first prompt is submitted.
 relay_forward_hook_payload /hook-check "{}" "$(relay_now_ms)"
 
 payload="$(cat || true)"
@@ -13,8 +13,8 @@ case "$source_kind" in
   clear)
     # A queued /clear can commit after the runner's confirmation timed out. Restore
     # its continuation in THIS fresh context, even if the backstop hit the old one.
-    if [ -n "${AGENT_RELAY_RUNNER_PORT:-}" ]; then
-      continuation="$(printf '{"source":"clear","providerSessionId":"%s"}' "$(relay_json_escape "${AGENT_RELAY_PROVIDER_SESSION_ID:-}")" | relay_post_json "$AGENT_RELAY_RUNNER_PORT" /session-start 3 || true)"
+    if [ -n "${HUMWICK_RUNNER_PORT:-}" ]; then
+      continuation="$(printf '{"source":"clear","providerSessionId":"%s"}' "$(relay_json_escape "${HUMWICK_PROVIDER_SESSION_ID:-}")" | relay_post_json "${HUMWICK_RUNNER_PORT-}" /session-start 3 || true)"
     fi
     relay_post_timeline_status idle provider-turn subagent context-cleared
     ;;

package/plugins/claude/hooks/shell-trust.ts

@@ -1,4 +1,4 @@
-// Shared "is this plain simple commands?" pre-filter for the PreToolUse guards (#2834, #2993).
+// Shared "is this plain simple commands?" pre-filter for the PreToolUse guards.
 // Heredocs, comments, functions, control-flow keywords, continuations, substitutions and
 // per-line unbalanced quotes (a string spanning lines) all mean "unsure": the caller allows.
 // `do`/`done` are deliberately not keywords here: they never appear without a header keyword

package/plugins/claude/hooks/stop-failure.sh

@@ -13,11 +13,11 @@ error_message="$(relay_json_string_field error_message "$payload")"
 [ -z "$error_message" ] && error_message="$(relay_json_string_field error_details "$payload")"
 [ -z "$error_message" ] && error_message="$(relay_json_string_field last_assistant_message "$payload")"
 
-# #286: a usage/rate-limit stall is transient and time-bounded — hold the agent
+# a usage/rate-limit stall is transient and time-bounded — hold the agent
 # (providerState blocked) and auto-resume at reset, instead of silently going idle.
 # The disambiguator for billing_error is reset_time: a subscription rolling-window
 # limit carries one (and is auto-resumable); true credit exhaustion does not (fatal).
-# #3577: a refused proxy credential (ERR_PROXY_TUNNEL) also posts here; the runner classifies it.
+# a refused proxy credential (ERR_PROXY_TUNNEL) also posts here; the runner classifies it.
 case "$error" in
   rate_limit|overloaded|server_error|api_error)
     relay_post_rate_limit "$error" "$reset_time" "$error_message"

package/plugins/claude/hooks/stop.sh

@@ -3,15 +3,15 @@ set -euo pipefail
 source "${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}/hooks/relay-status.sh"
 relay_install_hook_guard stop
 
-# Clearing the turn's busy state is the critical path (#199). Register it on EXIT
+# Clearing the turn's busy state is the critical path. Register it on EXIT
 # so it runs even if a side-call below fails or times out under `set -e`. The one
 # exception is the reply-obligation block path, which deliberately keeps the agent
 # busy to answer — it opts out via the flag before exiting.
 _relay_clear_idle_on_exit=1
 # bg_count/bg_tasks_json are read from the payload below and consumed by the trap at exit
-# time (#502): the turn-end status carries the live background-script snapshot so an agent
+# time: the turn-end status carries the live background-script snapshot so an agent
 # whose turn ended while a run_in_background shell keeps running stays busy instead of
-# falsely reading idle. bg_tasks_json (#2034) is the per-task {id, command} detail behind
+# falsely reading idle. bg_tasks_json is the per-task {id, command} detail behind
 # that snapshot — the ledger the runner enriches with startedAt and a watchdog can read.
 bg_count=0
 bg_tasks_json="[]"
@@ -22,11 +22,11 @@ stop_hook_active="$(relay_json_bool_field stop_hook_active "$payload")"
 bg_count="$(relay_background_task_count "$payload")"
 bg_tasks_json="$(relay_background_task_list "$payload")"
 
-# Session-mirror capture is orthogonal to reply-obligation gating (#332): a recursive Stop
+# Session-mirror capture is orthogonal to reply-obligation gating: a recursive Stop
 # (stop_hook_active=true) must NOT suppress capturing this turn's response, or the live mirror
 # silently drops frames. Always post the turn; only the reply-obligation decision is gated below.
 last_assistant_msg="$(echo "$payload" | jq -c '.last_assistant_message // empty' 2>/dev/null || true)"
-# prompt_id (#1086): Claude's own native turn identifier, correlating this Stop with
+# prompt_id: Claude's own native turn identifier, correlating this Stop with
 # the same UUID stamped on every transcript entry of the turn (and the id the
 # UserPromptSubmit hook reported at turn start) — the stable replacement for a
 # runner-minted random UUID.
@@ -35,7 +35,7 @@ relay_post_session_turn "$(relay_json_string_field transcript_path "$payload")"
 
 if [ "$stop_hook_active" != "true" ]; then
   # `|| true`: under `set -e`, a non-zero from the obligation check must never abort
-  # the hook before the idle-clear — clearing the turn is the critical path (#199).
+  # the hook before the idle-clear — clearing the turn is the critical path.
   stop_decision="$(relay_pending_reply_stop_decision || true)"
   if [ -n "$stop_decision" ]; then
     _relay_clear_idle_on_exit=0

package/plugins/claude/hooks/subagent-skill-policy.cjs

@@ -125,8 +125,10 @@ exports.skillDenial = async function skillDenial(payload, name) {
   }
   for (const plugin of plugins) {
     const manifest = json(path.join(plugin, '.claude-plugin/plugin.json'));
-    if (typeof manifest.name !== 'string') throw new Error(`Cannot establish plugin namespace in ${plugin}`);
-    const prefix = `${manifest.name}:`;
+    // Claude infers a manifestless plugin's namespace from its directory in either generation.
+    const namespace = manifest.name ?? path.basename(plugin);
+    if (typeof namespace !== 'string') throw new Error(`Cannot establish plugin namespace in ${plugin}`);
+    const prefix = `${namespace}:`;
     inspect(path.join(plugin, 'skills'), false, prefix);
     if (!stat(path.join(plugin, 'skills')) && manifest.skills === undefined) inspect(path.join(plugin, 'SKILL.md'), false, prefix);
     if (manifest.commands === undefined) inspect(path.join(plugin, 'commands'), true, prefix);
@@ -145,7 +147,7 @@ exports.skillDenial = async function skillDenial(payload, name) {
       if (typeof definition.content === 'string') inspectText(definition.content, `${plugin}:${command}`, command, prefix, definition.model);
     }
   }
-  // #3706: the role-provisioned copy in the managed home and its identical repo source are one skill; differing same-name skills stay ambiguous.
+  // the role-provisioned copy in the managed home and its identical repo source are one skill; differing same-name skills stay ambiguous.
   const sourced = new Set([...candidates.values()].filter((entry) => !entry.managed).map((entry) => entry.digest));
   for (const [key, entry] of candidates) if (entry.managed && sourced.has(entry.digest)) candidates.delete(key);
   if (candidates.size !== 1) return `skill ${name} ${candidates.size ? 'resolves ambiguously' : 'cannot be resolved'}; refusing unverified execution`;
@@ -154,7 +156,7 @@ exports.skillDenial = async function skillDenial(payload, name) {
   if (typeof skill.context === 'string' && skill.context.trim() === 'fork' && (typeof skill.model !== 'string' || !skill.model.trim() || skill.model.trim() === 'inherit')) return `fork skill ${name} requires an explicit model under capped profiles`;
 };
 
-// #3470: standalone CJS config adapters; this file is shipped beside subagent-guard.cjs.
-function skillSources() { return JSON.parse(process.env.AGENT_RELAY_CLAUDE_SKILL_SOURCES || '{}'); }
-function harnessSubagentsDisabled() { return process.env.AGENT_RELAY_HARNESS_SUBAGENTS === '0'; }
+// standalone CJS config adapters; this file is shipped beside subagent-guard.cjs.
+function skillSources() { return JSON.parse((process.env.HUMWICK_CLAUDE_SKILL_SOURCES) || '{}'); }
+function harnessSubagentsDisabled() { return (process.env.HUMWICK_HARNESS_SUBAGENTS) === '0'; }
 exports.harnessSubagentsDisabled = harnessSubagentsDisabled;

package/plugins/claude/hooks/subagent-stop.sh

@@ -10,10 +10,10 @@ payload="$(cat || true)"
 agent_id="$(relay_json_string_field agent_id "$payload")"
 agent_type="$(relay_json_string_field agent_type "$payload")"
 
-if [ -n "${AGENT_RELAY_RUNNER_PORT:-}" ] && [ -n "$(relay_json_string_field agent_transcript_path "$payload")" ]; then
-  printf '%s' "$payload" | relay_post_json "$AGENT_RELAY_RUNNER_PORT" /subagent-usage 4 >/dev/null
+if [ -n "${HUMWICK_RUNNER_PORT:-}" ] && [ -n "$(relay_json_string_field agent_transcript_path "$payload")" ]; then
+  printf '%s' "$payload" | relay_post_json "${HUMWICK_RUNNER_PORT-}" /subagent-usage 4 >/dev/null
 fi
 
-if [ "${AGENT_RELAY_CLAUDE_TRANSPORT:-}" != "stream-json" ]; then
+if [ "${HUMWICK_CLAUDE_TRANSPORT:-}" != "stream-json" ]; then
   relay_post_status idle subagent "${agent_id:-subagent}" "$agent_type" "$agent_type"
 fi

package/plugins/claude/hooks/user-prompt-submit.sh

@@ -4,7 +4,7 @@ source "${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}/
 relay_install_hook_guard user-prompt-submit
 fired_at="$(relay_now_ms)"
 payload="$(cat || true)"
-# prompt_id (#1086): Claude's own native turn identifier for the prompt starting
+# prompt_id: Claude's own native turn identifier for the prompt starting
 # now — the same UUID the Stop hook reports and the transcript stamps on every
 # entry of this turn. Passed as the busy report's `id` so the runner adopts it as
 # currentTurnId instead of minting a random UUID (runner-core.ts setProviderStatus).

package/plugins/claude/hooks/wait-loop-guard.ts

@@ -1,5 +1,5 @@
-// #2993: a FOREGROUND wait (bare long `sleep`, or an until/while loop that only sleeps between checks) holds the
-// turn; the wait belongs in one detached relay_run. STRICT ALLOWLIST: the command must be exactly
+// a FOREGROUND wait (bare long `sleep`, or an until/while loop that only sleeps between checks) holds the
+// turn; the wait belongs in one detached humwick_run. STRICT ALLOWLIST: the command must be exactly
 //   setup* ( sleep D | (until|while) CHECK; do (sleep D | echo|printf|date|true)+; done ) rest*
 // Anything else (loops doing work, `for`, nesting, `$(...)`, background `&`, unknown durations) is not matched,
 // so every parse doubt fails open to "allow".
@@ -110,7 +110,7 @@ export function waitLoopDenial(command: string): string | null {
   for (let depth = 0; depth <= MAX_UNWRAP_DEPTH && candidate !== undefined; depth += 1) {
     candidate = candidate.replace(TIMEOUT_PREFIX, ""); // `timeout 600 <cmd>` is transparent
     if (isForegroundWait(lexCommandLine(candidate))) {
-      return "Do not hold the turn on a foreground wait. Run it with the relay_run MCP tool (detach: true, waitMs: 0) as ONE poll loop with a deadline "
+      return "Do not hold the turn on a foreground wait. Run it with the humwick_run MCP tool (detach: true, waitMs: 0) as ONE poll loop with a deadline "
         + "(e.g. `end=$((SECONDS+1800)); until <check>; do [ $SECONDS -ge $end ] && exit 1; sleep 30; done`), then end your turn with no text; "
         + `Relay wakes you once when it finishes. Command: ${command}`;
     }

package/plugins/claude/monitors/monitors.json

@@ -1,7 +1,7 @@
 [
   {
-    "name": "agent-relay-runner-monitor",
+    "name": "humwick-runner-monitor",
     "command": "bun run \"${CLAUDE_PLUGIN_ROOT}/monitors/relay-monitor.ts\"",
-    "description": "Agent Relay runner message delivery pipe"
+    "description": "Humwick runner message delivery pipe"
   }
 ]