Dev

#!/usr/bin/env bash
# Generated by OrchestKit Claude Plugin — Created: 2026-04-27
# /ork:dev boot — wrap a dev server in a portless proxy with a stable HTTPS subdomain,
# optionally start emulators, register an agent-browser session.
#
# Verified against:
#   portless 0.10.x      `portless proxy start`, `portless <name> <cmd>`,
#                        `portless list`, `portless get <name>` (no --json on list)
#   emulate  0.4.x       `emulate --seed <yaml>`, foreground default
#   agent-browser 0.25+  `--session <name>` global flag,
#                        AGENT_BROWSER_SESSION env, sessions are lazy
#
# Architecture: portless WRAPS the dev command (not sidecar). The wrapper lives until
# the child dev server exits. We track the wrapper PID; killing it terminates the
# wrapped dev server.
#
# Idempotent. Writes state to .claude/state/dev-stack.json via jq.
# Exit codes: 0 = booted (or already live), 1 = aborted (missing prereq / startup fail).

set -euo pipefail

PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
STATE_DIR="${PROJECT_DIR}/.claude/state"
STATE_FILE="${STATE_DIR}/dev-stack.json"
LOG_FILE="${STATE_DIR}/dev.log"
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# ── 0. Detect package manager from lockfile ─────────────────────────────────
detect_pkg_mgr() {
  if [[ -f "${PROJECT_DIR}/pnpm-lock.yaml" ]]; then echo "pnpm"; return; fi
  if [[ -f "${PROJECT_DIR}/yarn.lock"     ]]; then echo "yarn"; return; fi
  if [[ -f "${PROJECT_DIR}/bun.lockb"     ]]; then echo "bun";  return; fi
  echo "npm"
}

# Detect Turborepo or pnpm/yarn/npm workspaces — triggers portless 0.11
# zero-config bare invocation (auto-discovers dev scripts, assigns subdomains).
is_monorepo() {
  [[ -f "${PROJECT_DIR}/turbo.json" ]] && return 0
  if [[ -f "${PROJECT_DIR}/package.json" ]] && command -v jq >/dev/null 2>&1; then
    jq -e '.workspaces // empty | length > 0' "${PROJECT_DIR}/package.json" >/dev/null 2>&1 && return 0  # silent: gating-relaxed
  fi
  [[ -f "${PROJECT_DIR}/pnpm-workspace.yaml" ]] && return 0
  return 1
}

# Detect json-render adapter family (#1560) — single answer or empty.
# Output: react|vue|svelte|solid (or empty if none).
json_render_adapter() {
  [[ -f "${PROJECT_DIR}/package.json" ]] || return 0
  command -v jq >/dev/null 2>&1 || return 0
  local q='
    ((.dependencies // {}) + (.devDependencies // {})) | keys |
    if   any(. == "@json-render/devtools-react")  then "react"
    elif any(. == "@json-render/devtools-vue")    then "vue"
    elif any(. == "@json-render/devtools-svelte") then "svelte"
    elif any(. == "@json-render/devtools-solid")  then "solid"
    elif any(startswith("@json-render/")) then "react"
    else empty end'
  jq -r "${q}" "${PROJECT_DIR}/package.json" 2>/dev/null  # silent: gating-relaxed
}

# Detect @clerk/* deps (#1563) — emit hint if found.
has_clerk() {
  [[ -f "${PROJECT_DIR}/package.json" ]] || return 1
  command -v jq >/dev/null 2>&1 || return 1
  jq -e '((.dependencies // {}) + (.devDependencies // {})) | keys | any(startswith("@clerk/"))' "${PROJECT_DIR}/package.json" >/dev/null 2>&1  # silent: gating-relaxed
}

# ── 1. Resolve slug from branch (DNS-safe, ≤63 chars) ───────────────────────
slug_branch() {
  local b
  b=$(git -C "${PROJECT_DIR}" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "dev")
  [[ "${b}" == "HEAD" ]] && b="dev"
  printf '%s' "${b}" | tr '[:upper:]' '[:lower:]' | tr '/' '-' | tr -cd 'a-z0-9-' | cut -c1-63
}

# Top-level service keys from emulate.config.yaml (awk, no PyYAML dep).
emulator_services_json() {
  local cfg="${PROJECT_DIR}/emulate.config.yaml"
  [[ ! -f "${cfg}" ]] && { printf '[]'; return; }
  local names
  names=$(awk '
    /^[[:space:]]*#/ { next }
    /^services:[[:space:]]*$/ { in_svc=1; next }
    in_svc && /^[a-zA-Z]/ { in_svc=0 }
    in_svc && /^[[:space:]]+[a-zA-Z][a-zA-Z0-9_-]*:[[:space:]]*$/ {
      sub(/^[[:space:]]+/, ""); sub(/:.*$/, ""); print
    }
  ' "${cfg}")
  if [[ -z "${names}" ]]; then printf '[]'; return; fi
  printf '%s\n' "${names}" | jq -R . | jq -s .
}

# True if portless proxy daemon is responding (idempotent check).
portless_proxy_running() {
  portless list >/dev/null 2>&1
}

# True if a route with the given slug is already registered (conflict guard).
portless_route_exists() {
  local sub="$1"
  portless list 2>/dev/null | grep -qE "https?://${sub}\.localhost(:[0-9]+)?\b"
}

# Canonical URL for a registered slug — uses portless's own resolver so we
# inherit the proxy's actual port (443 default; custom -p possible).
portless_url() {
  local sub="$1"
  portless get "${sub}" 2>/dev/null | head -1 | tr -d '\r\n'
}

require() {
  local cmd="$1" install="$2"
  if ! command -v "${cmd}" >/dev/null 2>&1; then
    printf '✗ %s not found.   Install: %s\n' "${cmd}" "${install}" >&2
    return 1
  fi
  printf '✓ %s     found\n' "${cmd}" >&2
}

main() {
  mkdir -p "${STATE_DIR}"

  # ── Arg parsing (M127 #1561+#1565) ────────────────────────────────────────
  # --share   : portless --tailscale (tailnet-only)
  # --funnel  : portless --funnel    (publicly exposed via Tailscale Funnel)
  # --live N  : equivalent to --funnel with N-hour expiry tracked in state file
  local share_mode=""        # "" | "tailscale" | "funnel"
  local live_duration_hours=0
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --share)         share_mode="tailscale"; shift ;;
      --funnel)        share_mode="funnel";    shift ;;
      --live)          share_mode="funnel"; live_duration_hours="${2:-4}"; shift 2 ;;
      stop|status|start) shift ;;
      *)               shift ;;
    esac
  done

  if [[ "${CI:-}" == "1" || "${CI:-}" == "true" ]]; then
    printf 'ork:dev — CI=1, skipping boot.\n' >&2
    exit 0
  fi

  printf 'ork:dev — checking prerequisites…\n' >&2
  local missing=0
  require portless      "npm i -g portless"      || missing=1
  require agent-browser "npm i -g agent-browser" || missing=1
  require jq            "brew install jq"        || missing=1
  if [[ -f "${PROJECT_DIR}/emulate.config.yaml" ]]; then
    require emulate "npm i -g emulate" || missing=1
  fi
  # Tailscale is OPTIONAL — only required when --share / --funnel / --live used.
  if [[ -n "${share_mode}" ]]; then
    require tailscale "brew install tailscale (or https://tailscale.com/download)" || missing=1
  fi
  if [[ ${missing} -ne 0 ]]; then
    printf '\nSkipping boot — install missing tools and re-run.\n' >&2
    exit 1
  fi

  if [[ -f "${STATE_FILE}" ]]; then
    if bash "${SCRIPT_DIR}/status.sh" --quiet 2>/dev/null; then
      printf 'ork:dev — already running. Run /ork:dev stop to tear down.\n' >&2
      exit 0
    fi
    printf 'ork:dev — state file exists but stack is dead. Cleaning up…\n' >&2
    rm -f "${STATE_FILE}"
  fi

  local pkg_mgr; pkg_mgr=$(detect_pkg_mgr)
  local slug;    slug=$(slug_branch)
  local branch;  branch=$(git -C "${PROJECT_DIR}" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "dev")

  printf '[1] slug       %s\n' "${slug}" >&2

  # 2. portless proxy — start if not already running. Don't disturb existing settings.
  if portless_proxy_running; then
    printf '[2] portless proxy already running — reusing.\n' >&2
  else
    printf '[2] portless proxy start (HTTPS by default)\n' >&2
    portless proxy start >>"${LOG_FILE}" 2>&1 || {
      printf '✗ portless proxy start failed (see %s)\n' "${LOG_FILE}" >&2
      exit 1
    }
  fi

  if portless_route_exists "${slug}"; then
    printf '✗ portless route %s.localhost already exists. Use a different branch or stop the conflicting service.\n' "${slug}" >&2
    exit 1
  fi

  # 3. emulate (sidecar — optional, runs only if config present)
  local e_pid=0
  local e_cmd=""
  if [[ -f "${PROJECT_DIR}/emulate.config.yaml" ]]; then
    printf '[3] emulate --seed emulate.config.yaml (background)\n' >&2
    e_cmd="emulate --seed ${PROJECT_DIR}/emulate.config.yaml"
    # exec so $! captures the actual emulate PID, not the subshell.
    ( exec emulate --seed "${PROJECT_DIR}/emulate.config.yaml" >>"${LOG_FILE}" 2>&1 ) &
    e_pid=$!
  else
    printf '[3] no emulate.config.yaml — skipping (run /ork:emulate-seed --auto to generate)\n' >&2
  fi

  # 4. WRAPPED dev server: portless owns the lifecycle. We track the wrapper PID.
  # CRITICAL: use `exec` inside the subshell so $! captures the portless PID directly.
  # Without exec, $! is the subshell PID (gone after its child exits) and stop.sh
  # would kill the wrong process, leaving portless + dev server orphaned.
  #
  # Mode selection (M127):
  #   share_mode=tailscale (#1561)  → portless --tailscale (tailnet-only, auto-HTTPS)
  #   share_mode=funnel    (#1561)  → portless --funnel    (publicly exposed)
  #   is_monorepo          (#1562)  → bare portless (auto-discovers workspace dev scripts)
  #   default                       → portless <slug> <pkg-mgr> run dev (current behavior)
  local mode_label="single"
  local share_flag=""
  case "${share_mode}" in
    tailscale) share_flag="--tailscale" ;;
    funnel)    share_flag="--funnel"    ;;
  esac

  local wrap_cmd=""
  if is_monorepo; then
    mode_label="monorepo"
    if [[ -n "${share_flag}" ]]; then
      wrap_cmd="portless ${share_flag}"
      printf '[4] monorepo + %s — portless %s (background, zero-config)\n' "${share_mode}" "${share_flag}" >&2
      ( cd "${PROJECT_DIR}" && exec portless "${share_flag}" >>"${LOG_FILE}" 2>&1 ) &
    else
      wrap_cmd="portless"
      printf '[4] monorepo detected — portless (bare, zero-config)\n' >&2
      ( cd "${PROJECT_DIR}" && exec portless >>"${LOG_FILE}" 2>&1 ) &
    fi
  else
    if [[ -n "${share_flag}" ]]; then
      wrap_cmd="portless ${share_flag} ${slug} ${pkg_mgr} run dev"
      printf '[4] portless %s %s %s run dev (background)\n' "${share_flag}" "${slug}" "${pkg_mgr}" >&2
      ( cd "${PROJECT_DIR}" && exec portless "${share_flag}" "${slug}" "${pkg_mgr}" run dev >>"${LOG_FILE}" 2>&1 ) &
    else
      wrap_cmd="portless ${slug} ${pkg_mgr} run dev"
      printf '[4] portless %s %s run dev (background)\n' "${slug}" "${pkg_mgr}" >&2
      ( cd "${PROJECT_DIR}" && exec portless "${slug}" "${pkg_mgr}" run dev >>"${LOG_FILE}" 2>&1 ) &
    fi
  fi
  local wrap_pid=$!

  # 5. Wait for portless to register the route, then wait-on the dev server.
  # Monorepo mode skips slug-based polling (multiple subdomains auto-assigned).
  local base_url=""
  if [[ "${mode_label}" == "monorepo" ]]; then
    sleep 3  # give bare portless a moment to discover and register subdomains
    base_url="$(portless list 2>/dev/null | head -1 | awk '{print $1}')"  # silent: best-effort
    [[ -z "${base_url}" ]] && base_url="(see 'portless list')"
    printf '[5] portless registered subdomain map (monorepo) — see /ork:dev status or `portless list`\n' >&2
  else
    for _ in $(seq 1 30); do
      base_url=$(portless_url "${slug}" || true)  # silent: gating-relaxed
      if [[ -n "${base_url}" ]]; then break; fi
      sleep 1
    done
    if [[ -z "${base_url}" ]]; then
      printf '✗ portless never registered route %s.localhost (see %s)\n' "${slug}" "${LOG_FILE}" >&2
      kill "${wrap_pid}" 2>/dev/null || true  # silent: post-cleanup
      [[ "${e_pid}" != "0" ]] && kill "${e_pid}" 2>/dev/null || true  # silent: post-cleanup
      exit 1
    fi
    printf '[5] route registered: %s — waiting for dev server to respond\n' "${base_url}" >&2
    if ! npx --yes wait-on --httpTimeout 30000 --tlsCheck false "${base_url}" 2>>"${LOG_FILE}"; then
      printf '✗ %s did not respond in 30s (see %s)\n' "${base_url}" "${LOG_FILE}" >&2
      kill "${wrap_pid}" 2>/dev/null || true  # silent: post-cleanup
      [[ "${e_pid}" != "0" ]] && kill "${e_pid}" 2>/dev/null || true  # silent: post-cleanup
      exit 1
    fi
  fi

  # 5b. Tailscale URL capture (M127 #1561) — best-effort.
  local tailscale_url=""
  local expires_at=""
  if [[ -n "${share_mode}" ]]; then
    tailscale_url="$(tailscale status --json 2>/dev/null | jq -r '.Self.DNSName // empty' | sed 's:\.$::')"  # silent: best-effort
    if [[ -n "${tailscale_url}" ]]; then
      tailscale_url="https://${tailscale_url}"
    fi
    if [[ "${live_duration_hours}" != "0" ]]; then
      # Cross-platform date arithmetic (BSD vs GNU).
      if date -u -v+1H +%s >/dev/null 2>&1; then  # silent: gating-relaxed
        expires_at="$(date -u -v+"${live_duration_hours}"H +%Y-%m-%dT%H:%M:%SZ)"
      else
        expires_at="$(date -u -d "+${live_duration_hours} hours" +%Y-%m-%dT%H:%M:%SZ)"
      fi
    fi
  fi

  # 6. agent-browser session — lazy; first navigate registers it. Skipped in monorepo.
  if [[ "${mode_label}" != "monorepo" ]]; then
    printf '[6] agent-browser session %s + warmup\n' "${slug}" >&2
    AGENT_BROWSER_SESSION="${slug}" agent-browser open "${base_url}" >>"${LOG_FILE}" 2>&1 || true  # silent: best-effort
  fi

  # 7. atomic state write — pure jq.
  local tmp="${STATE_FILE}.tmp"
  local emu_services_json; emu_services_json=$(emulator_services_json)
  local now; now=$(date -u +%Y-%m-%dT%H:%M:%SZ)

  jq -n \
    --arg     bootedAt   "${now}" \
    --arg     branch     "${branch}" \
    --arg     subdomain  "${slug}.localhost" \
    --arg     baseUrl    "${base_url}" \
    --argjson wrap_pid   "${wrap_pid}" \
    --arg     wrap_cmd   "${wrap_cmd}" \
    --argjson e_pid      "${e_pid}" \
    --arg     e_cmd      "${e_cmd}" \
    --arg     session    "${slug}" \
    --argjson emu        "${emu_services_json}" \
    --arg     mode       "${mode_label}" \
    --arg     shareMode  "${share_mode}" \
    --arg     tsUrl      "${tailscale_url}" \
    --arg     expiresAt  "${expires_at}" \
    '{
       bootedAt:  $bootedAt,
       branch:    $branch,
       subdomain: $subdomain,
       baseUrl:   $baseUrl,
       mode:      $mode,
       processes: ({
         portlessWrapper: {pid: $wrap_pid, command: $wrap_cmd},
         agentBrowser:    {sessionName: $session}
       } + (if $e_pid > 0 then {emulate: {pid: $e_pid, command: $e_cmd}} else {} end)),
       emulators: $emu,
       share:     (if $shareMode == "" then null else
                    {mode: $shareMode, tailscaleUrl: $tsUrl, expiresAt: (if $expiresAt == "" then null else $expiresAt end)}
                  end),
       notes: "portless proxy daemon is shared and not tracked here — stop.sh leaves it running."
     }' > "${tmp}"
  mv "${tmp}" "${STATE_FILE}"

  # Append a live-demo entry when --live is used (#1565). Doctor reads this jsonl
  # to warn about demos older than 24h.
  if [[ "${share_mode}" == "funnel" && "${live_duration_hours}" != "0" ]]; then
    local live_log="${STATE_DIR}/live-demos.jsonl"
    jq -nc \
      --arg     branch    "${branch}" \
      --arg     bootedAt  "${now}" \
      --arg     expiresAt "${expires_at}" \
      --arg     url       "${tailscale_url}" \
      '{branch: $branch, bootedAt: $bootedAt, expiresAt: $expiresAt, url: $url}' \
      >> "${live_log}"
  fi

  # 8. summary
  printf '\nork:dev — booted (branch %s, mode %s)\n' "${branch}" "${mode_label}" >&2
  printf '  ✓ portless     %s\n' "${base_url}" >&2
  if [[ "${e_pid}" != "0" ]]; then
    local svc; svc=$(printf '%s' "${emu_services_json}" | jq -r 'if (length>0) then join(", ") else "(empty config)" end')
    printf '  ✓ emulate      %s (pid %s)\n' "${svc}" "${e_pid}" >&2
  fi
  printf '  ✓ %s dev    pid %s (wrapped by portless)\n' "${pkg_mgr}" "${wrap_pid}" >&2
  if [[ "${mode_label}" != "monorepo" ]]; then
    printf '  ✓ agent-browser  session "%s"\n' "${slug}" >&2
  fi

  # M127 #1561: share-mode banner with security note for --funnel.
  if [[ -n "${share_mode}" ]]; then
    if [[ -n "${tailscale_url}" ]]; then
      printf '  ✓ public URL    %s   (mode: %s)\n' "${tailscale_url}" "${share_mode}" >&2
      printf '    PORTLESS_TAILSCALE_URL=%s\n' "${tailscale_url}" >&2
    else
      printf '  ⚠ %s mode requested but Tailscale URL not yet available — check `tailscale status`\n' "${share_mode}" >&2
    fi
    if [[ "${share_mode}" == "funnel" ]]; then
      printf '  ⚠ funnel mode is PUBLIC on the internet. Anyone with the URL can reach the dev server.\n' >&2
    fi
    if [[ -n "${expires_at}" ]]; then
      printf '    expires at %s (%sh)\n' "${expires_at}" "${live_duration_hours}" >&2
    fi
  fi

  # M127 #1560: surface json-render devtools URL hint when adapter detected.
  local jr_adapter; jr_adapter=$(json_render_adapter)
  if [[ -n "${jr_adapter}" ]]; then
    printf '  → json-render devtools: import "@json-render/devtools-%s" in your dev entry to enable the Spec/State/Actions/Stream/Catalog/Pick inspector.\n' "${jr_adapter}" >&2
  fi

  # M127 #1563: surface Clerk emulator hint when @clerk/* detected.
  if has_clerk && [[ "${e_pid}" != "0" ]]; then
    if printf '%s' "${emu_services_json}" | jq -e 'index("clerk")' >/dev/null 2>&1; then  # silent: gating-relaxed
      printf '  → clerk emulator    mock login at http://localhost:4012  (run /ork:emulate-seed --auto if missing)\n' >&2
    else
      printf '  ⚠ @clerk/* detected in deps but `clerk` not in emulate.config.yaml — run /ork:emulate-seed --auto.\n' >&2
    fi
  fi

  printf '\nOpen %s or run /ork:expect\n' "${base_url}" >&2
}

# Run main() only when executed directly. Sourcing the file (e.g. from tests)
# exposes the helper functions without booting the lab stack.
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
  main "$@"
fi

#!/usr/bin/env bash
# Generated by OrchestKit Claude Plugin — Created: 2026-04-27
# /ork:dev status — inspect this branch's lab-stack state.
# Exit codes: 0 = at least one tracked PID alive, 1 = down or no state.
# --quiet : suppress output, exit code only (used by boot.sh idempotency check).

set -euo pipefail

QUIET=0
[[ "${1:-}" == "--quiet" ]] && QUIET=1

PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
STATE_FILE="${PROJECT_DIR}/.claude/state/dev-stack.json"

if [[ ! -f "${STATE_FILE}" ]]; then
  [[ ${QUIET} -eq 0 ]] && printf 'ork:dev — no state file. Run /ork:dev to boot.\n' >&2
  exit 1
fi

if ! command -v jq >/dev/null 2>&1; then
  [[ ${QUIET} -eq 0 ]] && printf 'ork:dev — jq not found. Install: brew install jq\n' >&2
  exit 1
fi

# Liveness probe: is at least one tracked, integer PID still running?
any_live=0
while IFS= read -r pid; do
  [[ -z "${pid}" || "${pid}" == "0" || "${pid}" == "null" ]] && continue
  if kill -0 "${pid}" 2>/dev/null; then any_live=1; break; fi
done < <(jq -r '.processes // {} | to_entries[] | .value.pid // empty' "${STATE_FILE}")

if [[ ${any_live} -ne 1 ]]; then
  [[ ${QUIET} -eq 0 ]] && printf 'ork:dev — state file exists but stack is dead.\n' >&2
  exit 1
fi

if [[ ${QUIET} -eq 1 ]]; then
  exit 0
fi

# Pretty status.
branch=$(   jq -r '.branch    // "?"' "${STATE_FILE}")
base_url=$( jq -r '.baseUrl   // "?"' "${STATE_FILE}")
booted=$(   jq -r '.bootedAt  // ""'  "${STATE_FILE}")
ems=$(      jq -r '(.emulators // []) | join(", ")' "${STATE_FILE}")

printf 'ork:dev — %s\n' "${branch}"

while IFS=$'\t' read -r name pid cmd; do
  [[ -z "${name}" ]] && continue
  local_mark="✗"
  if [[ -n "${pid}" && "${pid}" != "0" && "${pid}" != "null" ]] && kill -0 "${pid}" 2>/dev/null; then
    local_mark="✓"
  elif [[ "${name}" == "agentBrowser" ]]; then
    # Sessions are lazy — sessionName presence is enough to consider them registered.
    local_mark="✓"
  fi
  printf '  %s %-18s %s\n' "${local_mark}" "${name}" "${cmd}"
done < <(jq -r '
  (.processes // {}) | to_entries[]
  | [ .key, (.value.pid // 0 | tostring), (.value.command // .value.sessionName // "") ]
  | @tsv
' "${STATE_FILE}")

[[ -n "${ems}" ]] && printf '  emulators: %s\n' "${ems}"
printf '  base url:  %s\n' "${base_url}"
[[ -n "${booted}" ]] && printf '  booted:    %s\n' "${booted}"

# Cross-check: portless's own view of the route.
if command -v portless >/dev/null 2>&1; then
  slug="$(jq -r '.subdomain // ""' "${STATE_FILE}" | sed 's/\.localhost$//')"
  if [[ -n "${slug}" ]]; then
    if portless list 2>/dev/null | grep -qE "https?://${slug}\.localhost(:[0-9]+)?\b"; then
      printf '  portless:  route registered ✓\n'
    else
      printf '  portless:  route NOT registered (wrapper may have died)\n'
    fi
  fi
fi

#!/usr/bin/env bash
# Generated by OrchestKit Claude Plugin — Created: 2026-04-27
# /ork:dev stop — tear down this branch's lab stack.
#
# Reverse boot order: agent-browser session → portless wrapper (kills wrapped dev server)
# → emulate. The portless PROXY DAEMON is shared and is NOT stopped here — that's a
# separate concern (`portless proxy stop` if you really mean it).

set -euo pipefail

PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
STATE_FILE="${PROJECT_DIR}/.claude/state/dev-stack.json"

if [[ ! -f "${STATE_FILE}" ]]; then
  printf 'ork:dev — no state file found, nothing to stop.\n' >&2
  exit 0
fi

if ! command -v jq >/dev/null 2>&1; then
  printf 'ork:dev — jq not found. Install: brew install jq\n' >&2
  exit 1
fi

session=$( jq -r '.processes.agentBrowser.sessionName  // ""'  "${STATE_FILE}")
wrap_pid=$(jq -r '.processes.portlessWrapper.pid       // 0'   "${STATE_FILE}")
e_pid=$(   jq -r '.processes.emulate.pid               // 0'   "${STATE_FILE}")
slug=$(    jq -r '.subdomain                            // ""' "${STATE_FILE}" | sed 's/\.localhost$//')

printf 'ork:dev — sending SIGTERM in reverse boot order…\n' >&2

# 1. agent-browser — close the session's browser if any.
if [[ -n "${session}" ]]; then
  if AGENT_BROWSER_SESSION="${session}" agent-browser close 2>/dev/null; then
    printf '  ✓ agent-browser session "%s" closed\n' "${session}" >&2
  else
    printf '  ⚠ agent-browser session "%s" not active\n' "${session}" >&2
  fi
fi

# 2. portless wrapper — kill its descendants FIRST (the wrapped dev server +
# any forked node processes), then the wrapper itself. portless doesn't always
# propagate SIGTERM cleanly, so we walk the process tree explicitly.
if [[ "${wrap_pid}" != "0" ]] && kill -0 "${wrap_pid}" 2>/dev/null; then
  descendants=()
  queue=("${wrap_pid}")
  while [[ ${#queue[@]} -gt 0 ]]; do
    parent="${queue[0]}"
    queue=("${queue[@]:1}")
    while IFS= read -r kid; do
      [[ -z "${kid}" ]] && continue
      descendants+=("${kid}")
      queue+=("${kid}")
    done < <(pgrep -P "${parent}" 2>/dev/null || true)
  done

  # SIGTERM leaves-first, then the wrapper.
  for ((i=${#descendants[@]}-1; i>=0; i--)); do
    kill -TERM "${descendants[i]}" 2>/dev/null || true
  done
  kill -TERM "${wrap_pid}" 2>/dev/null || true

  for _ in 1 2 3 4 5; do kill -0 "${wrap_pid}" 2>/dev/null || break; sleep 1; done
  if kill -0 "${wrap_pid}" 2>/dev/null; then
    for d in "${descendants[@]}"; do kill -KILL "${d}" 2>/dev/null || true; done
    kill -KILL "${wrap_pid}" 2>/dev/null || true
  fi
  printf '  ✓ portless wrapper (pid %s) + %d descendant(s) stopped\n' \
    "${wrap_pid}" "${#descendants[@]}" >&2
fi

# 3. emulate (sidecar)
if [[ "${e_pid}" != "0" ]] && kill -0 "${e_pid}" 2>/dev/null; then
  kill -TERM "${e_pid}" 2>/dev/null || true
  printf '  ✓ emulate (pid %s) stopped\n' "${e_pid}" >&2
fi

# Note: portless PROXY DAEMON intentionally NOT stopped — it's a shared resource.
# Verify the route is gone (portless detects wrapper exit and unregisters).
if [[ -n "${slug}" ]] && portless list 2>/dev/null | grep -qE "https?://${slug}\.localhost(:[0-9]+)?\b"; then
  printf '  ⚠ portless route %s.localhost still registered (proxy may need a moment)\n' "${slug}" >&2
fi

rm -f "${STATE_FILE}"
printf 'Cleared %s\n' "${STATE_FILE}" >&2
printf '\nNote: portless proxy daemon left running (shared). Run `portless proxy stop` if you really mean to stop the daemon.\n' >&2

{
  "skill": "dev",
  "version": "1.0.0",
  "testCases": [
    {
      "id": "trigger-bare",
      "rule": null,
      "query": "/ork:dev",
      "expectedBehavior": [
        "Triggers the dev skill, not portless or emulate-seed alone",
        "Calls scripts/boot.sh",
        "Detects package manager from lockfile (pnpm > yarn > bun > npm)",
        "Resolves subdomain from current git branch slug",
        "Verifies portless + emulate + agent-browser binaries before any side effects"
      ]
    },
    {
      "id": "trigger-stop",
      "rule": null,
      "query": "/ork:dev stop",
      "expectedBehavior": [
        "Calls scripts/stop.sh",
        "Reads .claude/state/dev-stack.json for tracked PIDs",
        "Sends SIGTERM in reverse boot order: agent-browser, dev server, emulate, portless",
        "Falls back to SIGKILL after 5 seconds for unresponsive processes",
        "Removes the state file last"
      ]
    },
    {
      "id": "trigger-status",
      "rule": null,
      "query": "/ork:dev status",
      "expectedBehavior": [
        "Calls scripts/status.sh",
        "Probes each tracked PID with kill -0",
        "Prints booted-at, branch, baseUrl, and per-process live/dead",
        "Exit code 0 if at least one PID is alive, 1 if all dead or no state file"
      ]
    },
    {
      "id": "rule-prereq-missing",
      "rule": "lab-stack-prerequisites",
      "query": "/ork:dev (with portless not installed)",
      "expectedBehavior": [
        "Detects missing portless binary",
        "Prints `✗ portless not found.   Install: npm i -g portless`",
        "Does NOT start emulate, dev server, or agent-browser",
        "Exits 0 (graceful skip, not an error)"
      ]
    },
    {
      "id": "rule-idempotent-rerun",
      "rule": "idempotent-boot",
      "query": "/ork:dev (when stack is already live)",
      "expectedBehavior": [
        "Reads existing .claude/state/dev-stack.json",
        "Probes PIDs via kill -0 to confirm at least one is alive",
        "Prints 'already running' message and exits 0",
        "Does NOT spawn duplicate processes"
      ]
    },
    {
      "id": "rule-stale-state",
      "rule": "idempotent-boot",
      "query": "/ork:dev (state file exists but all PIDs dead)",
      "expectedBehavior": [
        "Detects stale state via liveness probe failure",
        "Removes .claude/state/dev-stack.json",
        "Proceeds with full boot sequence"
      ]
    },
    {
      "id": "rule-subdomain-slug",
      "rule": "branch-named-subdomain",
      "query": "/ork:dev (on branch feat/m125-Lane-B with mixed case + slash)",
      "expectedBehavior": [
        "Slug becomes feat-m125-lane-b (slashes → dashes, lowercased)",
        "DNS hostname is feat-m125-lane-b.localhost",
        "Capped at 63 characters",
        "agent-browser session name == feat-m125-lane-b"
      ]
    },
    {
      "id": "ci-escape-hatch",
      "rule": "lab-stack-prerequisites",
      "query": "/ork:dev (with CI=1 env)",
      "expectedBehavior": [
        "Detects CI environment",
        "Prints 'CI=1, skipping boot.'",
        "Exits 0 immediately, before any prerequisite checks"
      ]
    },
    {
      "id": "compose-with-emulate-seed",
      "rule": null,
      "query": "/ork:dev (with no emulate.config.yaml)",
      "expectedBehavior": [
        "Skips emulate up step (no config file present)",
        "Suggests running /ork:emulate-seed --auto first",
        "Continues to boot portless, dev server, agent-browser without emulators"
      ]
    },
    {
      "id": "compose-with-expect",
      "rule": null,
      "query": "/ork:expect (after /ork:dev has booted)",
      "expectedBehavior": [
        "Reads .claude/state/dev-stack.json to find baseUrl + agent-browser session",
        "Reuses existing session named after the branch slug (no second handshake)",
        "If posttool/ui-change-detector fired before, picks up the route hint"
      ]
    }
  ]
}