tick.sh

#!/bin/bash
# 파일시스템 티켓 디스패처(프로젝트 무관). 진입점은 워커 스크립트다 - 이 파일을 직접 부르지 않는다.
# 워커 = <티켓루트>/workers/<이름>.sh, 이 파일을 `.`(source)하는 두 줄짜리 셸 스크립트.
# 크론잡 하나가 워커 하나고, 한 번 실행에 티켓 1건을 동기로 끝낸다. 더 돌리려면 워커를 더 둔다.
#   <루트>/workers/w1.sh              티켓 1건 디스패치 (cron 진입점)
#   <루트>/workers/w1.sh list         열린 티켓 큐 상태
#   <루트>/workers/w1.sh unassign H   티켓 H의 할당(session_id) 해제 -> 큐 복귀
#                        (산 세션이면 거부하고 exit 3. --force면 그 pid를 죽여서 푼다)
#   <루트>/workers/w1.sh reap         스테일 수거만 1회
#   <루트>/workers/w1.sh dryrun       실행 없이 선정 결과만 출력
#   <루트>/workers/w1.sh poll H 스크립트파일명 상한   폴링 대기로 전환(§폴링 대기 결정 8).
#                        <루트>/polls/<스크립트파일명>이 있어야 하고, 검사 다섯을 하나라도
#                        걸리면 frontmatter를 안 고치고 0이 아닌 코드로 거절한다
#   <루트>/workers/w1.sh tick H       지목 디스패치(DESIGN.md §1-5 갈래 B) - 후보를 H 하나로 좁힌다
#   <루트>/workers/w1.sh preempt H [--dryrun]   선점(§1-5 갈래 C) - 피해자를 끊고 H를 지목 디스패치
# 워커 계약(설정 가능한 값)은 worker.sh.example 참조.
set -uo pipefail

export PATH="$HOME/.local/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"

# 코드(이 레포)와 워커(티켓 루트 안)는 다른 곳에 있다.
#   BASH_SOURCE = 이 파일(source돼도 맞다)  |  $0 = 나를 source한 워커 스크립트
SELF="${BASH_SOURCE[0]}"
while [ -L "$SELF" ]; do SELF="$(readlink "$SELF")"; done
CODE="$(cd "$(dirname "$SELF")" && pwd -P)"
PY="$CODE/tickets.py"

# 워커 위치가 곧 티켓 루트다: <루트>/workers/<이름>.sh. 그래서 루트를 어디에도 적지 않는다.
WORKERS="$(cd "$(dirname "$0")" 2>/dev/null && pwd -P)"
if [ "$(basename "${WORKERS:-/}")" != "workers" ]; then
  echo "이 파일은 직접 실행하지 않는다. <티켓루트>/workers/<이름>.sh 를 만들어 source하세요 ($CODE/worker.sh.example 참조)" >&2
  exit 2
fi
TICKET_ROOT="$(dirname "$WORKERS")"
LOGDIR="$WORKERS/logs"
RUNLOG="$WORKERS/runner.log"
# 머신 로컬 상태(토큰·실행 락). 티켓 루트가 공유 드라이브여도 비밀과 pid는 여기 남는다.
LOCAL="${TICKET_LOCAL:-$HOME/.config/dira}"
# 멀티플레잉(§0-18): TICKET_SLOT이 비어 있으면 이 값은 오늘과 글자 그대로 같다.
TOKENF="$LOCAL/oauth-token${TICKET_SLOT:+-$TICKET_SLOT}"
mkdir -p "$LOGDIR" "$LOCAL/run" "$TICKET_ROOT/tickets" "$TICKET_ROOT/polls"

log() { printf '%s [%s] %s\n' "$(date '+%F %T')" "${TICKET_NAME:-?}" "$*" >> "$RUNLOG"; }

TICKET_NAME="${TICKET_NAME:-$(basename "$0" .sh)}"
# 기본 작업 디렉터리 = 루트의 부모(<프로젝트>/.dira/workers/w1.sh -> <프로젝트>)
TICKET_CWD="${TICKET_CWD:-$(dirname "$TICKET_ROOT")}"

# 프롬프트에 큐 경로를 적을 때, 같은 곳을 가리키는 워크트리 안의 이름이 있으면 그 이름을
# 쓴다(§워커는 언제나 자기 워크트리에서 일한다 §개정 1). 읽는 파일은 안 갈린다 - 프롬프트
# 문자열만 바뀐다. $1이 $TICKET_ROOT 밖이거나(TICKET_ONTOLOGY 같은 오버라이드) 후보 디렉터리가
# 같은 canonical로 안 풀리면(TICKET_CWD 없는 워커) 원래 경로를 그대로 낸다.
wtpath() {
  local canonical="$1" rest base candroot
  case "$canonical" in
    "$TICKET_ROOT"/*) rest="${canonical#"$TICKET_ROOT"/}" ;;
    *) printf '%s\n' "$canonical"; return ;;
  esac
  base="$(basename "$TICKET_ROOT")"
  candroot="$TICKET_CWD/$base"
  if [ -d "$candroot" ] && [ "$(cd "$candroot" 2>/dev/null && pwd -P)" = "$TICKET_ROOT" ]; then
    printf '%s\n' "$candroot/$rest"
  else
    printf '%s\n' "$canonical"
  fi
}
TICKET_MAXRUN="${TICKET_MAXRUN:-5400}"
# 디스패치가 실제로 섰다고 볼 때까지 기다리는 상한(프롬프트 주입 완료 + 엔진 init).
# 프롬프트는 파이프 버퍼보다 크므로 엔진이 stdin을 빨아야만 주입이 끝난다 - 기동 중 멎으면 영영 안 끝난다.
TICKET_FEED_TIMEOUT="${TICKET_FEED_TIMEOUT:-120}"
# 프롬프트 포맷의 %s = 티켓 해시 하나뿐이다(역할 호칭은 페르소나 프로필이 대신한다).
TICKET_PROMPT_FMT="${TICKET_PROMPT_FMT:-%s 티켓을 확인해 주세요. (해당 티켓은 이미 진행중으로 잡아두었습니다. 수행을 마치면 완료 상태로 rename하고, 막히면 티켓 본문에 블록 이력을 남겨주세요.)}"
# 세션 재활용(§4-11, §제약 1 §결정 기록 §열셋째). 0이면 기능 전체를 끈다(기본 켜짐).
# CTX는 마지막 assistant 턴 컨텍스트(input+cache_creation+cache_read)의 재활용 상한이다.
TICKET_REUSE="${TICKET_REUSE:-1}"
TICKET_REUSE_CTX="${TICKET_REUSE_CTX:-100000}"

# 엔진 수정 서른네 번째 승인 §판정 1. `## 진행 계획`이 이 초(기본 1200 = 20분) 동안 안 갈리면
# 감시 루프가 세션 inbox에 참견 한 줄을 넣는다. 0이면 장치가 꺼진다. 값의 근거는 임계값
# 실측표(정상 간격의 5.1%만 넘고, 반례 세션의 34분 생존은 잡는다) - docs/DESIGN.md 그 절.
TICKET_PLAN_NUDGE="${TICKET_PLAN_NUDGE:-1200}"
# 엔진 수정 서른여섯 번째 승인 §판정 2. 참견을 넣은 뒤 이 초 동안도 티켓 파일이 안 갈리면
# 그 세션을 끊고 티켓을 되돌린다. 0이면 장치가 꺼진다(기본값) - 반례가 4.8%뿐인 실측표라
# 켜는 값은 운영이 관측하며 고른다. 사람 참견이 그 사이 들어왔으면 안 끊는다(check_plan_kill).
TICKET_PLAN_KILL="${TICKET_PLAN_KILL:-0}"

# 엔진 수정 마흔한 번째 승인 §판정 1. `result ok`를 낸 세션이 티켓을 `.wip`으로 남긴 채
# 죽기 전, 이번 구간에 하네스가 밀어낸(`moved to the background`) 명령이 있으면 그 알림이
# 닿을 창을 이 초(기본 40)만큼 준다. 0이면 장치가 꺼진다. 기본값은 apps/teams의 pnpm test
# 실측 셋(24.07s/22.41s/22.51s, 최댓값의 1.5배 36.105s를 10초 단위로 올림)이다.
TICKET_BG_GRACE="${TICKET_BG_GRACE:-40}"
# 한 티켓에서 유예가 몇 번까지 걸리는지의 상한. 밀린 작업이 계속 새로 생기는 세션이 창을
# 무한히 늘리는 것을 이 수가 막는다 - REUSE로 새 티켓을 받으면 다시 0부터 잰다.
TICKET_BG_MAX="${TICKET_BG_MAX:-2}"

# 엔진 수정 서른아홉 번째 승인 §판정 1. MAXRUN 감시 루프가 이 초(기본 60)마다
# `workers/health/YYYYMMDD.log`에 바깥 상태 한 줄을 적는다. 부모 셸까지 함께 죽는 세션은 종료
# 줄을 남길 손이 없으므로, 죽기 직전 상태를 남기려면 종료 시점이 아니라 도는 동안 적어야 한다.
# 0이면 장치가 꺼지고 파일도 디렉터리도 안 생긴다.
TICKET_HEALTH_INTERVAL="${TICKET_HEALTH_INTERVAL:-60}"

# 엔진 수정 스물네·스물일곱 번째 계약: 워커가 부르는 실행 파일의 자리를 고정 경로로 모은다.
# claude 실행 파일은 심링크고 실체가 업데이트마다 새 버전 디렉터리로 옮겨간다(이 머신 버전
# 디렉터리 32개) - macOS TCC는 허용을 절대경로로 적어서 매 업데이트가 새 TCC 항목이 된다.
# BIN_DIR을 그 실체로 매 tick 다시 겨눠, 경로 문자열은 고정한 채(TCC 항목 1개) 가리키는
# 실체만 갈리게 한다. 심링크는 답이 아니다 - exec가 심링크를 풀어서 TCC가 여전히 버전 경로를 본다.
# §27 계약 1: bin 자리는 TICKET_LOCAL을 안 탄다 - 프로젝트가 락·토큰을 자기 디렉터리로 빼도
# 실행 파일은 머신에 한 자리다(오늘 기본값이 이미 이 값이라 도는 경로는 안 갈린다).
BIN_DIR="$HOME/.config/dira/bin"
FIXED_ENGINE="$BIN_DIR/dira"
refresh_fixed_engine() {
  # §27 계약 2: 카탈로그 넷을 각각 굽는다 - claude만 이름이 dira, 나머지는 dira-<엔진>
  # (§24 계약 3 접미사 판정과 대응). PATH에 없는 엔진은 조용히 건너뛴다(WARN 없음).
  local pair cmd bin src real tmp
  mkdir -p "$BIN_DIR" 2>/dev/null || return 1
  for pair in claude:dira codex:dira-codex grok:dira-grok agy:dira-agy; do
    cmd="${pair%%:*}"
    bin="$BIN_DIR/${pair#*:}"
    src="$(command -v "$cmd" 2>/dev/null)" || continue
    [ -x "$src" ] || continue
    # §계약 3 판정(2026-08-25): 신선도는 굽힌 파일의 inode가 아니라 <PATH의 실체가 여전히
    # 같은가>로 잰다 - 아래가 복사라 `-ef`(device+inode 비교)는 언제나 거짓이 된다. 실체 경로를
    # `$bin.src`에 적어 두고 문자열로 대조한다(`readlink -f`는 BSD에 없어 python3로 낸다).
    real="$(python3 -c 'import os,sys;print(os.path.realpath(sys.argv[1]))' "$src" 2>/dev/null)"
    [ -n "$real" ] || continue
    [ -e "$bin" ] && [ "$(cat "$bin.src" 2>/dev/null)" = "$real" ] && continue
    tmp="$bin.tmp.$$"
    # 별도 inode로 굽는다 - 하드링크는 tccd가 원본 inode의 이름을 그대로 아이덴티티로 적어
    # TCC 항목이 안 모인다(§계약 3 판정 실측). APFS 클론(`cp -c`)이 서면 디스크를 안 물고,
    # 안 서면(다른 볼륨·비-APFS) 보통 복사로 떨어진다. 임시 이름에 만든 뒤 mv로 원자 교체 -
    # 여러 워커가 동시에 tick을 돌아도 실행 파일이 반쪽으로 보이는 창이 없다.
    if cp -c "$src" "$tmp" 2>/dev/null || cp "$src" "$tmp" 2>/dev/null; then
      mv -f "$tmp" "$bin" && printf '%s' "$real" > "$bin.src" 2>/dev/null
    else
      rm -f "$tmp"
    fi
  done
  # §27 계약 4: mv -f가 지금 실행 중인 고정 경로를 못 덮을 때(macOS ETXTBSY, 워커 여러 장이
  # 도는 큐에서는 정상) 남는 임시 파일을 갱신할 때마다 쓸어낸다. 갱신 실패는 종전대로 조용하다.
  rm -f "$BIN_DIR"/*.tmp.[0-9]* 2>/dev/null
}
refresh_fixed_engine

# 실행 엔진. 워커가 TICKET_ENGINE 배열로 덮어쓴다. {prompt}/{sid}는 실행 직전 치환된다.
# ${arr[@]+"..."}는 set -u에서 미정의 배열을 안전하게 전개하는 관용구(bash 3.2 포함).
# 기본 엔진은 스트리밍 입력이다: 최초 프롬프트도 argv가 아니라 stdin(FIFO)으로 간다.
# 그래야 세션이 도는 동안 사람이 같은 입구로 말을 걸 수 있다(참견).
TICKET_ENGINE=(${TICKET_ENGINE[@]+"${TICKET_ENGINE[@]}"})
[ ${#TICKET_ENGINE[@]} -eq 0 ] && TICKET_ENGINE=("$FIXED_ENGINE" -p --session-id "{sid}" \
  --dangerously-skip-permissions \
  --input-format stream-json --output-format stream-json --verbose)
# 상태 접미사는 tickets.py가 환경변수로 읽는다(미설정이면 .wip/.done).
# TICKET_ONTOLOGY는 graph.py가 같은 형태로 읽는다(미설정이면 <큐>/ontology, 아래 ONTDIR과 동일).
export TICKET_INPROGRESS="${TICKET_INPROGRESS:-}" TICKET_DONE="${TICKET_DONE:-}" \
  TICKET_ONTOLOGY="${TICKET_ONTOLOGY:-}"
# 이 시점의 값이 "기본 엔진"이다(워커 대입 -> 없으면 위 기본값). `personas/<이름>/engine`이
# 있으면 티켓 선정 루프 안에서 후보의 persona가 확정된 뒤 이 배열을 덮어쓴다(§제약 1 §결정
# 기록 §열한 번째) - 그래서 ENGINE_NAME 계산·쿨다운·claude 인증 게이트도 전부 그 뒤로
# 옮겨졌다. 여기서 하던 계산은 이제 없다(아래 선정 루프 참조).
BASE_ENGINE=("${TICKET_ENGINE[@]}")

CDOWN_W=300   # 리밋이 복귀 시각을 안 줄 때(네트워크 실패 등)의 창 + 만료 직후 재무장 창

# 세션이 실제로 디스패치되는 순간(engine_gate_ok가 게이트를 통과하는 순간)의 엔진 지문.
# api_error는 세션이 끝난(최대 몇 시간 뒤) 자리에서 arm_cdown을 부르는데, 그때 $TOKENF를 다시
# 읽으면 이미 다음 계정으로 회전된 뒤일 수 있다 - 그 값을 그대로 쓰면 늦게 도착한 보고가 리밋을
# 만난 적 없는 새 계정을 소진으로 찍고, 동시 세션 수만큼 계정이 연쇄로 말라 NO_ELIGIBLE로 큐가
# 멎는다(DESIGN.md §0-13 §한 리밋 사건에 계정 하나만 태운다, 실측 2026-08-27). 그래서 게이트를
# 통과하는 순간의 값을 여기 붙잡아 두고 arm_cdown이 기본값으로 쓴다.
DISPATCH_FP=""

# 엔진 지문 = **인증 토큰만**. 사람이 계정을 바꾸면 값이 갈리고 그 순간 쿨다운이 풀린다 -
# 리밋이 준 복귀 시각을 그대로 기다리면 계정을 바꿔도 몇 시간을 놀기 때문이다(요구 15ceae18).
#
# 엔진 argv(모델 플래그)는 **일부러 안 넣는다**. 창은 이름이 엔진별일 뿐 머신에 하나인데
# argv는 큐마다 다르다 - 넣었더니 "지문이 갈리면 푼다"가 *남의 창을 지우는* 동작이 됐다
# (실측 2026-08-05: `--model sonnet`인 dira와 모델 플래그가 없는 stream이 서로의 창을
# 1분마다 풀어서, 16:30까지 닫혀 있어야 할 창에서 같은 티켓을 27번 태웠다).
# 모델을 갈아도 5시간 리밋은 계정에 걸린 채라 애초에 풀 근거가 아니다.
engine_fp() {
  python3 -c 'import hashlib,sys
try: tok = open(sys.argv[1], "rb").read()
except OSError: tok = b""
print(hashlib.sha1(tok).hexdigest()[:12])' \
    "$TOKENF"
}
# $2(known)는 복귀 시각을 리밋이 실제로 줬는지 - 1이면 있음, 그 외(빈 값 포함)는 미상.
# token-rotate.sh의 tick 모드가 이 3번째 줄로 "미상" 쿨다운엔 exhaustedUntil을 안 찍는다
# (요구 61028b02/fc92d14e: 미상 쿨다운을 진짜 계정 소진과 같은 칸에 찍어 마지막 eligible
# 계정이 죽고 NO_ELIGIBLE로 큐가 11분 멈춘 실측). 옛 2줄 파일을 읽는 쪽은 3번째 read가
# EOF라 빈 값 -> 안전측(미상 취급)으로 떨어진다.
arm_cdown() { printf '%s\n%s\n%s\n' "$1" "${DISPATCH_FP:-$(engine_fp)}" "${2:-0}" > "$CDOWN"; }

# claude 인증 + 엔진 쿨다운 게이트. ENGINE_NAME·CDOWN이 이미 정해진 상태에서 부른다.
# 통과 못하면 SKIP을 로그하고 1을 반환한다 - 이 엔진을 쓰는 후보 전체를 건너뛰라는 뜻이라
# 선정 루프가 이 반환값으로 ENGOVER에 등록한다(§4-11 재활용 경로는 후보가 하나뿐이라 등록 없이
# 반환값만 쓴다 - 같은 게이트를 다시 지나는 것이 §4-11 §규칙 ⑤다).
engine_gate_ok() {
  if [ "$ENGINE_NAME" = "claude" ]; then
    # claude setup-token 으로 발급 후: printf %s '<토큰>' > ~/.config/dira/oauth-token
    [ -r "$TOKENF" ] && export CLAUDE_CODE_OAUTH_TOKEN="$(tr -d '\r\n' < "$TOKENF")"
    # 비대화형 claude만 장기 토큰이 없으면 이 엔진으로 못 뜬다. `.authwarn`으로 "최초 1회만
    # 남긴다"는 종전 계약 그대로 둔다.
    if [ ! -r "$TOKENF" ] && [ ! -t 1 ]; then
      if [ ! -f "$LOCAL/.authwarn" ]; then
        log "SKIP AUTH 대기 $ENGINE_NAME (claude setup-token 발급 후 $TOKENF 에 저장 필요)"
        touch "$LOCAL/.authwarn"
      fi
      return 1
    fi
  fi
  local CUR_FP
  CUR_FP="$(engine_fp)"
  if [ -f "$CDOWN" ]; then
    local UNTIL WAS_FP NOW
    UNTIL=""; WAS_FP=""
    { read -r UNTIL; read -r WAS_FP; } < "$CDOWN"
    case "$UNTIL" in ''|*[!0-9]*) UNTIL=0 ;; esac
    NOW=$(date +%s)
    if [ "$WAS_FP" != "$CUR_FP" ]; then
      rm -f "$CDOWN"
      log "NOTE 엔진 쿨다운 해제 - 토큰·모델이 바뀌었다(남은 창 $((UNTIL - NOW))초를 안 기다린다)"
    elif [ "$NOW" -lt "$UNTIL" ]; then
      log "SKIP 엔진 쿨다운 · $((UNTIL - NOW))초 남음"
      return 1
    fi
  fi
  DISPATCH_FP="$CUR_FP"   # 이 후보가 실제로 나가는 순간의 지문 - arm_cdown이 나중에 이 값을 쓴다
  return 0
}

# 선정 잠금 획득(§5-4 SLOCK). 실패하면 SLOCK=""로 남기고 1을 반환한다 - 트랩이 남의 잠금을
# 안 지우게 하는 값이자, §4-11 재활용 판정 ⑤가 실패로 떨어지는 신호로 두 호출부가 나눠 쓴다.
acquire_slock() {
  SLOCK="$LOCAL/run/select.lock"
  if ! mkdir "$SLOCK" 2>/dev/null; then
    local SOWNER
    SOWNER=$(cat "$SLOCK/pid" 2>/dev/null)
    if [ -n "$SOWNER" ] && kill -0 "$SOWNER" 2>/dev/null; then
      # 남의 잠금이다. 비워야 트랩이 주인의 잠금을 지우지 않는다.
      SLOCK=""
      log "SKIP 다른 워커가 선정 중이다 pid=$SOWNER"
      return 1
    fi
    log "WARN 스테일 선정 잠금 회수 pid=${SOWNER:-?}"
    rm -rf "$SLOCK"
    mkdir "$SLOCK" 2>/dev/null || { SLOCK=""; log "SKIP 선정 잠금 재획득 실패"; return 1; }
  fi
  printf %s "$$" > "$SLOCK/pid"
}

# `personas/<이름>/limit` -> 정수 하나, 또는 "" = 상한 없음. 파서를 만들지 않는다.
# 양끝 공백·후행 개행은 값이 아니다 - 화면이 쓰는 사이드카는 전부 끝에 `\n`이 붙어서
# `2\n`·` 2 `·`2\n\n`이 전부 정수 2여야 한다(`read`가 첫 줄만 읽고 양끝 공백을 떼는 것이
# 그 규약 그대로다). 정수가 아니면 **상한 없음 + WARN**이고 0으로 읽지 않는다 - 오타 하나가
# 페르소나를 영구히 굶기는 쪽으로 떨어지면 안 된다.
# (아래 §선점 판정이 이 함수를 워커 락 exit 경로에서 부르므로 CMD 분기보다 앞에 선다.)
persona_limit() {
  LIMF="${TICKET_PERSONAS:-$TICKET_ROOT/personas}/$1/limit"
  [ -f "$LIMF" ] || return 0
  PL=""; read -r PL < "$LIMF" 2>/dev/null
  case "$PL" in
    '') ;;                                             # 빈 파일 = 상한 없음(기본값)
    *[!0-9]*) log "WARN 페르소나 상한이 정수가 아니다: $LIMF ($PL) - 상한 없이 돈다" ;;
    *) printf %s "$PL" ;;
  esac
}

# 그 페르소나가 지금 물고 있는 수. 단위는 `.wip` 하나고 사본이 없다 - 보드가 세는 수와 같은
# 수이고, 손 claim(session_id 없이 진행중인 티켓)도 그래서 공짜로 같이 센다. 락 디렉터리 같은
# 두 번째 표현을 만들면 스테일이 그 페르소나를 영구히 0으로 굶긴다.
# 판정은 tickets.py를 그대로 불러 쓴다(NFC·상태 접미사·persona 문자 규칙이 한 벌이어야 한다).
persona_wip() {
  python3 -c 'import sys
sys.path.insert(0, sys.argv[1])
import tickets as T
n = 0
for p in T.in_progress(sys.argv[2]):
    try: fm, _, end = T.read_fm(p)
    except (OSError, UnicodeDecodeError): continue
    if end >= 0 and T.persona_of(fm) == sys.argv[3]: n += 1
print(n)' "$CODE" "$TICKET_ROOT" "$1"
}

# 엔진 수정 서른네 번째 승인 §판정 2 - `tickets.py`의 `fresh_block`을 그대로 불러 쓴다(NFC ·
# 상태 접미사 판정을 두 곳에 두지 않는다, persona_wip과 같은 이유). exit 0 = 신선한 블록이다.
fresh_block_sh() {
  python3 -c 'import sys
sys.path.insert(0, sys.argv[1])
import tickets as T
sys.exit(0 if T.fresh_block(sys.argv[2]) else 1)' "$CODE" "$1"
}

# --- §1-5 갈래 C / §1-3 §5 — 피해자 판정은 여기 한 자리뿐이다(엔진 계약 `3acc1a56`) ---
# `maybe_preempt`(자동, 소유자 필터 있음)와 `preempt`(사람이 부르는 명령, 소유자 필터 없음)가
# 둘 다 이 함수만 부른다 - 정렬을 두 곳에 안 둔다(§1-5 §갈리는 것 하나). 성공하면 VPATH·VHASH·
# VEFF·VASSIGN·VPID·VOWNER를 전역에 채우고 0을 반환한다. $1=1이면 "내 티켓만"(소유자 필터).
pick_victim() {
  local WROWS
  VPATH=""; VHASH=""; VEFF=""; VASSIGN=""; VPID=""; VOWNER=""
  WROWS=$(python3 "$PY" wips "$TICKET_ROOT" 2>/dev/null) || return 1
  [ -z "$WROWS" ] && return 1

  # 유효 우선순위가 최저인 것, 동률이면 assigned_at이 가장 늦은 것(가장 나중에 시작한 것).
  # 정렬 키 하나로 둘 다 접는다.
  IFS='|' read -r VPATH VHASH VEFF VASSIGN VPID VOWNER <<< \
    "$(printf '%s\n' "$WROWS" | sort -t'|' -k3,3n -k4,4r | head -1)"
  [ -z "$VPATH" ] && return 1
  [ "$VEFF" -lt 5 ] || return 1                     # 5끼리는 안 끊는다
  if [ "$1" = 1 ]; then
    case "$VOWNER" in *" / $TICKET_NAME-"*) ;; *) return 1 ;; esac   # 내 티켓이 아니면 손대지 않는다
  fi
  [ -f "$VPATH" ] || return 1
  case "$VPID" in ''|*[!0-9]*) return 1 ;; esac
  return 0
}

# --- §1-3 §5 — 선점: 바쁜 워커의 즉시 exit 경로가 유일하게 도는 자리다 ---
# 중앙 스케줄러가 없다. 전원이 바쁘면 아무도 큐를 안 보므로, 워커 락에 막혀 나가는 이 순간이
# 유일하게 남은 "바쁜 워커가 도는 자리"다(새 프로세스·새 데몬 0개). 새 잠금도 0개다 - claim처럼
# 자원을 다투는 게 아니라 파일을 읽기만 하고, 각 워커는 **자기 자신이 물고 있는 티켓일 때만**
# 죽인다. 전원이 같은 파일을 보고 같은 계산을 해도 "내 티켓이 전역 최저다"는 결정적으로 한
# 워커에서만 참이라 정확히 하나만 죽는다 - 조율이 필요 없다.
maybe_preempt() {
  local PUSH5 q_path q_hash q_kind q_persona q_prio q_base q_eff q_squadp PLIM PWIP
  local WT COMMIT
  pick_victim 1 || return 0

  # 조건 1 — 유효 5 후보가 있고 자기 게이트(deps·페르소나 상한)를 다 지난다. `select`가 이미
  # deps 미충족·할당됨을 걸렀으니 여기서는 페르소나 상한만 본다(선정 루프와 같은 판정).
  PUSH5=""
  while IFS='|' read -r q_path q_hash q_kind q_persona q_prio q_base q_eff q_squadp; do
    [ "$q_eff" = "5" ] || continue
    [ -n "$q_squadp" ] && q_persona="$q_squadp"   # 스쿼드 리더가 게이트를 대신 받는다(§5-5)
    if [ -n "$q_persona" ]; then
      PLIM=$(persona_limit "$q_persona")
      if [ -n "$PLIM" ]; then
        PWIP=$(persona_wip "$q_persona")
        [ "$PWIP" -ge "$PLIM" ] && continue
      fi
    fi
    PUSH5="$q_hash"; break
  done < <(python3 "$PY" select "$TICKET_ROOT")
  [ -z "$PUSH5" ] && return 0

  # 끊긴 티켓 본문에 무슨 일이 있었는지 남긴다(§1-3 §5 §표) - git은 있으면 쓰고 없으면 그
  # 항목만 빈다(2>/dev/null, 의존성 0을 안 깬다).
  WT="$TICKET_ROOT/worktrees/$TICKET_NAME"
  COMMIT=$(git -C "$WT" rev-parse --short HEAD 2>/dev/null)
  {
    printf '\n## 선점\n\n'
    printf '| | |\n|---|---|\n'
    printf '| 시각 | %s |\n' "$(date '+%F %T')"
    printf '| 밀어낸 티켓 | %s |\n' "$PUSH5"
    printf '| 워커 · 브랜치 | %s · wt/%s |\n' "$TICKET_NAME" "$TICKET_NAME"
    printf '| 워크트리 | %s |\n' "$WT"
    printf '| 커밋 | %s |\n' "$COMMIT"
    printf '| 회수 | `.dira/protocols/재디스패치-복구.md`를 읽고 그대로 하세요. |\n'
  } >> "$VPATH"
  log "PREEMPT $VHASH -> $PUSH5 pid=$VPID"
  kill -TERM "$VPID" 2>/dev/null
}

# §1-5 갈래 B §검증 (2) — 지목한 해시가 `select` 후보에 없을 때 로그에 남길 사유 한 줄. 새
# 판정을 만들지 않는다 - `scan()`이 이미 셈한 assigned·polling·unmet 플래그와 `find_any`(상태
# 무관 검색)를 그대로 읽는다(developer PROFILE §엔진 의미 복제 - 패리티는 부르는 것으로 지킨다).
target_reason() {
  python3 -c 'import sys, os
sys.path.insert(0, sys.argv[1])
import tickets as T
troot, want = sys.argv[2], T.nfc(sys.argv[3])
for r in T.scan(troot):
    if T.nfc(r["hash"]) != want:
        continue
    if r["assigned"]:
        print("이미 할당됨(session=" + r["session_id"] + ")"); sys.exit()
    if r["polling"]:
        print("폴링 대기 중"); sys.exit()
    if r["unmet"]:
        print("deps 미충족: " + ",".join(r["unmet"])); sys.exit()
    print("대기 중인데 못 집었다 - 경합"); sys.exit()
p = T.find_any(troot, want)
print(("파일: " + os.path.basename(p)) if p else "티켓을 못 찾음")
' "$CODE" "$TICKET_ROOT" "$1"
}

# --- §폴링 대기 결정 4 §실행 상한 30초 — 백그라운드 + kill 관용구(`timeout` 바이너리는
# macOS 기본 설치에 없다). $1=스크립트 경로, $2=출력 파일(호출자가 마지막 200줄만 남긴다).
# 반환값은 스크립트의 진짜 종료 코드, 상한을 넘겨 죽인 경우는 124(결정 4 "그 밖" 취급).
run_capped() {
  : > "$2"
  "$1" > "$2" 2>&1 &
  local pid=$! waited=0
  while [ "$waited" -lt 30 ] && kill -0 "$pid" 2>/dev/null; do
    sleep 1; waited=$((waited + 1))
  done
  if kill -0 "$pid" 2>/dev/null; then
    kill -TERM "$pid" 2>/dev/null; sleep 2; kill -KILL "$pid" 2>/dev/null
    wait "$pid" 2>/dev/null
    return 124
  fi
  wait "$pid"
}

CMD="${1:-tick}"
# §1-5 갈래 B(지목 디스패치, 엔진 계약 `3acc1a56`) — `tick <해시>`일 때만 채운다. 인자 없는
# `tick` · `dryrun`은 그대로 빈 값이라 아래 선정 루프가 종전과 한 글자도 안 다르게 돈다.
TARGETHASH=""
[ "$CMD" = "tick" ] && [ -n "${2:-}" ] && TARGETHASH="$2"

case "$CMD" in
  list)
    python3 "$PY" list "$TICKET_ROOT"; exit $? ;;
  unassign)
    USAGE="사용법: $(basename "$0") unassign <티켓해시> [--force]"
    H="${2:-}"; [ -z "$H" ] && { echo "$USAGE"; exit 2; }
    # --force = 산 세션을 죽여서 푼다. 그 밖의 인자는 사용법(exit 2).
    FORCE=""; shift 2
    for a in ${@+"$@"}; do
      [ "$a" = "--force" ] && { FORCE=1; continue; }
      echo "$USAGE" >&2; exit 2
    done
    P=$(python3 "$PY" find "$TICKET_ROOT" "$H") || exit 1
    # 산 세션을 두고 할당만 풀면 티켓이 다시 열려 두 워커가 같은 티켓을 문다
    # (2026-08-01 실사고: b7bacafb·a461c2f7이 각각 세션 2개를 달았다). 죽은 뒤에 풀어라.
    # reap과 같은 근거를 쓴다: pid 생존, 그리고 ps의 --session-id.
    UPID=$(sed -n 's/^pid:[[:space:]]*//p' "$P" | head -1 | tr -d "\"' ")
    USID=$(sed -n 's/^session_id:[[:space:]]*//p' "$P" | head -1 | tr -d "\"' ")
    ALIVE=""
    case "$UPID" in ''|*[!0-9]*) ;; *) ps -p "$UPID" -o pid= >/dev/null 2>&1 && ALIVE="pid=$UPID" ;; esac
    # ps를 변수에 먼저 담고 셸이 매칭한다. `ps -eo command= | grep -- "--session-id $USID"`는
    # **grep 자신을 문다** — grep의 명령줄에 그 문자열이 그대로 들어 있고 ps가 그걸 본다.
    # 그러면 세션이 죽어도 항상 살아 있다고 판정해 unassign이 영영 거부된다(CI 실측
    # 2026-08-01: `거부: ... (session=dead-sid)`). 파이프를 없애면 매칭 시점에 grep이 없다.
    # §개정(421f440d) 결정 1 - pid= 필드를 같이 받아 매칭된 행의 pid를 $UPID에 되찾는다.
    # 헤어스트링은 이미 담긴 $PSOUT을 읽을 뿐 새 프로세스를 안 띄운다 - 함정은 그대로 닫혀 있다.
    if [ -z "$ALIVE" ] && [ -n "$USID" ]; then
      PSOUT=$(ps -eo pid=,command= 2>/dev/null)
      while IFS= read -r LINE; do
        case "$LINE" in *"--session-id $USID"*)
          set -- $LINE
          case "$1" in ''|*[!0-9]*) ;; *) UPID="$1"; ALIVE="session=$USID" ;; esac
          break ;;
        esac
      done <<< "$PSOUT"
    fi
    # 주인 세션이 자기 손으로 푸는 것은 통과다. 왕복 절차(PM PROFILE §요구사항 왕복 3단계)가
    # 부르는 자리가 바로 여기이고, 거기서 산 pid는 **부르는 세션 자신**이다(티켓 828dc247).
    # 조상 사슬로 본다 - 남의 산 세션을 푸는 것은 사슬에 없으므로 그대로 막힌다.
    if [ -n "$ALIVE" ] && [ -n "$UPID" ]; then
      ANC=$$
      while [ "$ANC" != "0" ] && [ "$ANC" != "1" ] && [ -n "$ANC" ]; do
        [ "$ANC" = "$UPID" ] && { ALIVE=""; break; }
        ANC=$(ps -p "$ANC" -o ppid= 2>/dev/null | tr -d ' ')
      done
    fi
    if [ -n "$ALIVE" ]; then
      # §개정(421f440d) 결정 2 - session= 갈래도 이제 $UPID를 들고 있어 --force로 풀 수 있다.
      # 종전엔 여기서 거부하고 끝(exit 1)이었지만, 그 판정이 죽일 프로세스를 이미 찾아 놓고도
      # pid 열을 버렸을 뿐이었다 - 아래 공통 경로로 그대로 흘려보낸다.
      if [ -z "$FORCE" ]; then
        echo "거부: $H 의 세션이 아직 살아 있다($ALIVE). 먼저 끝내거나 죽인 뒤 다시 시도하세요." >&2
        log "UNASSIGN-DENY $H $ALIVE 생존"
        # 3 = 산 세션이라 거부했다(--force면 풀 수 있다). 화면이 이 코드로 확인을 띄운다 -
        # 문구를 정규식으로 읽으면 문구를 고치는 순간 확인이 조용히 사라진다.
        exit 3
      fi
      # 죽이기 **전에** 답변 대기로 잠근다(§2-5 §개정). 열림에는 잠금이 없어서 같은 워커가
      # 1~4초 뒤 다시 문다 - 중단이 중단이 아니게 된다. 여기가 세 가지가 동시에 성립하는
      # 유일한 구간이다: 창이 0이고(deps·awaiting은 clear+release를 지나서도 남는다), 티켓 파일을
      # 쓰는 것이 나 혼자고(부모는 wait에 서 있다), 인용할 transcript가 아직 안 지워졌다.
      if ASK=$(python3 "$PY" askhuman "$P"); then log "$ASK"; else log "ASK-FAIL $H 답변 대기 잠금 실패"; fi
      # 강제: pid를 죽이면 그 세션의 부모 tick.sh가 wait에서 실패 판정으로 떨어져 이미
      # clear + release를 한다. 새 상태 전이가 아니라 그 경로를 밟게 하고 결과를 기다리는 것이다.
      kill -TERM "$UPID" 2>/dev/null
      log "UNASSIGN-FORCE $H $ALIVE 강제 중단"
      N=0
      while [ -e "$P" ] && [ "$N" -lt 15 ]; do sleep 1; N=$((N+1)); done
      if [ -e "$P" ]; then
        # 손 클레임 티켓(tickets.py handclaim)에는 풀어 줄 부모가 없다 - 여기서 우리가 푼다.
        # 단, pid가 아직 살아 있으면 풀지 않는다. 산 세션을 두고 할당만 푸는 것이 바로
        # 2026-08-01 실사고(b7bacafb·a461c2f7)의 원인이다.
        # ps는 좀비(부모가 아직 wait 안 한 죽은 자식)도 "있다"고 답한다. 그건 도는 세션이 아니다.
        case "$(ps -p "$UPID" -o state= 2>/dev/null | tr -d ' ')" in
          ''|Z*) ;;
          *) echo "실패: $H 의 pid $UPID 가 ${N}s 뒤에도 살아 있다. 할당은 그대로 둔다. 답변 대기 잠금은 걸려 있다 — 그 세션이 끝나면 백로그가 아니라 답변 대기로 선다." >&2
             log "UNASSIGN-FORCE $H pid=$UPID 안 죽음 - 해제 보류"
             exit 1 ;;
        esac
        python3 "$PY" clear "$P" || exit 1
        RP=$(python3 "$PY" release "$P") || exit 1
        [ "$RP" != "$P" ] && echo "백로그 복귀: $(basename "$RP")"
      fi
      log "UNASSIGN $H 강제(pid=$UPID ${N}s)"
      echo "강제 할당 해제: $H — 답변 대기로 잠갔다(답을 쓸 때까지 아무 워커도 안 가져간다)"
      exit 0
    fi
    # 결정 9 -- 세션이 `## 블록`을 남기고 스스로 unassign한 경로. clear+release **앞에서** 조건부로
    # 잠근다(신선한 블록 + 미충족 dep 0). 열리자마자 잠긴 채로 서야 하므로 순서가 계약이다.
    if ASK=$(python3 "$PY" askhuman "$P" --if-blocked); then [ -n "$ASK" ] && log "$ASK"; fi
    python3 "$PY" clear "$P" || exit 1
    RP=$(python3 "$PY" release "$P") || exit 1
    [ "$RP" != "$P" ] && echo "백로그 복귀: $(basename "$RP")"
    log "UNASSIGN $H"; echo "할당 해제: $H"
    exit 0 ;;
  reap)
    python3 "$PY" reap "$TICKET_ROOT" "$LOCAL" | while IFS= read -r line; do
      [ -n "$line" ] && { log "$line"; echo "$line"; }
    done
    exit 0 ;;
  poll)
    # §폴링 대기 결정 8 - 워커 스크립트 서브커맨드 하나가 대기에 드는 문이다. 검사 다섯을
    # 하나라도 걸리면 frontmatter를 한 글자도 안 고치고 0이 아닌 코드로 거절한다.
    USAGE="사용법: $(basename "$0") poll <티켓해시> <스크립트 파일명> <상한 ISO 8601>"
    H="${2:-}"; SCRIPT="${3:-}"; UNTIL="${4:-}"
    if [ -z "$H" ] || [ -z "$SCRIPT" ] || [ -z "$UNTIL" ]; then echo "$USAGE" >&2; exit 2; fi
    P=$(python3 "$PY" find "$TICKET_ROOT" "$H") || exit 1

    # 검사 1 - 값에 '/'가 없다(`../`도 걸린다) + 파일이 실제로 있고 실행 권한이 있다.
    case "$SCRIPT" in
      */*) echo "거부: 스크립트 파일명에 '/'를 쓸 수 없다: $SCRIPT" >&2; exit 1 ;;
    esac
    SCRIPTPATH="$TICKET_ROOT/polls/$SCRIPT"
    if [ ! -f "$SCRIPTPATH" ] || [ ! -x "$SCRIPTPATH" ]; then
      echo "거부: 스크립트가 없거나 실행 권한이 없다: $SCRIPTPATH" >&2; exit 1
    fi

    # 검사 2 - 머리에 `# dira-poll-interval:` 줄이 있으면 그 값이 양의 정수다.
    IVLINE=$(grep -m1 -E '^#[[:space:]]*dira-poll-interval:' "$SCRIPTPATH" 2>/dev/null)
    if [ -n "$IVLINE" ]; then
      IVVAL=$(printf '%s\n' "$IVLINE" | sed -n 's/^#[[:space:]]*dira-poll-interval:[[:space:]]*//p')
      case "$IVVAL" in
        ''|*[!0-9]*|0) echo "거부: dira-poll-interval이 양의 정수가 아니다: $IVVAL" >&2; exit 1 ;;
      esac
    fi

    # 검사 3 - <상한>이 파싱되고 지금보다 뒤다.
    UNTIL_EPOCH=$(python3 -c 'import sys, datetime
try:
    dt = datetime.datetime.fromisoformat(sys.argv[1])
    if dt.tzinfo is None: dt = dt.astimezone()
    print(int(dt.timestamp()))
except Exception:
    pass' "$UNTIL" 2>/dev/null)
    case "$UNTIL_EPOCH" in
      ''|*[!0-9]*) echo "거부: 상한 시각을 못 읽는다: $UNTIL" >&2; exit 1 ;;
    esac
    [ "$UNTIL_EPOCH" -gt "$(date +%s)" ] || { echo "거부: 상한이 과거다: $UNTIL" >&2; exit 1; }

    # 검사 4 - 그 티켓의 주인이 자기 세션이다. unassign(위 §조상 사슬)과 같은 관용구다 -
    # 이 poll 서브커맨드를 부르는 것은 그 티켓을 물고 있는 세션 자신이어야 한다.
    UPID=$(sed -n 's/^pid:[[:space:]]*//p' "$P" | head -1 | tr -d "\"' ")
    case "$UPID" in
      ''|*[!0-9]*) echo "거부: 이 티켓에 pid가 없다 - 세션 소유를 확인할 수 없다" >&2; exit 1 ;;
    esac
    ANC=$$; OWNED=""
    while [ "$ANC" != "0" ] && [ "$ANC" != "1" ] && [ -n "$ANC" ]; do
      [ "$ANC" = "$UPID" ] && { OWNED=1; break; }
      ANC=$(ps -p "$ANC" -o ppid= 2>/dev/null | tr -d ' ')
    done
    [ -n "$OWNED" ] || { echo "거부: 남의 티켓이다(pid=$UPID) - 자기 세션만 폴링에 넣을 수 있다" >&2; exit 1; }

    # 검사 5 - 스크립트를 그 자리에서 한 번 돌려 본다. 0이면 이미 조건에 도달한 것이라
    # 대기에 넣지 않고 그대로 둔다(tick 하나를 안 버린다). 그 밖(1이 아님)이면 거절한다.
    TESTOUT="$LOCAL/run/poll-test-$$.log"
    run_capped "$SCRIPTPATH" "$TESTOUT"; TESTRC=$?
    rm -f "$TESTOUT"
    if [ "$TESTRC" -eq 0 ]; then
      echo "이미 조건에 도달했다 - 대기에 넣지 않는다: $H"
      exit 0
    elif [ "$TESTRC" -ne 1 ]; then
      echo "거부: 스크립트가 오류를 냈다(rc=$TESTRC) - 대기에 넣지 않는다" >&2
      exit 1
    fi

    # 다섯 검사를 다 지났다. unassign 결정 9 종료 경로와 같은 두 줄(clear+release)로 열고
    # 그 위에 대기 키 둘을 얹는다.
    python3 "$PY" clear "$P" || exit 1
    RP=$(python3 "$PY" release "$P") || exit 1
    python3 "$PY" pollstart "$RP" "$SCRIPT" "$UNTIL" || exit 1
    log "POLL-START $H $SCRIPT until=$UNTIL"
    echo "폴링 대기: $H -> $(basename "$RP") (스크립트 $SCRIPT, 상한 $UNTIL)"
    exit 0 ;;
  preempt)
    # §1-5 갈래 C(사람이 부르는 선점, 엔진 계약 `3acc1a56`) - 순서 넷이 계약이다.
    USAGE="사용법: $(basename "$0") preempt <티켓해시> [--dryrun]"
    H="${2:-}"; [ -z "$H" ] && { echo "$USAGE" >&2; exit 2; }
    DRYRUN=""; shift 2
    for a in ${@+"$@"}; do
      [ "$a" = "--dryrun" ] && { DRYRUN=1; continue; }
      echo "$USAGE" >&2; exit 2
    done

    # 1. 피해자를 고른다(위 §피해자 판정 한 자리) - `maybe_preempt`와 달리 소유자 필터가 없다.
    if ! pick_victim ""; then
      if [ -z "$DRYRUN" ]; then
        echo "피해자 없음 - 도는 티켓이 없거나 전부 유효 5" >&2
        log "PREEMPT-NONE $H 요청 - 피해자 없음"
      fi
      exit 1
    fi
    VWORKER="${VOWNER#*/ }"; VWORKER="${VWORKER%-*}"   # owner "<페르소나> / <워커>-<SID 8글자>"

    if [ -n "$DRYRUN" ]; then
      VTITLE=$(sed -n 's/^title:[[:space:]]*//p' "$VPATH" | head -1 | tr -d "\"'")
      printf '%s - %s - %s\n' "$VHASH" "$VTITLE" "$VWORKER"
      exit 0
    fi

    # 2. 피해자 본문에 `## 선점` 절을 붙인다(§1-3 §5 §표와 같은 표, 라벨은 `밀어낸 티켓`).
    # 워커·워크트리는 **피해자를 물었던 워커**(VWORKER)다 - 부르는 워커($TICKET_NAME)가 아니다.
    # 소유자 필터가 없어서(§1-5 §갈리는 것 하나) 피해자가 남의 워커에서 돌 수 있고, 회수
    # 안내가 가리켜야 하는 것은 그 미커밋 변경이 실제로 있는 워크트리다.
    WT="$TICKET_ROOT/worktrees/$VWORKER"
    COMMIT=$(git -C "$WT" rev-parse --short HEAD 2>/dev/null)
    {
      printf '\n## 선점\n\n'
      printf '| | |\n|---|---|\n'
      printf '| 시각 | %s |\n' "$(date '+%F %T')"
      printf '| 밀어낸 티켓 | %s |\n' "$H"
      printf '| 워커 · 브랜치 | %s · wt/%s |\n' "$VWORKER" "$VWORKER"
      printf '| 워크트리 | %s |\n' "$WT"
      printf '| 커밋 | %s |\n' "$COMMIT"
      printf '| 회수 | `.dira/protocols/재디스패치-복구.md`를 읽고 그대로 하세요. |\n'
    } >> "$VPATH"
    # 3. 그 세션을 끊는다. 피해자를 물었던 워커의 부모 tick.sh가 kill을 보고 clear+release를
    # 밟는다(위 unassign --force와 같은 경로, `unassign --force`와 달리 답변 대기로 안 잠근다 -
    # askhuman을 안 부른다) - VPATH가 사라지면 열림으로 돌아온 것이다.
    log "PREEMPT $VHASH -> $H (사람 요청) pid=$VPID"
    kill -TERM "$VPID" 2>/dev/null
    N=0
    while [ -e "$VPATH" ] && [ "$N" -lt 15 ]; do sleep 1; N=$((N+1)); done

    # 4. 비워진 워커에 갈래 B의 지목 디스패치(`tick <해시>`)를 건다 - 워커 락이 풀릴 때까지
    # 기다린다. 15·20·30초는 이 파일의 다른 생존 대기(unassign·MAXRUN 감시)와 같은 자릿수다.
    VWLOCK="$LOCAL/run/$VWORKER-$(python3 -c \
      'import hashlib,sys;print(hashlib.sha1(sys.argv[1].encode()).hexdigest()[:8])' "$WORKERS/$VWORKER").lock"
    N=0
    while [ -d "$VWLOCK" ] && [ "$N" -lt 30 ]; do sleep 1; N=$((N+1)); done
    if [ -d "$VWLOCK" ]; then
      log "PREEMPT-TIMEOUT $H 워커 $VWORKER 락이 30초 안에 안 풀렸다 - 다음 cron이 받는다"
      exit 0
    fi
    VWSCRIPT="$WORKERS/$VWORKER.sh"
    if [ ! -x "$VWSCRIPT" ]; then
      log "PREEMPT-NOWORKER $H 워커 스크립트 없음: $VWSCRIPT"
      exit 0
    fi
    # 던지고 잊는다(§4-5·§1-5 갈래 B와 같은 계약 - 결과를 안 본다) - 물면 세션이 5~25분을
    # 붙드는데, 이 명령은 GUI의 `execFile`(60초 상한, engine.ts)로 불린다. fd를 다 떼야
    # execFile이 자식의 표준출력이 안 닫혀서 60초를 그대로 기다리는 사고가 안 난다.
    nohup "$VWSCRIPT" tick "$H" </dev/null >/dev/null 2>&1 &
    disown 2>/dev/null || true
    exit 0 ;;
  dryrun|tick) ;;
  *) echo "알 수 없는 명령: $CMD"; exit 2 ;;
esac

# --- 스테일 수거: 세션이 죽었는데 진행중으로 남은 티켓을 백로그로 되돌린다 ---
# 없으면 사람에게 질문하고 rc=0으로 종료한 세션의 티켓이 영구 유실된다(2026-07-28 스트림 실사고 3건).
# §폴링 대기 결정 5와 같은 이유로 아래 워커 락(SKIP)보다 앞이다 - reap은 이 워커의 바쁨과
# 무관한 큐 전체의 스테일 수거라, 원래도 워커 락 성패에 기댈 이유가 없었다.
if [ "$CMD" = "tick" ]; then
  python3 "$PY" reap "$TICKET_ROOT" "$LOCAL" 2>/dev/null | while IFS= read -r line; do
    [ -n "$line" ] && log "$line"
  done
fi

# --- 로그 보존: workers/logs·workers/health 아래 오래된 파일을 지운다 ---
# 실측(P409-2, 2026-09-15): 3,014개 3.8GB, 세션 로그 하나가 119MB까지 간다 - 그 위에서 큐
# 탐색이 느려진다. 하루 한 번만 훑는다 - 매 tick(1분 주기)마다 3,000개를 훑으면 이 손이 스스로
# 탐색 지연을 보탠다. 실패해도 디스패치를 막지 않는다(reap과 같은 이유).
if [ "$CMD" = "tick" ]; then
  LOGKEEPDAYS="${TICKET_LOG_KEEP_DAYS:-14}"
  LOGRETMARK="$LOCAL/run/log-retention-date"
  LOGRETTODAY="$(date +%F)"
  if [ "$(cat "$LOGRETMARK" 2>/dev/null)" != "$LOGRETTODAY" ]; then
    if [ "$LOGKEEPDAYS" != "0" ]; then
      for d in "$WORKERS/logs" "$WORKERS/health"; do
        [ -d "$d" ] && find "$d" -type f -mtime "+$LOGKEEPDAYS" \
          ! -name 'runner.log' ! -name 'cron.log' -delete 2>/dev/null
      done
    fi
    mkdir -p "$LOCAL/run" 2>/dev/null
    printf %s "$LOGRETTODAY" > "$LOGRETMARK" 2>/dev/null
  fi
  true
fi

# --- §폴링 대기 결정 3·5·6 — 폴링 단계: reap 다음, `select` 앞이고, 이 워커가 바빠서 아래
# 워커 락에 걸려 SKIP하는 자리보다도 앞이다 - 대기는 워커 슬롯과 무관한 큐 전체의 상태라서다.
# 새 cron 줄 0개, 새 프로세스 0개 - 이미 깨어난 이 tick에 얹는다. 대기 티켓이 0건이면 파일
# 목록 한 번 훑는 것으로 끝난다.
POLL_FLOOR="${TICKET_POLL_FLOOR:-30}"
poll_step() {
  local ROWS p_path p_hash LOCKP OWNER PLAN rest scriptpath outf rc
  ROWS=$(python3 "$PY" pollrows "$TICKET_ROOT" 2>/dev/null)
  [ -z "$ROWS" ] && return 0
  while IFS='|' read -r p_path p_hash; do
    [ -z "$p_path" ] && continue
    LOCKP="$LOCAL/run/poll-$p_hash.lock"
    if ! mkdir "$LOCKP" 2>/dev/null; then
      OWNER=$(cat "$LOCKP/pid" 2>/dev/null)
      # 못 얻으면 기다리지 않고 이 티켓을 넘긴다(결정 6) - 다음 tick이 30~60초 뒤에 온다.
      if [ -n "$OWNER" ] && kill -0 "$OWNER" 2>/dev/null; then continue; fi
      rm -rf "$LOCKP"
      mkdir "$LOCKP" 2>/dev/null || continue
    fi
    printf %s "$$" > "$LOCKP/pid"

    # 주기 판정(polled_at + 머리의 초)은 잠금을 얻은 뒤에 다시 읽는다(결정 6) - pollplan이
    # 매번 파일을 새로 읽으므로 여기서 부르는 것 자체가 그 재읽기다.
    PLAN=$(python3 "$PY" pollplan "$p_path" "$POLL_FLOOR" 2>/dev/null)
    case "$PLAN" in
      WAIT) : ;;
      "RUN "*)
        rest="${PLAN#RUN }"
        scriptpath="${rest%%|*}"
        [ "$rest" != "$scriptpath" ] && log "${rest#*|}"
        outf="$TICKET_ROOT/polls/$p_hash.log"
        run_capped "$scriptpath" "$outf.tmp"; rc=$?
        tail -n 200 "$outf.tmp" > "$outf" 2>/dev/null; rm -f "$outf.tmp"
        python3 "$PY" pollresult "$p_path" "$rc" "$outf" | while IFS= read -r line; do
          [ -n "$line" ] && log "$line"
        done
        ;;
      "ASK "*) log "$PLAN" ;;
      "POLL "*"상한 초과"*) log "$PLAN" ;;
      *) log "WARN POLL 알 수 없는 pollplan 출력: $p_hash: $PLAN" ;;
    esac
    rm -rf "$LOCKP"
  done <<EOF
$ROWS
EOF
}
[ "$CMD" = "tick" ] && poll_step

# 참견 입구(FIFO)와 최초 프롬프트 파일. 스트리밍 입력 엔진일 때만 실제 경로가 들어간다.
INBOX=""; PRIMEF=""
# 선정·claim 임계구역 잠금(§5-4). 트랩보다 먼저 선언한다 - 잠금을 잡기 전에 종료하는 경로가
# 여럿이고(선정 잠금 획득 실패 등) set -u에서 미정의 변수를 트랩이 읽으면 그 자리에서 죽는다.
SLOCK=""

# --- 워커 락: 한 워커는 한 번에 티켓 1건 ---
# 워커는 동기 프로세스다. 앞 실행이 아직 세션을 물고 있으면 이번 tick은 그냥 넘긴다
# (cron은 1분마다 깨우지만 티켓 하나는 보통 5~25분 걸린다). 동시성은 워커 개수로 조절한다.
# 락은 머신 로컬에 둔다 - 안에 든 pid는 이 머신에서만 뜻이 있다.
# 서로 다른 티켓을 든 두 워커가 같은 파일·공유 DB를 만지는 건 여전히 사람이 조절할 몫이다
# (관측 사고: 동시 4세션이 같은 dev DB에서 컬럼 드롭, 2026-07-28 스트림).
if [ "$CMD" = "tick" ]; then
  LOCK="$LOCAL/run/$TICKET_NAME-$(python3 -c \
    'import hashlib,sys;print(hashlib.sha1(sys.argv[1].encode()).hexdigest()[:8])' "$WORKERS/$TICKET_NAME").lock"
  if ! mkdir "$LOCK" 2>/dev/null; then
    OWNER=$(cat "$LOCK/pid" 2>/dev/null)
    if [ -n "$OWNER" ] && kill -0 "$OWNER" 2>/dev/null; then
      maybe_preempt
      log "SKIP 이 워커가 아직 티켓을 물고 있다 pid=$OWNER"
      exit 0
    fi
    log "WARN 스테일 락 회수 pid=${OWNER:-?}"
    rm -rf "$LOCK"
    mkdir "$LOCK" 2>/dev/null || exit 0
  fi
  printf %s "$$" > "$LOCK/pid"
  # 빈 값이면 rm -f ""가 되고 아무 일도 안 한다 -- 어떻게 죽든 FIFO가 남지 않게 여기 한 번만 건다.
  trap 'rm -rf "$LOCK" "$SLOCK"; rm -f "$INBOX" "$PRIMEF" "${PRIMEF:+$PRIMEF.fed}" "${INBOX:+$INBOX.human}"' EXIT
fi

# 엔진 쿨다운 게이트·claude 인증 게이트는 여기 없다 - 페르소나가 엔진을 정하므로 어느
# 엔진인지가 어느 후보를 고르느냐에 달렸다(§제약 1 §결정 기록 §열한 번째). 둘 다 아래 선정
# 루프 안, 후보의 persona가 확정된 뒤로 옮겼다 - reap만 이 앞에 그대로 둔다(스테일 수거는
# 엔진 가용성과 무관하다).

# --- 티켓 선정: 상태접미사 없고 session_id 비어있는 것, 유효 우선순위 높은 순(§1-3) ---
# select가 이미 `(-effective, birth, path)`로 정렬해 준다(tickets.py scan()) - 여기는
# 그 순서를 그대로 훑을 뿐이다.
CANDS=$(python3 "$PY" select "$TICKET_ROOT") || { log "ERROR select 실패"; exit 1; }

# §1-5 갈래 B — 지목 디스패치: 후보 목록을 그 해시 하나로 좁힌다(무수정 tick과 다른 점 전부).
# 후보가 아니면(이미 할당됨·폴링 대기·deps 미충족·없는 티켓) 사유 한 줄만 로그하고 나간다.
# 게이트(페르소나 상한·유효 1·엔진 쿨다운)에 걸리는 경우는 후보 목록에는 있으므로 아래 선정
# 루프가 후보 하나를 그대로 훑다가 종전 SKIP 로그를 남기고 TPATH가 빈 채로 끝난다(§검증 (2)).
if [ -n "$TARGETHASH" ]; then
  MCANDS=$(printf '%s\n' "$CANDS" | awk -F'|' -v h="$TARGETHASH" '$2==h')
  if [ -z "$MCANDS" ]; then
    log "SKIP 지목 $TARGETHASH — $(target_reason "$TARGETHASH")"
    exit 0
  fi
  CANDS="$MCANDS"
fi

[ -z "$CANDS" ] && exit 0

# --- 선정·claim 임계구역: 페르소나 상한·1 게이트는 여기 없으면 게이트가 아니다 ---
# 상한(§5-4)은 `personas/<이름>/limit` 한 줄이고 **세는 것과 잡는 것이 한 임계구역**이어야 한다.
# 지금 구조는 select가 후보를 전부 주고 각 워커가 위에서부터 claim하니 카운트가 claim보다 앞이다.
# 워커 8개는 cron 같은 분에 뜨고 같은 1초에 최대 5개가 DISPATCH된다(실측) - 상한 1의 티켓이
# 다섯 장 열려 있으면 다섯 워커가 모두 `0 < 1`을 읽고 각자 다른 티켓을 잡는다. 로그에는 아무
# 이상이 안 남아서 아무도 못 잡는다.
# 1 게이트(§1-3)도 같은 이유다 - "유효 1은 .wip 0건일 때만 후보"를 세고 나서 잡으면 게이트가
# 아니다. 그래서 같은 그릇(같은 SLOCK)을 쓴다 - 새 잠금은 0개다.
# 그릇은 위 워커 락과 같은 관용구다(mkdir + pid + kill -0 스테일 회수). 다른 점 하나 - 워커 락은
# 워커 이름별이고 이것은 **머신에 하나**다. reap은 이 앞에 그대로 둔다.
# **못 얻으면 기다리지 않고 종료한다**: 다음 cron이 60초 뒤에 오고, 죽은 워커가 물고 있어도
# 큐가 서지 않는다(스테일 회수가 그 위에 있다). 대가는 §5-4가 적은 `마지막 워커가 1초 늦게
# 뜬다`가 아니다 - 줄을 서지 않고 나가므로 **같은 순간에 깬 워커 중 한 명만 뜬다**
# (실측 3회: 워커 5개 동시 · 안 걸리는 상한 하나 -> 디스패치 1건. 상한 파일이 없으면 5건).
# 즉 상한을 한 번 쓰면 그 큐의 디스패치가 분당 1건으로 눌린다. 세션이 5~25분이라 정상 상태는
# 견디지만 냉시동이 워커 수만큼 느려진다 - 뒤집으려면 짧은 재시도가 필요하고 그건 스펙의 일이다.
#
# **상한 파일도 유효 1 후보도 없으면 잠금을 안 잡는다.** `상한 없음`이 기본값이고(스캐폴딩이
# 이 파일을 안 만든다) 그 판은 §5-4 표대로 **종전 그대로**여야 한다 - 지킬 게이트가 0개인데
# 직렬화하면 같은 분에 깬 워커 여덟 중 하나만 뜬다. 파일이 하나라도 생기거나 유효 1이 뜨면
# 그때부터 전원이 줄을 선다.
LIMITED=""
for lf in "${TICKET_PERSONAS:-$TICKET_ROOT/personas}"/*/limit; do
  [ -f "$lf" ] && { LIMITED=1; break; }
done
HASPRIO1=""
# select 출력은 이제 8필드다(끝에 squad_persona가 붙는다, §5-5) - `|1$`는 그 필드가 비어 있을
# 때만 우연히 맞는다. 7번째 필드(effective) 위치로 고정해서 본다.
grep -qE '^([^|]*\|){6}1\|' <<< "$CANDS" && HASPRIO1=1
if [ "$CMD" = "tick" ] && { [ -n "$LIMITED" ] || [ -n "$HASPRIO1" ]; }; then
  acquire_slock || exit 0
fi

# 전체 큐의 진행중 수(페르소나 무관) - 1 게이트(§1-3)가 "모든 워커가 idle"을 판정하는 값.
# 워커 락을 세지 않는 이유는 위 persona_wip과 같다(락에서 프로젝트를 역추적할 수 없다).
total_wip() {
  python3 -c 'import sys
sys.path.insert(0, sys.argv[1])
import tickets as T
print(len(T.in_progress(sys.argv[2])))' "$CODE" "$TICKET_ROOT"
}

# §1-4 §로그: DISPATCH 줄의 prio= 괄호 출처. raw(원값) != baseline(기준값)이면 duedate가
# 기준값을 덮었다는 뜻이라 `마감` - baseline != effective(유효)면 §1-3의 상속이 그 위에
# 얹혔다는 뜻이라 `상속 <baseline>`(보여주는 값은 상속이 얹히기 전 값, 종전 표기와 같은 자리).
# 둘 다면 이어붙인다. 새 게이트가 아니다 - 이미 있는 세 수를 비교만 한다.
prio_log() {
  local raw="$1" base="$2" eff="$3"
  local out="prio=$eff"
  if [ "$raw" != "$base" ] && [ "$base" != "$eff" ]; then
    out="prio=$eff(마감·상속 $base)"
  elif [ "$raw" != "$base" ]; then
    out="prio=$eff(마감)"
  elif [ "$base" != "$eff" ]; then
    out="prio=$eff(상속 $base)"
  fi
  printf '%s' "$out"
}

# §4-12 §개정 2026-08-11 — 술어 둘. unassign(위 249-270)의 관용구를 그대로 쓴다(새 도구 0).
# 조상 사슬은 안 가져온다 - 부모는 자기 $SID를 알아서 「내 것」을 한 번에 가른다.
sid_of() { sed -n 's/^session_id:[[:space:]]*//p' "$1" | head -1 | tr -d "\"' "; }
owns()   { [ -f "$1" ] && [ "$(sid_of "$1")" = "$SID" ]; }         # ③이 쓴다
live_other() {                     # 파일이 있고 · 내 것이 아니고 · 그 주인이 살아 있다
  local OSID OPID PSOUT
  [ -f "$1" ] || return 1
  OSID=$(sid_of "$1"); [ "$OSID" = "$SID" ] && return 1
  OPID=$(sed -n 's/^pid:[[:space:]]*//p' "$1" | head -1 | tr -d "\"' ")
  case "$OPID" in ''|*[!0-9]*) ;; *) ps -p "$OPID" -o pid= >/dev/null 2>&1 && return 0 ;; esac
  [ -n "$OSID" ] || return 1
  PSOUT=$(ps -eo command= 2>/dev/null)   # 파이프 금지 — grep이 자기 명령줄을 문다(tick.sh:253)
  case "$PSOUT" in *"--session-id $OSID"*) return 0 ;; esac
  return 1
}

# 조용한 실패 회수 자리 넷(§4-10 §개정) 공용 헬퍼 - `clear`+`release` 두 줄을 `tickets.py`의
# `reapclear`(엔진 `reap_release`) 한 번으로 묶는다. release를 clear보다 먼저 돌려 reclaim과
# 순서를 맞추고(5f0498c9), 실패하면 REAP-FAIL 한 줄을 표준출력으로 돌려준다(빈 값 = 성공).
# 호출자가 그 줄을 그대로 log에 남긴다. 2번째 인자(사유)는 §4-13의 메인 FAIL 경로만 준다
# (P362-2) - 나머지 셋(assign 실패·cwd 없음·이어받기 기동 실패)은 생략해 종전대로 attempts를
# 안 건드린다.
reap_silent() { python3 "$PY" reapclear "$1" "${2:-}"; }

# 엔진 수정 마흔 번째 승인 §판정 2 - 디스패치 직전에 워크트리 3항(주인이 .wip/미배정 ->
# 버린다)만 대신 집행한다. 4항(보존)-5항(후속 티켓)은 판단이 들어가 세션의 몫으로 남긴다.
# 순서 계약: 이 함수는 DISPATCH 로그 직후, cd "$TICKET_CWD" 전에 돈다(판정 1의 dirty-<해시>
# 기록보다 먼저 -> AC13). 실패해도 디스패치를 막지 않는다(AC12) - NOTE만 남기고 넘어간다.
cleanup_stray_wip() {
  local wt="$1" tdir="$TICKET_ROOT/tickets" line status path owner_hash owner_file hit_count f
  git -C "$wt" status --porcelain 2>/dev/null | while IFS= read -r line; do
    status="${line:0:2}"
    path="${line:3}"
    # 이름바꾸기(R  old -> new)는 새 이름만 본다 - 옛 이름은 이미 트리에 없다
    case "$path" in *' -> '*) path="${path##*' -> '}" ;; esac
    [ -z "$path" ] && continue
    hit_count=0; owner_file=""
    for f in "$tdir"/*.md; do
      [ -e "$f" ] || continue
      if grep -qF -- "$path" "$f" 2>/dev/null; then
        hit_count=$((hit_count + 1))
        owner_file="$f"
      fi
    done
    [ "$hit_count" -eq 1 ] || continue
    case "$owner_file" in
      *.done.md) continue ;;   # 4항 - 보존, 세션의 몫
      *.wip.md|*.md) ;;        # 3항 - 버린다 (미배정 <해시>.md도 이 갈래)
      *) continue ;;
    esac
    owner_hash="$(basename "$owner_file")"; owner_hash="${owner_hash%%.*}"
    case "$status" in
      '??') rm -f -- "$wt/$path" 2>/dev/null && log "NOTE cleanup_stray_wip 버림(미추적) path=$path owner=$owner_hash" ;;
      *) git -C "$wt" restore --staged --worktree -- "$path" 2>/dev/null \
           && log "NOTE cleanup_stray_wip 버림 path=$path owner=$owner_hash" \
           || log "NOTE cleanup_stray_wip 실패 path=$path owner=$owner_hash" ;;
    esac
  done
  return 0
}

SID=$(python3 -c 'import uuid;print(uuid.uuid4())')
TPATH=""; THASH=""; TKIND=""; TPERSONA=""; TPRIO=""; TBASE=""; TEFF=""; TSQUAD=""
OVER=""    # 이 판에서 이미 상한이던 페르소나들. 후보가 여럿이어도 SKIP은 페르소나당 한 줄이다
ENGOVER="" # 이 판에서 이미 디스패치 불가이던 엔진들. 후보가 여럿이어도 SKIP은 엔진당 한 줄이다
while IFS='|' read -r c_path c_hash c_kind c_persona c_prio c_base c_eff c_squadp; do
  [ -z "$c_path" ] && continue
  # `squad:`가 풀렸으면 리더가 이 후보의 수행자다 - 아래 상한 게이트-엔진 선택-claim이
  # 전부 c_persona를 보므로 여기서 한 번만 덮으면 나머지는 종전 코드 그대로다(§5-5 §개정).
  [ -n "$c_squadp" ] && c_persona="$c_squadp"

  # 1 게이트(§1-3) — 유효 1은 진행중 티켓이 0건일 때만 후보다. "모든 워커가 idle"의 큐 쪽
  # 값이 그것이다. 걸려도 큐에서 안 빠진다 - 이번 tick의 후보가 아닐 뿐이고 다음 후보로
  # 넘어간다(페르소나 상한의 continue와 같은 모양 - 다른 우선순위 티켓을 안 굶긴다).
  if [ "$c_eff" = "1" ]; then
    WIPN=$(total_wip)
    if [ "$WIPN" -gt 0 ]; then
      log "SKIP 우선순위 1 $c_hash — 진행중 ${WIPN}건"
      continue
    fi
  fi

  # 상한에 걸려 안 뜨는 것은 SKIP이다(새 로그 낱말 0). 다른 페르소나 후보는 계속 본다 -
  # 한 페르소나가 상한이어도 나머지를 굶기지 않는 것이 이 요구의 절반이다.
  if [ -n "$c_persona" ]; then
    case " $OVER " in *" $c_persona "*) continue ;; esac
    PLIM=$(persona_limit "$c_persona")
    if [ -n "$PLIM" ]; then
      PWIP=$(persona_wip "$c_persona")
      if [ "$PWIP" -ge "$PLIM" ]; then
        OVER="$OVER $c_persona"
        log "SKIP 페르소나 상한 $c_persona $PWIP/$PLIM"
        continue
      fi
    fi
  fi

  # --- 엔진 재구성: 확정된 후보의 persona:가 personas/<이름>/engine을 가지면 그 값으로,
  # 없으면 종전 그대로(워커 대입 -> 기본값)다(§제약 1 §결정 기록 §열한 번째). 매 후보마다
  # 기본값으로 되돌린 뒤 다시 얹는다 - 안 그러면 앞 후보의 override가 다음 후보로 샌다.
  TICKET_ENGINE=("${BASE_ENGINE[@]}")
  if [ -n "$c_persona" ]; then
    PENGINE="${TICKET_PERSONAS:-$TICKET_ROOT/personas}/$c_persona/engine"
    [ -r "$PENGINE" ] && . "$PENGINE"
  fi
  # §27 계약 3: 접미사에서 이름을 딴다 - dira -> claude(§24 계약 4 그대로), dira-<x> -> <x>.
  # 판정은 여기 한 자리뿐이다 - 아래 스킬 주입 조건도 다시 basename을 부르지 않고 이 값을 읽는다.
  ENGBN="$(basename "${TICKET_ENGINE[0]}")"
  case "$ENGBN" in
    dira) ENGSUF="claude" ;;
    dira-*) ENGSUF="${ENGBN#dira-}" ;;
    *) ENGSUF="" ;;
  esac
  # 엔진 수정 24번째 계약 5 + §27 계약 3 폴백: 고정 경로를 못 만들었거나(권한-볼륨-원본 없음)
  # 그 경로가 실행 가능하지 않으면 종전대로 PATH의 이름으로 돌아간다 - 디스패치를 막지 않는다.
  if [ -n "$ENGSUF" ] && [ ! -x "${TICKET_ENGINE[0]}" ]; then
    TICKET_ENGINE[0]="$ENGSUF"
  fi
  ENGINE_NAME="${ENGSUF:-$ENGBN}"
  CDOWN="$LOCAL/run/cooldown-$ENGINE_NAME${TICKET_SLOT:+-$TICKET_SLOT}"

  # 어느 엔진인지가 후보에 달렸으므로 ENGINE_NAME·claude 인증·쿨다운도 후보 확정 뒤에 판정한다
  # (dryrun은 미리보기라 건너뛴다 - 종전에도 이 게이트는 CMD=tick 전용이었다). 디스패치 불가면
  # 페르소나 상한과 같은 자리에서 skip-and-continue다(같은 로그 낱말 SKIP) - 이 엔진을 못
  # 쓴다고 다른 엔진 쓰는 후보까지 굶기지 않는다. 건너뛸 후보가 없으면 이번 tick은 그냥
  # 아무것도 안 고르고 끝난다(TPATH가 빈 채로 루프가 끝난다).
  if [ "$CMD" = "tick" ]; then
    case " $ENGOVER " in *" $ENGINE_NAME "*) continue ;; esac
    if ! engine_gate_ok; then
      ENGOVER="$ENGOVER $ENGINE_NAME"
      continue
    fi
  fi

  if [ "$CMD" = "dryrun" ]; then
    TPATH="$c_path"; THASH="$c_hash"; TKIND="$c_kind"; TPERSONA="$c_persona"; TPRIO="$c_prio"; TBASE="$c_base"; TEFF="$c_eff"; break
  fi
  # 잡기 = 원자적 rename. 이게 진짜 락 - 다른 세션·다른 tick도 이걸 보고 피한다.
  if CPATH=$(python3 "$PY" claim "$c_path" 2>/dev/null); then
    TPATH="$CPATH"; THASH="$c_hash"; TKIND="$c_kind"; TPERSONA="$c_persona"; TPRIO="$c_prio"; TBASE="$c_base"; TEFF="$c_eff"; TSQUAD="$c_squadp"
    # 스쿼드 리더 이름을 SLOCK 반환 전에 persona:로 남긴다 - 여기서 늦추면 persona_wip()이
    # 이 임계구역이 지키려는 상한(§27 setpersona 위치 개정)을 뒤늦게 세어 다음 워커가 통과한다.
    [ -n "$TSQUAD" ] && python3 "$PY" setpersona "$TPATH" "$TSQUAD"
    break
  fi
done <<EOF
$CANDS
EOF
# 임계구역 끝. 세션을 띄우기 **전에** 놓는다 - 잡은 뒤로는 상한 판정에 영향이 없고, 여기서 안
# 놓으면 워커 하나가 최대 MAXRUN(5,400초) 동안 나머지 전부의 선정을 막는다.
# 비워야 트랩이 다음 주인의 잠금을 지우지 않는다.
[ -n "$SLOCK" ] && { rm -rf "$SLOCK"; SLOCK=""; }
[ -z "$TPATH" ] && exit 0

# 재무장: 쿨다운이 만료돼서 여기까지 왔으면 나가면서 창을 다시 감는다. 그래야 한 창의 재시도가
# 이 워커 하나로 고정된다(안 감으면 8워커가 같은 창에서 한꺼번에 나가 헛디스패치가 8회 또 돈다).
# **파일이 있을 때만 쓴다** - 정상 상태에서 쓰면 워커 하나가 나갈 때마다 나머지가 막혀 큐가 직렬화된다.
# 여기 창은 복귀 시각이 아니라 짧은 300초다 - 다음 FAIL(실측 13초)까지만 나머지를 막으면 된다.
if [ "$CMD" = "tick" ] && [ -f "$CDOWN" ]; then
  arm_cdown "$(( $(date +%s) + CDOWN_W ))"
fi

PROMPT=$(printf "$TICKET_PROMPT_FMT" "$THASH")

# --- 참조 컨텍스트: 워커의 TICKET_CONTEXT=("<경로>|<설명>" ...)를 프롬프트 꼬리에 붙인다 ---
# 없는 경로는 건너뛴다(클라우드 마운트가 안 붙은 상태에서 세션이 헛짚지 않게).
# ${arr[@]+"..."}는 set -u에서 미정의 배열을 안전하게 전개하는 관용구(bash 3.2 포함).
CTX=""
for entry in ${TICKET_CONTEXT[@]+"${TICKET_CONTEXT[@]}"}; do
  CPATH_="${entry%%|*}"; CDESC="${entry#*|}"
  [ "$CDESC" = "$entry" ] && CDESC=""          # `|` 없이 경로만 준 경우
  [ -e "$CPATH_" ] || { log "WARN 컨텍스트 경로 없음: $CPATH_"; continue; }
  CTX="$CTX
- $CPATH_${CDESC:+ — $CDESC}"
done
[ -n "$CTX" ] && PROMPT="$PROMPT

참조 컨텍스트(필요하면 읽어보세요):$CTX"

# --- 언어 주입: $LOCAL/language.json의 locale이 무엇이든 프롬프트 맨 꼬리에 문장 두 짝
# (§0-16 §주입 §개정) -- ko면 한국어 문장, en이면 영어 문장. 무주입은 없다(안 고른 사람이
# 정확히 그 기본값이라 회귀가 그 사람에게 난다). 흡수 판정은 그대로다 -- 파일 없음·JSON
# 깨짐·객체 아님·모르는 값 넷 다 ko로 흡수한다(GUI의 readLanguage와 같은 판정,
# apps/teams/lib/projects.ts). 자리는 참조 컨텍스트 바로 뒤다 -- 조립이 prepend라 아래로
# 내려갈수록 프롬프트 앞쪽에 붙고, 여기가 append로 남는 마지막 자리다. persona if 밖이라
# `persona:` 없는 티켓에도 붙는다. 블록은 상수 -- 로케일이 늘면 case에 문장 한 줄만 는다.
# 문장 ①은 "사용자에게 하는 모든 말"로 긍정 좁힘이라 thinking·도구명·요약은 예외로 나열하지
# 않아도 애초에 안 걸린다 -- 였는데, 세션이 꼬리의 한국어/영어 문장을 보고 사고까지 그 언어로
# 돌리는 게 실전에서 관측됐다(§0-16 §주입 §개정 2, 요구 ef37b15e). 그래서 문장 ①에 예외 절을
# 하나 더한다 -- 생각·내부 추론은 이 지시의 대상이 아니라는 자유 허가(금지 아님). 이유는 안
# 적는다 -- 이유를 적으면 세션이 그 이유를 산출물·검증까지 넓혀 읽는다.
# 문장 ②(산출물 언어)는 §0-16 §주입 §개정 5(요구 d8407b1a)로 로케일을 따른다 -- en이면 산출물도
# 영어다. ko 경로는 바이트 단위로 안 갈린다. en 문장에는 절 이름(`## Goal`-`## Done when`-
# `## 진행 계획`-`## 결과`-`## 블록`-`## 질문 n`)이 로케일과 무관한 리터럴이라는 절이 붙는다 --
# 안 붙으면 영어 세션이 `## Result`라고 적어 자동 상신·계획 아코디언·답변 대기가 조용히 안 뜬다
# (tickets.py:782,876,933 - lib/queue.ts:775). 아래 FLUENTKO 블록을 가리키던 recency 줄도
# en에서는 그 블록 자체가 안 실려서 함께 뺀다.
LOCALE=$(python3 -c 'import json, sys
try:
    o = json.load(open(sys.argv[1], encoding="utf-8"))
    print("en" if isinstance(o, dict) and o.get("locale") == "en" else "ko")
except Exception:
    print("ko")' "$LOCAL/language.json" 2>/dev/null)
case "$LOCALE" in
en)
  PROMPT="$PROMPT

Language note: say everything you say to the user in English for the rest of
this session -- not only replies when someone writes in, but also any prose
you leave in the progress stream even when no one does. Thinking or internal
reasoning is not covered by this instruction -- you may think in any language.
Keep every written deliverable in English -- the ticket body, \`## 결과\`,
commit messages, and anything under \`docs/\`. Section names stay literal
regardless of language -- \`## Goal\`, \`## Done when\`, \`## 진행 계획\`,
\`## 결과\`, \`## 블록\`, and \`## 질문 n\` are written exactly as shown; only
the prose inside those sections changes language."
  ;;
*)
  PROMPT="$PROMPT

언어 안내: 이번 세션 동안 사용자에게 하는 모든 말을 한국어로 하세요 -- 참견에
답할 때만이 아니라 아무도 말을 안 걸어도 진행 기록 스트림에 남기는 산문까지입니다.
생각하거나 내부적으로 추론하는 구간은 이 지시의 대상이 아닙니다 -- 어느 언어로
생각해도 됩니다. 산출물은 그대로 한국어로 고정합니다 -- 티켓 본문, \`## 결과\`,
커밋 메시지, \`docs/\` 아래 전부입니다. 그 한국어를 쓰는 방법은 프롬프트 앞쪽의
<한국어 문장 지침> 블록에 있습니다 -- 한국어 문장을 낼 때마다 그 지침을 따르세요."
  ;;
esac

# --- 주도성 주입: $LOCAL/autonomy.json의 level이 무엇이든 언어 안내 바로 뒤에 그 수준
# 문장이 실린다(§주도성 결정 1-3, 요구 862c7d6e, 답 e68990f2). 흡수 판정은 파일 없음·JSON
# 깨짐·객체 아님·정수 아님·1~5 밖 다섯 경우 전부 4로 읽는다(GUI readAutonomy와 같은 판정,
# 언어의 readLanguage와 같은 틀). 무주입은 없다. 자리는 언어 case 바로 뒤, TAIL을 떼기
# 전이라 persona if 밖이고 persona 없는 티켓에도 붙는다. 블록은 상수 -- 수준이 늘면 case에
# 문장 한 짝만 는다. 우선순위는 CORE.md 머리에 한 줄로 박혀 있다(더 안 늘린다).
LEVEL=$(python3 -c 'import json, sys
try:
    o = json.load(open(sys.argv[1], encoding="utf-8"))
    v = o.get("level") if isinstance(o, dict) else None
    print(v if isinstance(v, int) and not isinstance(v, bool) and 1 <= v <= 5 else 4)
except Exception:
    print(4)' "$LOCAL/autonomy.json" 2>/dev/null)
case "$LEVEL" in
  1|2|3|4|5) ;;
  *) LEVEL=4 ;;
esac
case "$LEVEL" in
1)
  ROW_KO="사람에게 묻는 것: \`## Done when\`과 스펙에 적히지 않은 선택 전부 -- 이름·파일
위치·구현 방식·문구까지 묻습니다. 스스로 정하는 것: 없습니다 -- 선택지가 하나뿐인 일만
진행하세요."
  ROW_EN="What you ask: every choice not written in \`## Done when\` or the spec --
names, file locations, implementation approach, even wording. What you decide
alone: nothing -- proceed only when exactly one option exists."
  ;;
2)
  ROW_KO="사람에게 묻는 것: 스펙·화면·동작·파일 계약에 드러나는 선택과, 대안이 둘 이상인
설계 선택입니다. 스스로 정하는 것: 밖에서 안 보이는 구현 세부입니다."
  ROW_EN="What you ask: choices visible in the spec, screens, behavior, or file
contracts, and design choices with two or more alternatives. What you decide
alone: implementation details invisible from outside."
  ;;
3)
  ROW_KO="사람에게 묻는 것: 지금 규약 그대로입니다 -- 모호한 요구, Human calls 넷, 엔진
수정 승인. 스스로 정하는 것: 지금 규약이 세션에 맡긴 것입니다."
  ROW_EN="What you ask: exactly today's protocol -- ambiguous requests, the four
Human calls, engine-edit approval. What you decide alone: whatever today's
protocol already leaves to the session."
  ;;
4)
  ROW_KO="사람에게 묻는 것: Human calls 넷과 엔진 수정 승인뿐입니다 -- 금지 명령과 큐
불변도 그대로 지킵니다. 스스로 정하는 것: 모호한 요구와 설계 선택입니다 -- 목표에 가장
가까운 쪽을 골라 진행하고, 고른 것과 이유를 \`## 결과\`에 한 줄씩 남기세요."
  ROW_EN="What you ask: only the four Human calls and engine-edit approval --
forbidden commands and queue invariants still hold. What you decide alone:
ambiguous requests and design choices -- pick whichever is closest to the
goal, and record each pick and why in \`## 결과\`, one line at a time."
  ;;
5)
  ROW_KO="묻지 않습니다 -- 예외 한 가지만 남습니다: 비밀번호·로그인·결제 수단·2단계 인증
코드처럼 사람만 가진 것이 없어 진행이 불가능하면 그때는 \`## 블록\`을 쓰세요. 스펙 모순,
읽기 전용 영역, 새 외부 의존성, push 실패 처리, 엔진 수정, 금지 명령, 큐 불변까지 목표에
가장 가까운 방향으로 스스로 정하고, 규약을 넘은 판단은 각 줄을 \`주도성 5 판단:\`으로 시작해
답변이나 \`## 결과\` 끝, 정보 문자열 \`autonomy\`인 펜스 한 벌에 모으세요."
  ROW_EN="You do not ask -- one exception remains: if progress is impossible
without something only the human holds (password, login, payment method, 2FA
code), write \`## 블록\` even at level 5. Otherwise decide alone, picking
whichever is closest to the goal, even across spec contradictions, read-only
areas, new external dependencies, push-failure handling, engine edits,
forbidden commands, and queue invariants -- record any judgment that crosses
protocol as a line starting with \`주도성 5 판단:\`, gathered into one fence
with info string \`autonomy\` at the end of the reply or \`## 결과\`."
  ;;
esac
case "$LOCALE" in
en)
  PROMPT="$PROMPT

Autonomy note: $LEVEL/5. $ROW_EN"
  ;;
*)
  PROMPT="$PROMPT

주도성 안내: $LEVEL/5. $ROW_KO"
  ;;
esac

# --- 캐시 갈래(P295-10): 여기부터는 안 변하는 문서 층이다. 꼬리(위에서 쌓은 티켓 해시 문장 -
# 참조 컨텍스트 - 언어 안내)를 TAIL로 떼어 두고 PROMPT를 비운다 - 아래 프로토콜-온톨로지-페르소나-
# CORE 4개 블록이 이 빈 PROMPT 앞에 종전과 같은 순서로 쌓여 문서 층만 남긴다. 스트리밍 프라임
# JSON은 이 문서 층(PROMPT)과 TAIL을 블록 둘로 나눠 쓰고, argv/dryrun은 아래에서 다시 합친
# "$PROMPT$TAIL"을 쓰므로 최종 문자열은 한 글자도 안 갈린다.
TAIL="$PROMPT"
PROMPT=""

# --- 협업 프로토콜: <protocols>/AGENTS.md 를 프롬프트에 인라인한다 ---
# 페르소나가 '누구'라면 이건 '어떻게 같이 일하는가'다 - 티켓 성격별 처리, 핸드오프, 보고 규약.
# 모든 세션이 같은 문서를 받는다(페르소나와 달리 티켓이 고르지 않는다). 없으면 그냥 넘어간다.
# AGENTS.md 안에서 같은 디렉터리의 다른 문서를 가리키면 세션이 필요할 때 직접 읽는다.
PROTOCOL="${TICKET_PROTOCOLS:-$TICKET_ROOT/protocols}/AGENTS.md"
if [ -r "$PROTOCOL" ]; then
  PROMPT="아래는 이 프로젝트의 협업 프로토콜입니다. 티켓 수행·핸드오프·보고는 이 규약을 따르세요.

===== AGENTS.md ($(wtpath "$PROTOCOL")) =====
$(cat "$PROTOCOL")
===== 프로토콜 끝 =====

$PROMPT"
fi

# --- 온톨로지 블록: 위치 + 검색 방법만 싣는다(나열 없음, 9d7ba932) ---
# 메모리는 페르소나의 것이고 온톨로지는 큐 전체의 것이라 블록을 가른다 - 그래서 페르소나 if 밖이고
# `persona:`가 없는 티켓에도 실린다. 목차 나열(파일명+`## ` 절)을 걷었다 - 블록이 상수라 파일 수·
# 절 수와 무관하게 크기가 고정된다. _ontology/SCHEMA.md가 타입 지도(객체·관계·액션)라 그게
# 진입점이고, 나머지 개념에 닿는 길은 세션의 grep이다. 없거나 비면 안 붙고 WARN도 없다(없는 것이
# 정상이다).
# TICKET_ONTOLOGY가 값을 들고 있으면(워커가 재정의한 자리) find를 안 건다 - 존재 판정은
# 쓰는 쪽(GUI, 결정 2 §받는 자리의 경계)이 이미 했다. 매 디스패치 재검사는 재정의한 자리가
# 남의 앱 데이터 도메인(예: Google Drive 파일 프로바이더)일 때 티켓마다 macOS 권한 창을 새로
# 띄운다(51c730de). 미설정(기본값 <큐 루트>/ontology)은 종전 그대로 find로 존재를 잰다.
ONTDIR="${TICKET_ONTOLOGY:-$TICKET_ROOT/ontology}"
if [ -n "$TICKET_ONTOLOGY" ] || [ -n "$(find "$ONTDIR" -type f -name '*.md' 2>/dev/null)" ]; then
  ONTDIR_DISP="$(wtpath "$ONTDIR")"
  PROMPT="아래는 이 큐의 온톨로지가 있는 곳입니다.

===== 온톨로지 ($ONTDIR_DISP) =====
$ONTDIR_DISP 안의 _ontology/SCHEMA.md가 지도입니다(객체·관계·액션 타입의 진입점). 본문은 안 실립니다 -
필요한 개념은 티켓의 어휘로 $ONTDIR_DISP 를 grep해서 여세요.
===== 온톨로지 끝 =====

$PROMPT"
fi

# --- 페르소나: 티켓 frontmatter `persona:` -> <personas>/<이름>/PROFILE.md ---
# 프로필 본문을 프롬프트 머리에 인라인한다(경로만 주면 세션이 안 읽고 시작할 수 있다).
# persona가 비어 있으면 페르소나 없는 평범한 에이전트가 그냥 처리한다(정상 경로, 경고 없음).
# 이름은 있는데 프로필 파일이 없으면 WARN만 남기고 돈다 - 수행 자체는 성립한다.
PROFILE="${TICKET_PERSONAS:-$TICKET_ROOT/personas}/$TPERSONA/PROFILE.md"
if [ -z "$TPERSONA" ]; then
  :
elif [ -r "$PROFILE" ]; then
  # 스킬 사이드카(같은 디렉터리 skills.md)는 프로필 바로 뒤에 붙는다. 없는 것이 정상이라 WARN 없다.
  # Claude 엔진일 때만이다 - codex엔 스킬 개념이 없어서 "없는 도구를 쓰라"는 문장이 된다.
  SKILLS="${TICKET_PERSONAS:-$TICKET_ROOT/personas}/$TPERSONA/skills.md"
  SKILLBLOCK=""
  if [ -r "$SKILLS" ] && [ "$ENGINE_NAME" = "claude" ]; then
    SKILLBLOCK="
===== $TPERSONA 스킬 ($(wtpath "$SKILLS")) =====
$(cat "$SKILLS")
===== 스킬 끝 =====
"
  fi
  # 메모리 사이드카(같은 디렉터리 memory/*.md)는 스킬 블록 뒤에 붙는다. 여기는 엔진을 안 가린다 -
  # 메모리는 이 큐에서 알아낸 사실이라 codex에도 참이다. 없는 것이 정상이라 WARN 없다.
  # 글롭은 한 단계다(memory/<하위>/x.md는 안 읽는다). 목차 나열(파일명+`## ` 절)을 걷었다(9d7ba932) -
  # 블록이 상수라 파일 수·절 수와 무관하게 크기가 고정된다. 본문·목차에 닿는 길은 세션의
  # grep이다(엔진이 만드는 색인은 0). 되돌리려면 이 if를 종전 for 루프로 바꾼다.
  MEMDIR="${TICKET_PERSONAS:-$TICKET_ROOT/personas}/$TPERSONA/memory"
  MEMBLOCK=""
  if [ -n "$(find "$MEMDIR" -maxdepth 1 -type f -name '*.md' 2>/dev/null)" ]; then
    MEMDIR_DISP="$(wtpath "$MEMDIR")"
    MEMBLOCK="
===== $TPERSONA 메모리 ($MEMDIR_DISP) =====
이 큐에서 알아낸 교훈이 파일별로 쌓인 곳입니다(CORE.md §회고가 쓰는 자리). 본문은 안 실립니다 -
필요한 개념은 티켓의 어휘로 $MEMDIR_DISP 를 grep해서 그 파일을 여세요. [[링크]]는
grep -rl '\[\[<이름>\]\]' $MEMDIR_DISP 로 1홉 따라갑니다.
===== 메모리 끝 =====
"
  fi
  PROMPT="당신은 이 프로젝트의 '$TPERSONA'입니다. 아래 프로필이 당신의 역할·권한·판단 기준이고,
티켓을 수행하는 동안 이 페르소나로 일관되게 행동하세요. 프로필과 티켓 지시가 충돌하면 티켓을 따르되
충돌 사실을 티켓 본문에 남기세요.

===== $TPERSONA PROFILE ($(wtpath "$PROFILE")) =====
$(cat "$PROFILE")
===== PROFILE 끝 =====
$SKILLBLOCK$MEMBLOCK
$PROMPT"
else
  log "WARN 페르소나 프로필 없음: $PROFILE (페르소나 없이 디스패치)"
fi

# --- 스쿼드 블록: TPERSONA가 속한 스쿼드 전부(§5-5 §개정 §스쿼드 블록 - §블록의 틀) ---
# 상시 성질이다 - 이 티켓이 squad:를 들었는지와 무관하게, TPERSONA가 어느 squads/*/members에
# 있으면 실린다. claim 임계구역 밖이다(위 선정 루프는 이미 끝났다). 새 환경변수 0
# (TICKET_SQUADS를 안 만든다 - §5-5 §값) - 자리는 언제나 $TICKET_ROOT/squads다. 멤버 이름을
# 엔진이 검증하지 않는다(고발은 화면의 몫) - 여기서 하는 것은 프롬프트에 실을 문장 조립뿐이다.
# 1,500B 상한의 집행 자리는 화면이다(§5-5 §스쿼드 블록 §상한) - 여기서는 안 잰다.
# 틀은 §블록의 틀이 값으로 고정했다 - 엔진과 화면이 같은 바이트를 세는 유일한 접점이라 글자
# 하나도 안 지어낸다: 머리 `===== 스쿼드 <이름> =====`, 멤버 줄마다 `<이름>[ (리더)] - <역할>`,
# 꼬리는 이름 없이 `===== 스쿼드 끝 =====` 그대로다. rules는 이 블록 밖의 별도 사이드카 틀이다.
SQUADBLOCK=""
RULESBLOCK=""
if [ -n "$TPERSONA" ] && [ -d "$TICKET_ROOT/squads" ]; then
  while IFS= read -r sqdir; do
    [ -n "$sqdir" ] || continue
    sqname="$(basename "$sqdir")"
    mfile="$sqdir/members"
    [ -f "$mfile" ] || continue
    ROWS=""; LEADER=""; FOUND=""; FIRST=1
    # 한 줄에 `<이름>` 또는 `<이름> <역할>` - 첫 공백에서 한 번만 가른다(§5-5 §값, split(None,1)과 같다).
    # `read`가 그대로 그 문법이다: 변수 둘로 받으면 나머지 전부가 둘째 변수로 몰린다.
    while IFS= read -r rawline || [ -n "$rawline" ]; do
      name=""; role=""
      read -r name role <<< "$rawline"
      [ -n "$name" ] || continue
      if [ -z "$role" ]; then
        pfile="${TICKET_PERSONAS:-$TICKET_ROOT/personas}/$name/PROFILE.md"
        [ -r "$pfile" ] && role="$(head -1 "$pfile")"
      fi
      TAG=""
      if [ "$FIRST" = 1 ]; then LEADER="$name"; TAG=" (리더)"; fi
      FIRST=0
      [ "$name" = "$TPERSONA" ] && FOUND=1
      ROWS="$ROWS
$name$TAG - $role"
    done < "$mfile"
    [ -n "$FOUND" ] || continue
    SQUADBLOCK="$SQUADBLOCK
===== 스쿼드 $sqname =====$ROWS
===== 스쿼드 끝 =====
"
    if [ "$LEADER" = "$TPERSONA" ] && [ -r "$sqdir/rules" ]; then
      RULESBLOCK="$RULESBLOCK
===== 스쿼드 $sqname 규칙 ($(wtpath "$sqdir/rules")) =====
$(cat "$sqdir/rules")
===== 규칙 끝 =====
"
    fi
  done < <(find "$TICKET_ROOT/squads" -mindepth 1 -maxdepth 1 -type d 2>/dev/null | sort)
fi
[ -n "$RULESBLOCK" ] && PROMPT="$RULESBLOCK
$PROMPT"
[ -n "$SQUADBLOCK" ] && PROMPT="$SQUADBLOCK
$PROMPT"

# --- 한국어 문장 지침: 세션이 쓰는 한국어의 품질 규약을 인라인한다 ---
# 언어 안내(§0-16 §주입)가 *어느 언어로* 말할지 정하고, 이 블록이 *그 한국어를 어떻게 쓸지*
# 정한다. 세 짝이 아니라 별개 층이다 - §0-16 §주입 §개정 5(요구 d8407b1a) 전에는 로케일을 안
# 가리고 상시 실렸으나, 그 개정이 산출물 언어를 로케일에 넘기면서 `en`에는 적용 대상이 없는
# 지시가 됐다 - `ko`일 때만 싣는다.
# 자리는 꼬리가 아니라 문서 층이다 - 매 디스패치 한 글자도 안 변하는 6KB 상수라서, 꼬리에
# 두면 캐시 밖에서 회차마다 새로 쓰인다(§엔진 수정 스물다섯 번째 승인). recency는 꼬리의
# 언어 안내가 이 블록을 한 줄로 가리켜 대신 든다(`ko`에서만 - `en` 꼬리는 그 줄도 뺀다).
# 파일이 아니라 인라인 상수다 - 큐 vendored 사본을 만들면 사람이 지울 수 있고 dmg 배포에서
# 조용히 0바이트가 된다(CORE.md와 달리 폴백할 사본이 없다). 엔진에 박으면 못 지운다.
# 본문은 fluent-korean(MIT, (c) 2026 snflkd - github.com/snflkd/fluent-korean) 원문 그대로다 -
# 요약하면 조항마다 붙은 예시가 사라져 무슨 동작을 의도한 조항인지 안 전해진다(원문 §상황과 목표).
# 갱신은 원문 갱신 때 이 블록을 통째로 갈아 끼우는 것이다(부분 손질 금지 - 같은 이유다).
if [ "$LOCALE" != "en" ]; then
PROMPT="$(cat <<'FLUENTKO'
===== 한국어 문장 지침 (fluent-korean, MIT (c) 2026 snflkd) =====
당신은 한국어를 활용해야 하는 상황에 있다면 본 문서에 제시된 지침들을 준수해야 합니다. 그럼으로써 의사소통의 효율성을 높일 수 있습니다. 이 지침들은, 의미가 명확하며 비교적 가독성이 높고 안정적인 구조를 지닌 한국어 문장을 출력하는 방법을 자세히 설명합니다. 인용, 코드, 코드 주석에는 이 지침들을 적용하지 않습니다.


## 상황과 목표

- LLM은 한국어를 구사할 때 몇 가지 특징을 보이는데, 일부 특징은 결과물의 완성도를 낮추거나, 사용자가 소통에 더 많은 노력을 들이게 만듭니다. 이 문서에 작성된 사항들을 준수하면 이런 현상을 개선할 수 있습니다.

- 이 문서에서 제시하는 지침들을 요약하는 것은 일반적으로 권장되지 않습니다. 그렇게 한다면 조항마다 첨부된 예시를 확인할 수 없으므로 조항의 문구가 구체적으로 어떤 동작을 의도했는지 파악하기 어렵습니다. 또한 요약에 포함된 몇 가지 지침을 제외한 나머지 지침들은 잘 준수되지 않는 방향으로 서술 압력이 작동하게 될 수도 있습니다. 그리고 목적과 의도를 생략하고 제한 사항만 요약한다면 목적에 부합하지 않게 기계적으로 지침을 준수했는지 확인하게 될 수도 있습니다.


## 동작 범위

1. 본문의 지침들은 한국어를 활용하는 상황에서 그 한국어를 명확하게 출력하라는 지시입니다. 외국어 문장이나 어휘를 출력해야 하는 상황에서, 그것을 한국어로 번역하거나 대체하라는 지시가 아닙니다.

2. 변수명과 주석, 커밋 메시지, 로그 문자열처럼 코드에 속하는 텍스트는 프로젝트의 기존 관례를 준수해야 합니다. 이러한 텍스트는 지침을 적용하면 안 되기 때문에 이 조항에서 한 번 더 강조하고 있습니다.

3. 고유 명사와 기술 용어 등은, 통상적인 용례로 정착된 번역어 혹은 음차가 있다면 우선적으로 사용하고, 그렇지 않다면 원어를 유지함으로써, 한국어 사용자가 이해하기 편하고 의미를 잘 이해할 수 있도록 합니다.

4. 사용자가 어떤 어조나 어휘를 사용하든지, 사용자 메시지의 어조를 모방하지 않고, 본문에서 제시하는 지침들을 일관되게 유지합니다.


## 문장 단위

1. 읽는 이가 문장의 의미를 충분히 이해할 수 있어야 하므로, 의미가 있는 문장 성분을 생략하지 않습니다. [그러면 경고가 붙습니다.→ ('그러면 이미 작업 중인 파일에도 경고 표지가 추가됩니다.'와 같이, 맥락과 정보를 충분히 제공하도록 수정) ]  특히 관형격 조사인 '~의'를 필요 이상으로 사용한다면, 의미를 담고 있는 문장 성분을 생략하기 쉬우므로 유의해야 합니다.  [사본의 문구는 작업의 상황을 → 사본에 기재된 문구는 작업이 진행되는 상황을]

2. (이 2번 조항은 헤더와 목록에는 강제로 적용되는 사항이 아닙니다.) 명사구나 부사구, 연결어미로 문장을 끝내지 말고, 서술어와 종결어미를 사용하여 완성된 형태의 문장으로 끝을 맺어야 합니다.


## 구 단위

1. 필수적인 경우가 아니라면 조사와 어미를 생략하지 말아야 합니다. 또한 부사, 보조사와 선어말어미, 보조 용언을 적극적으로 활용하면, 의미가 명확한 한국어 문장을 완성할 수 있습니다. [이 결정은 이후 중요 정책이 갈리는 자리. 컨텍스트 압축 전 신중 반영한다. → 이 결정은 이후 중요한 정책에 지속적으로 영향을 주기 때문에, 컨텍스트가 압축되기 전에 신중히 반영합니다. → 지금 답변해주신 결정 사항은 이후 중요한 정책에도 지속적으로 영향을 미치기 때문에, 컨텍스트가 압축되기 전에 미리 신중하게 반영해 놓겠습니다.]

2. 구체적인 의미를 담고 있는 한자어와 자연스러운 통사 구조를 결합하면, 풍부하고 명확한 의미를 전달할 수 있습니다. 따라서 맥락에 적합한 한자어를 적극적으로 활용하고, 그 한자어에 조사와 어미를 붙여서 어휘 사이의 관계를 확실하게 나타내야 합니다. [<쓴 비용을 구하는 토큰 카운트 함수에 문제가 생기면 (상황에 적합한 어휘가 사용되지 않아 의미가 불충분함) /지출 비용 추론 용도의 토큰 카운트 함수의 오류 상황에서 (조사와 어미가 없어 가독성이 낮고 의미 관계가 불분명함)>  → 지출한 비용을 추론하는 토큰 카운트 함수에 오류가 발생하면 (이 지침의 목표 예시)]

3. 일반적인 어휘를 사용해야 하는 자리에 비유적 어휘를 사용하면 가독성이 낮고, 의미가 변질되기 쉽습니다. 따라서 꼭 필요한 경우가 아니라면 비유적 어휘로 일반적인 명사나 동사를 대체하지 않습니다. 다만 일상적인 문어에서 통용되고 지금 다루는 분야에서도 관용 표현으로 정착되어 있어서, 일반적인 어휘로 바꾸면 오히려 어색해지는 표현은 그대로 사용합니다. [<분석의 흐름 → 분석의 방향성>, <코드로 박는 자리 → 코드에 명시하는 상황 (혹은 코드에 명시하는 작업)>, <요청을 받습니다 -> 요청을 확인했습니다 (혹은 요청대로 수행하겠습니다)>]

4. 엠대시(—)는 앞뒤 문장의 관계를 지나치게 함축하기 때문에 자제하고, 문맥과 형식에 따라 콜론이나 접속사로 대체합니다.


## 추가 사항

- 서브에이전트를 호출할 때, 한국어로 프롬프트를 작성했다면 실제로 서브에이전트 호출 도구를 사용하기 전에 이 본문의 지침들이 준수되어 있는지 점검합니다. 서브에이전트가 산출한 결과를 사용자에게 전달할 때에도 본문의 지침들이 그대로 적용됩니다.
===== 지침 끝 =====

===== 고치기 전/후 예시 (dira 엔진) =====
사람이 읽는 글은 이렇게 고칩니다.
- 고치기 전: 앞의 둘이 원인을 가르는 손이고, 셋째는 원인과 무관하게 손실을 묶는 손입니다
  고친 뒤: 앞의 둘이 원인을 파악하기 위한 작업이고, 셋째는 원인과 무관하게 손실을 방지하기 위한 작업입니다
- 고치기 전: 안 잰 수를 먼저 계약으로 적으면 하루 만에 흔들립니다
  고친 뒤: 측정하지 않고 규칙으로 정하면 바로 문제가 발생할 것입니다
- 고치기 전: 그래서 저라면 요구를 이렇게 세웁니다
  고친 뒤: 그래서 저라면 이렇게 요구합니다
===== 예시 끝 =====
FLUENTKO
)

$PROMPT"
fi

# --- 코어 프로토콜: <엔진 레포>/protocols/CORE.md 를 프롬프트 맨 앞에 인라인한다 ---
# 엔진이 읽는 계약(파일명 상태·claim·frontmatter 키·`## 블록`)이라 큐 밖에 살고 사본이 없다 -
# 큐에 없으니 사람이 지울 수 없다(§프롬프트 층 결정 1). 큐 AGENTS.md **앞**에 서므로 프로젝트
# 문서가 뒤에서 어긋난 규약을 적어도 세션이 어느 쪽을 따를지 안다(결정 3 - 코어 머리에 우선순위 한 줄).
# 조립은 prepend라 이 블록이 코드에서 마지막이어야 프롬프트에서 첫 번째다.
# 큐 쪽 vendored 사본이 있으면 그것부터 읽고, 없으면 엔진 사본으로 폴백한다(§프롬프트 층
# 결정 8-b) - dmg 배포에는 "엔진 레포"가 없어 새 프로젝트가 코어를 자기 큐에 품는다.
# 둘 다 없으면 WARN만 남기고 넘어간다 - 디스패치를 세우는 쪽이 더 나쁘다(프로토콜 인라인과 같다).
CORE="$TICKET_ROOT/protocols/CORE.md"
[ -r "$CORE" ] || CORE="$TICKET_CWD/protocols/CORE.md"
[ -r "$CORE" ] || CORE="$CODE/protocols/CORE.md"
if [ -r "$CORE" ]; then
  PROMPT="===== CORE.md ($(wtpath "$CORE")) =====
$(cat "$CORE")
===== 코어 프로토콜 끝 =====

$PROMPT"
else
  log "WARN 코어 프로토콜 없음: $CORE (코어 없이 디스패치)"
fi

# 문서 층이 다 쌓였다. HEAD로 따로 쥐고(스트리밍 프라임 JSON의 앞 블록), PROMPT는 TAIL을 다시
# 붙여 종전과 같은 통짜 문자열로 되돌린다(argv 치환·dryrun은 여기서부터 이 PROMPT를 쓴다).
HEAD="$PROMPT"
PROMPT="$PROMPT$TAIL"

# 엔진 argv 조립: 토큰 치환은 여기서만 한다(프롬프트에 공백·개행이 있어도 인자 1개로 유지).
ENGINE=()
for arg in "${TICKET_ENGINE[@]}"; do
  arg="${arg//\{prompt\}/$PROMPT}"
  ENGINE+=("${arg//\{sid\}/$SID}")
done

if [ "$CMD" = "dryrun" ]; then
  echo "워커: $TICKET_NAME (루트 $TICKET_ROOT, cwd $TICKET_CWD)"
  echo "선정: $THASH (kind ${TKIND:--}, 페르소나 ${TPERSONA:-없음})"
  echo "경로: $TPATH"
  echo "엔진: ${TICKET_ENGINE[*]}"
  echo "프롬프트: $PROMPT"
  exit 0
fi

# 세션키 선발급 -> 즉시 frontmatter 기록(디스패치 순간부터 '할당됨'으로 큐에서 제외)
python3 "$PY" assign "$TPATH" "$SID" "${TPERSONA:-agent} / ${TICKET_NAME}-${SID:0:8}" || {
  log "ERROR assign 실패 $THASH"; OUT=$(reap_silent "$TPATH"); [ -n "$OUT" ] && log "$OUT"; exit 1; }
LOGF="$LOGDIR/$(date '+%Y%m%d-%H%M%S')-${TICKET_NAME}-${THASH}.log"
PRIOLOG=$(prio_log "$TPRIO" "$TBASE" "$TEFF")
log "DISPATCH $THASH kind=${TKIND:--} persona=${TPERSONA:-none} sid=$SID log=$(basename "$LOGF") $PRIOLOG"

cleanup_stray_wip "$TICKET_CWD"

# 판정 1(DESIGN.md §엔진 수정 마흔 번째 승인) - 디스패치 시점의 더러운 경로를 적어 둔다.
# push.sh ship이 같은 경로를 대조해 세션이 안 건드린 채로 남아 있으면 커밋을 거절한다.
# 대조는 경로만 - 내용은 안 본다. 깨끗하면 지운다(앞 회차가 남긴 같은 이름의 파일도 치운다).
_dirty_fp="$LOCAL/run/dirty-$THASH"
_dirty_now=$(git -C "$TICKET_CWD" status --porcelain 2>/dev/null | cut -c4-)
if [ -n "$_dirty_now" ]; then
  printf '%s\n' "$_dirty_now" > "$_dirty_fp"
else
  rm -f -- "$_dirty_fp"
fi

cd "$TICKET_CWD" || { log "ERROR cwd 없음 $TICKET_CWD"; OUT=$(reap_silent "$TPATH"); [ -n "$OUT" ] && log "$OUT"; exit 1; }

# 실행 상한(기본 90분). 매달린 세션이 티켓을 무한정 쥐고 있는 걸 막는다.
# 관측치: 정상 티켓은 5~25분, 죽은 세션 하나가 2시간14분을 쥐고 있었다(2026-07-28 스트림 9b3e5c08).
OUTF="$LOGDIR/.out-${SID}"

# --- 참견 입구: 스트리밍 입력 엔진일 때만 FIFO를 판다 ---
# 갈림은 최종 argv에 `--input-format stream-json`이 인접해 있는가 하나다. 없으면 종전 그대로
# (프로세스가 스스로 끝나고 RC가 판정) - Codex와 가짜 엔진이 그 경로로 간다.
prev=""
for arg in "${ENGINE[@]}"; do
  if [ "$prev" = "--input-format" ] && [ "$arg" = "stream-json" ]; then
    INBOX="$LOCAL/run/inbox-$SID"; break
  fi
  prev="$arg"
done

if [ -n "$INBOX" ]; then
  rm -f "$INBOX"; mkfifo "$INBOX" || { log "ERROR mkfifo 실패 $INBOX"; INBOX=""; }
fi
if [ -n "$INBOX" ]; then
  # O_RDWR로 연다. 쓰기 전용으로 열면 읽는 쪽이 붙을 때까지 블록하고, 엔진이 못 뜨면 영영
  # 안 풀린다. 읽기도 같이 잡으면 open이 즉시 돌아오고 우리가 항상 writer라 엔진이 EOF를 안 본다
  # (최초 프롬프트를 쓴 직후 세션이 끝나는 걸 막는 것이 이 fd의 일이다). 우리는 읽지 않는다.
  exec 9<>"$INBOX"
  # 최초 프롬프트는 FIFO가 아니라 **파일**로 먹인다. FIFO로 밀면 엔진 기동이 겹칠 때 교착한다:
  # 프롬프트(실측 58KB)가 파이프 버퍼(64KB)를 넘으면 write가 블록하고, 그 상태의 엔진은
  # init조차 못 내고 멎는다. 2026-08-04 실측 - 동시 6개 FIFO 대형 프롬프트는 6/6 STALL,
  # 같은 프롬프트를 파일로 먹이면 6/6이 2초에 init. 1개만 띄우면 FIFO로도 되므로 한동안
  # 안 보이다가 워커가 늘면서 터졌다(7/30 실패 0% -> 8/3 22시 86%).
  # cat 두 방으로 이어 붙여 참견 입구는 그대로 남는다: 프롬프트 다음 줄부터 FIFO가 stdin이다.
  # 그룹에도 9>&-를 건다. cat이 fd 9(쓰기 끝)를 물려받으면 우리가 닫아도 자기가 writer라
  # EOF를 못 봐서 세션이 죽은 뒤에도 영영 남는다.
  # cache_control은 우리 몫이 0이다. CLI가 자기 몫으로 4개를 다 쓴다 - system 둘 + 대화 롤링
  # 둘이고, 롤링 창은 도구 결과가 붙는 **둘째** 요청부터 2개가 된다(2026-08-28 실측: 로컬
  # 기록 API로 요청 본문을 떠서 셌다). 우리가 한 개라도 달면 그 세션은 둘째 요청에서 통째로
  # 400이다 - "A maximum of 4 blocks with cache_control may be provided. Found 5.". 그 400이
  # api_error로 읽혀 쿨다운을 걸고, 만료 직전 나간 워커가 또 400을 받아 되감는 고리가 큐를
  # 6시간 세웠다(04:50~11:07, 실패 세션 14건).
  #
  # 그러면서 P295 이득은 지킨다 - 안 변하는 문서 층(HEAD)을 프라임 JSON이 아니라
  # `--append-system-prompt`로 넘긴다. CLI가 그 텍스트를 **자기 시스템 블록 끝에 이어 붙이고**,
  # 그 블록에는 CLI 자기 cache_control ttl 1h가 이미 달려 있다(같은 실측: 붙인 뒤에도 요청의
  # cache_control 총 개수는 턴1 3 - 턴2 4로 그대로다). 우리 블록을 하나도 안 쓰고 HEAD가
  # 캐시 프리픽스 안에 들어간다. 덤으로 옛 자리보다 캐시가 오래 산다 - 옛 자리(첫 user 메시지)는
  # 매 커밋마다 갈리는 gitStatus 리마인더 **뒤**였는데, 시스템 블록은 그 앞이라 커밋에 안 깨진다.
  # 워커가 다른 세션의 것을 읽으려면 그 블록이 디스패치 사이에 같아야 하는데, 같다(같은 워커
  # cwd로 띄운 세션 둘의 시스템 블록이 바이트 단위로 같은 것을 확인했다).
  #
  # 스트리밍 입력 엔진에만 붙인다 - 그 갈림(위 `--input-format stream-json` 인접 판정)이 곧
  # claude다. 다른 엔진에 stream-json을 물리려면 이 플래그도 그 엔진 말로 옮겨야 한다.
  ENGINE+=(--append-system-prompt "$HEAD")
  PRIMEF="$LOCAL/run/prime-$SID.json"
  python3 -c 'import json,sys
content = [{"type": "text", "text": sys.argv[1]}]
sys.stdout.write(json.dumps({"type":"user","message":{"role":"user","content":content}},
                            ensure_ascii=False, separators=(",", ":")) + "\n")' "$TAIL" > "$PRIMEF"
  # 9>&-로 엔진의 fd 9 사본을 닫는다. 물려주면 엔진이 자기 쓰기 끝을 쥐고 있어, 아래에서
  # 우리가 fd 9를 닫아도 EOF를 영영 못 본다(FIFO의 writer가 0이 되어야 EOF다).
  # `.fed` 표식이 곧 "프롬프트가 엔진 stdin으로 다 들어갔다"이다. 파이프 버퍼보다 큰 프롬프트를
  # 안 빠는 엔진에서는 첫 cat이 막혀 표식이 안 생긴다 - 옛 feeder 생존 판정과 같은 근거다.
  # FIFO는 그룹 진입 때 fd 8로 **미리** 연다. 두 번째 cat이 그때 가서 열면, 워커가 먼저 끝나
  # fd 9가 닫힌 뒤엔 writer 없는 FIFO를 여는 셈이라 open에서 영영 막힌다 - 그 cat이 워커의
  # stderr를 쥔 채 남아 호출자(capture_output·테스트)가 EOF를 못 본다. 여기서 열면 fd 9가
  # 아직 살아 있어 open이 즉시 돌아오고, 나중에 fd 9가 닫히면 EOF로 정상 종료한다.
  # 그룹의 stderr도 로그로 보낸다(워커 stderr를 물려주지 않는다). 9>&-는 위 fd 9와 같은 이유다.
  { cat "$PRIMEF" && : > "$PRIMEF.fed"; cat <&8; } 8<"$INBOX" 9>&- 2>>"$LOGF" | "${ENGINE[@]}" >"$OUTF" 2>>"$LOGF" 9>&- &
  CPID=$!
else
  # </dev/null: 비스트리밍 엔진에는 참견 채널이 없으니 stdin을 물려줄 이유가 없다. 그런데
  # `codex exec`는 프롬프트를 argv로 받고도 stdin을 EOF까지 읽는다("Reading additional input
  # from stdin..."). 터미널에서 워커를 손으로 돌리면 fd0이 tty라 EOF가 안 와 turn이 시작조차
  # 못 한다(실측 210초 정지, 상한은 TICKET_MAXRUN=5400s). cron은 이미 닫힌 fd0을 줘서 안 걸린다.
  "${ENGINE[@]}" </dev/null >"$OUTF" 2>>"$LOGF" &
  CPID=$!
fi
# Codex에는 Claude식 --session-id가 없으므로 실제 엔진 pid도 남겨 reap이 생존을 확인한다.
# 프롬프트 주입보다 **먼저** 적는다. 주입이 막히는 동안 pid가 비어 있으면 reap이 판정할 근거가
# 없어 티켓이 진행중에 영구 잔류한다(2026-08-01 실사고).
python3 "$PY" setpid "$TPATH" "$CPID"

if [ -n "$INBOX" ]; then
  # 디스패치가 섰는지는 둘을 같이 본다. 하나만으로는 새는 구멍이 있다:
  #   주입 완료(.fed)만: 프롬프트가 버퍼에 다 들어가도 엔진이 기동에서 멎으면 못 본다
  #                      - 2026-08-04의 실제 사고가 그 모양이었다(init도 없이 0% CPU).
  #   init만:            프롬프트를 한 글자도 안 빠는 엔진이 init만 뱉고 자면 통과한다.
  # 상한을 넘기면 세션을 죽여 아래 wait이 평범한 FAIL 경로로 떨어지게 한다(clear + release + 복귀).
  started() { [ -e "$PRIMEF.fed" ] && grep -q '"subtype":"init"' "$OUTF" 2>/dev/null; }
  FED=0
  while [ "$FED" -lt "$TICKET_FEED_TIMEOUT" ] && kill -0 "$CPID" 2>/dev/null; do
    started && break
    sleep 1; FED=$((FED+1))
  done
  if started; then
    # 프롬프트를 넣은 뒤에 입구를 광고한다. 순서를 뒤집으면 화면이 먼저 밀어 넣은 참견이
    # 티켓 지시 줄 사이에 끼어들어 JSON 한 줄이 깨진다.
    python3 "$PY" setinbox "$TPATH" "$INBOX"
  else
    kill -KILL "$CPID" 2>/dev/null
    log "STALL $THASH ${TICKET_FEED_TIMEOUT}s 안에 프롬프트 주입+init을 못 봤다 - 기동 실패 (fed=$([ -e "$PRIMEF.fed" ] && echo y || echo n))"
  fi
fi
# 감시자는 짧은 sleep으로 돈다. 한 방 `sleep $TICKET_MAXRUN`이면 세션이 끝난 뒤에도 그 sleep이
# 상속받은 stdout/stderr를 90분간 쥐고 남아, 호출자(cron·테스트)가 파이프에서 못 빠져나온다.
# 스트리밍 입력에서는 stdin이 열려 있는 한 세션이 스스로 안 끝난다(닫아도 60초는 안 죽는다).
# `result` 줄이 곧 끝이고, 끝내는 건 우리다. MAXRUN은 그 줄이 영영 안 오는 경우로 남는다.
POLL=5; [ -n "$INBOX" ] && POLL=1
# 마지막 줄이 아니라 offset(줄 수) 이후의 마지막 줄이 `result`인가. §4-11 재활용은 세션 하나에
# 티켓이 여러 장 쌓이므로 "파일 마지막 줄"로는 둘째 주입 직후 첫 티켓의 result를 다시 보고
# 즉시 죽인다(구현 함정 1호, §검증 ⑥) - offset이 그 경계다.
# 접두사로는 못 본다 - 실측된 키 순서는 `is_error`가 먼저다. 문자열 매치만으로 죽이는 것도
# 안 된다: 세션이 뱉는 본문에 이 프로토콜이 그대로 인용될 수 있고(이 레포가 그 문서를 갖고
# 있다) 그러면 남의 티켓을 중간에 잘라낸다. grep은 문지기고 판정은 파싱이다.
is_result() {
  local line
  # 구간 끝에서 type:system 줄만 건너뛰고, 처음 만나는 줄을 본다(P448).
  line=$(tail -n +"$(( $2 + 1 ))" "$1" 2>/dev/null | python3 -c '
import json,sys
lines = [l.rstrip("\n") for l in sys.stdin if l.strip()]
for ln in reversed(lines):
    try:
        o = json.loads(ln)
    except Exception:
        print(ln)
        break
    if isinstance(o, dict) and o.get("type") == "system":
        continue
    print(ln)
    break
')
  [ -n "$line" ] || return 1
  printf '%s' "$line" | grep -q '"type":"result"' || return 1
  printf '%s' "$line" | python3 -c \
    'import json,sys
try: o = json.loads(sys.stdin.readline())
except Exception: sys.exit(1)
sys.exit(0 if isinstance(o, dict) and o.get("type") == "result" else 1)'
}

# §4-11 조건 ②④: 이번 구간(offset 이후)만의 판정 + 마지막 assistant 턴 컨텍스트.
# "sid|ok|reason|reset|ctx" 한 줄 - 아래 최종 VERDICT 파서와 같은 필드 + ctx 하나뿐이다.
# 최종 파서는 안 건드린다 - 그건 전체 $OUT을 훑어 마지막 result로 자연히 떨어지므로(누적
# 스캔이 마지막 값으로 덮어써진다) 체인 전체가 끝난 뒤의 판정은 종전 그대로 맞는다.
segment_result() {
  tail -n +"$(( $2 + 1 ))" "$1" 2>/dev/null | python3 -c \
    'import json,sys
LIMIT_WORDS = ("usage limit", "rate limit", "quota")
sid = ""; ok = ""; reason = ""; reset = ""; ctx = ""
for ln in sys.stdin:
    ln = ln.strip()
    if not ln:
        continue
    try: o = json.loads(ln)
    except Exception: continue
    if not isinstance(o, dict): continue
    if o.get("type") == "assistant":
        u = ((o.get("message") or {}).get("usage")) or {}
        try:
            ctx = str(int(u.get("input_tokens", 0)) + int(u.get("cache_creation_input_tokens", 0))
                      + int(u.get("cache_read_input_tokens", 0)))
        except Exception:
            pass
    elif o.get("type") == "result":
        sid = o.get("session_id", "") or sid
        ok = "err" if o.get("is_error") else "ok"
        if "terminal_reason" in o:
            reason = o.get("terminal_reason", "") or ""
        elif o.get("is_error"):
            errs = " ".join(str(e) for e in (o.get("errors") or [])).lower()
            if any(k in errs for k in LIMIT_WORDS):
                reason = "api_error"
    elif o.get("type") == "rate_limit_event":
        info = o.get("rate_limit_info") or {}
        if info.get("status") == "rejected" and isinstance(info.get("resetsAt"), int):
            reset = str(info["resetsAt"])
    elif o.get("type") == "error":
        msg = str(o.get("message", "")).lower()
        if any(k in msg for k in LIMIT_WORDS):
            reason = "api_error"
print("|".join((sid, ok, reason, reset, ctx)))'
}

# 엔진 수정 마흔한 번째 승인 §판정 1 - 세 조건. segok는 이번 구간의 segment_result 둘째
# 필드(ok/err)를 호출부가 이미 파싱해 건네준다(segment_result를 여기서 또 부르지 않는다).
bg_pending() {
  local segok="$1"
  [ "$segok" = "ok" ] || return 1
  [ -f "$TPATH" ] || return 1
  # P435 결정 4 - 하네스가 붙이는 문구('moved to the background (ID: ')뿐 아니라 세션이
  # `run_in_background`로 직접 띄운 명령의 문구('Command running in background with ID: ')도
  # 같은 밀림으로 센다. 둘 다 "이번 구간에 백그라운드로 넘어간 작업이 있다"는 같은 사실이다.
  tail -n +"$(( OUTOFFSET + 1 ))" "$OUTF" 2>/dev/null | grep -qF -e 'moved to the background (ID: ' -e 'Command running in background with ID: '
}

# P435 결정 1 - $1(줄 번호) 뒤에 새로 생긴 줄 중 assistant/user/result 타입이 하나라도
# 있으면 참. system 줄(bg_task_stopped가 보는 것과 같은 부류 - task_notification 등)은
# 안 센다 - 턴이 닫히며 하네스가 붙이는 정리 이벤트라 다음 result가 온다는 신호가 아니다.
bg_real_growth() {
  [ "$(wc -l < "$OUTF")" -gt "$1" ] || return 1
  tail -n +"$(( $1 + 1 ))" "$OUTF" 2>/dev/null | python3 -c '
import json,sys
for ln in sys.stdin:
    ln = ln.strip()
    if not ln:
        continue
    try:
        o = json.loads(ln)
    except Exception:
        continue
    if isinstance(o, dict) and o.get("type") in ("assistant", "user", "result"):
        sys.exit(0)
sys.exit(1)'
}

# P435 결정 1 §2 - 이번 구간(OUTOFFSET 뒤, bg_pending과 같은 자리)에 task_notification
# (status stopped)이 이미 있으면 더 기다릴 이유가 없다.
bg_task_stopped() {
  tail -n +"$(( OUTOFFSET + 1 ))" "$OUTF" 2>/dev/null | python3 -c '
import json,sys
for ln in sys.stdin:
    ln = ln.strip()
    if not ln:
        continue
    try:
        o = json.loads(ln)
    except Exception:
        continue
    if isinstance(o, dict) and o.get("type") == "system" \
            and o.get("subtype") == "task_notification" and o.get("status") == "stopped":
        sys.exit(0)
sys.exit(1)'
}

# 유예 걸음 1·2 공용 - LASTLINE(호출 시점의 줄 수) 대비 진짜 성장(bg_real_growth)이
# TICKET_BG_GRACE초 안에 나면 0. 그사이 stopped 알림이 보이면 더 기다리지 않고 2를 낸다
# (P435 결정 1 §2, 호출부가 문구를 가른다). POLL 간격으로 본다 - is_result 감시 루프와
# 같은 박자다. 세션이 그 사이 죽으면(kill -0 실패) 더 기다릴 이유가 없어 즉시 판정한다.
bg_wait_grow() {
  local lastline elapsed
  lastline=$(wc -l < "$OUTF")
  elapsed=0
  while [ "$elapsed" -lt "$TICKET_BG_GRACE" ]; do
    bg_real_growth "$lastline" && return 0
    bg_task_stopped && return 2
    kill -0 "$CPID" 2>/dev/null || break
    sleep "$POLL"; elapsed=$((elapsed + POLL))
  done
  bg_real_growth "$lastline"
}

# §4-11 조건 ⑤: 같은 페르소나 후보를 종전 선정과 같은 임계구역·게이트에서 다시 claim한다.
# ENGINE_NAME·CDOWN은 이미 이 세션의 페르소나로 정해져 있다(위 선정 루프에서 세워졌고 그 뒤로
# 아무도 안 건드린다) - 재활용은 페르소나를 안 바꾸므로 다시 세우지 않고 같은 값으로 게이트를 본다.
select_reuse_candidate() {
  local persona="$1"
  RTPATH=""; RTHASH=""; RTKIND=""; RTPRIO=""; RTBASE=""; RTEFF=""
  local RCANDS
  RCANDS=$(python3 "$PY" select "$TICKET_ROOT") || return 1
  [ -z "$RCANDS" ] && return 1

  if [ -n "$LIMITED" ]; then
    local PLIM PWIP
    PLIM=$(persona_limit "$persona")
    if [ -n "$PLIM" ]; then
      PWIP=$(persona_wip "$persona")
      if [ "$PWIP" -ge "$PLIM" ]; then
        log "SKIP 페르소나 상한 $persona $PWIP/$PLIM"
        return 1
      fi
    fi
  fi

  engine_gate_ok || return 1

  if [ -n "$LIMITED" ]; then
    acquire_slock || return 1
  fi

  local rc_path rc_hash rc_kind rc_persona rc_prio rc_base rc_eff rc_squadp RCPATH
  # §5-5 §안 하는 것 - 세션 재활용은 안 갈린다(문자열 일치 하나). $persona는 이미 이 세션이
  # 최초 디스패치에서 스쿼드를 풀어 확정한 값이라 rc_squadp를 다시 덮어 쓸 이유가 없다 -
  # 필드 수만 맞춘다(안 맞추면 마지막 값 rc_eff가 squad_persona를 삼킨다).
  while IFS='|' read -r rc_path rc_hash rc_kind rc_persona rc_prio rc_base rc_eff rc_squadp; do
    [ -z "$rc_path" ] && continue
    [ "$rc_persona" = "$persona" ] || continue
    if RCPATH=$(python3 "$PY" claim "$rc_path" 2>/dev/null); then
      RTPATH="$RCPATH"; RTHASH="$rc_hash"; RTKIND="$rc_kind"; RTPRIO="$rc_prio"; RTBASE="$rc_base"; RTEFF="$rc_eff"
      break
    fi
  done <<EOF
$RCANDS
EOF

  [ -n "$SLOCK" ] && { rm -rf "$SLOCK"; SLOCK=""; }
  [ -n "$RTPATH" ]
}

# 엔진 수정 서른네 번째 승인 §판정 1 - 조건 1·2(계획 절이 있다 / 완료·취소가 아닌 항목이
# 하나 있다)의 판정. `## 진행 계획` 다음 `## ` 절 앞까지가 그 절이다 - 항목은 `- [ ]`/`- [x]`
# 줄 하나(중첩 없음, §2-11 ①). 취소는 문장이 `~~`로 감싸였다(같은 절 상태 표) - 상자 뒤
# 첫 비공백이 `~~`면 취소로 본다. 켠 상자(`x`/`X`)도 취소도 아닌 줄이 하나면 참견 대상이다.
# exit 0 = 참견 대상 있음, exit 1 = 없음(절이 없거나 다 끝났거나 다 취소됐다).
plan_needs_nudge() {
  python3 -c '
import re, sys
try:
    text = open(sys.argv[1], encoding="utf-8").read()
except OSError:
    sys.exit(1)
m = re.search(r"^## 진행 계획[ \t]*$", text, re.M)
if not m:
    sys.exit(1)
rest = text[m.end():]
m2 = re.search(r"^## ", rest, re.M)
section = rest[:m2.start()] if m2 else rest
for line in section.splitlines():
    lm = re.match(r"^-\s*\[([ xX])\]\s*(.*)$", line)
    if not lm:
        continue
    box, tail = lm.groups()
    if box.lower() == "x":
        continue
    if tail.strip().startswith("~~"):
        continue
    sys.exit(0)
sys.exit(1)
' "$1"
}

# 엔진 수정 서른일곱 번째 승인 §판정 1 - 조건 1의 둘째 갈래(절이 아예 없다). exit 0 = 절이
# 없다(참견 대상), exit 1 = 절이 있다(첫째 갈래로 넘긴다 - plan_needs_nudge가 그 안을 본다).
plan_section_missing() {
  python3 -c '
import re, sys
try:
    text = open(sys.argv[1], encoding="utf-8").read()
except OSError:
    sys.exit(1)
sys.exit(1 if re.search(r"^## 진행 계획[ \t]*$", text, re.M) else 0)
' "$1"
}

# 참견 무장 상태 - 넷이 한 벌이다. PN_MTIME은 마지막으로 본 티켓 파일 mtime(정수 초),
# PN_SINCE는 그 mtime이 안 갈린 채로 시작된 시각(에폭), PN_ARMED=1이면 이번 정체에서
# 아직 참견을 안 넣었다(조건 4). TPATH가 바뀌면(§4-11 재활용) 호출부가 PN_MTIME을 비워
# 다시 무장시킨다 - 새 티켓의 mtime을 옛 티켓의 것과 우연히 비교하지 않는다. PN_KIND는
# check_plan_nudge가 exit 0으로 돌아온 뒤 호출부가 참견 문장을 고르는 갈래 표식이다.
PN_MTIME=""; PN_SINCE=0; PN_ARMED=1; PN_KIND=""
# 엔진 수정 마흔한 번째 승인 §판정 1 - 이 티켓에서 유예를 쓴 횟수(TICKET_BG_MAX가 상한).
# REUSE로 새 티켓을 받으면 0으로 되감는다(아래 REUSE 절 참고) - 티켓마다 새로 잰다.
BG_GRACE_USED=0

# 감시 루프가 매 POLL(스트리밍이면 1초)마다 부른다. `TICKET_PLAN_NUDGE=0`이면 장치가 꺼진다
# (조건 6). 파일이 갈리면(mtime 변화) 다시 무장하고 시계를 되감는다(조건 3·4) - 세션의 손이
# 계획이든 다른 무엇이든 그 티켓 파일에 한 글자라도 쓰면 이 mtime이 움직인다.
check_plan_nudge() {
  [ "$TICKET_PLAN_NUDGE" = "0" ] && return 1
  [ -f "$TPATH" ] || return 1
  local mtime now
  mtime=$(python3 -c 'import os,sys; print(int(os.path.getmtime(sys.argv[1])))' "$TPATH" 2>/dev/null) || return 1
  now=$(date +%s)
  if [ "$mtime" != "$PN_MTIME" ]; then
    PN_MTIME="$mtime"; PN_SINCE="$now"; PN_ARMED=1
    return 1
  fi
  [ "$PN_ARMED" = 1 ] || return 1
  [ $(( now - PN_SINCE )) -ge "$TICKET_PLAN_NUDGE" ] || return 1
  if plan_section_missing "$TPATH"; then
    PN_KIND="section"; return 0
  fi
  if plan_needs_nudge "$TPATH"; then
    PN_KIND="box"; return 0
  fi
  return 1
}

# 사람 참견 표식(엔진 수정 서른여섯 번째 승인 §판정 2 §경계 셋) - 자리는 `$INBOX.human`,
# `lib/interject.ts`가 FIFO에 쓴 뒤 같은 자리를 건드리는 사이드카 파일이다. 새 frontmatter
# 키 0(파일이 티켓 밖에 있다) - 엔진은 시각만 읽고 이 파일에 안 쓴다(mkfifo 자리 옆의 다른
# 런타임 파일과 같은 신분, `$PRIMEF.fed`처럼) - 사람이 보는 문구 0(내용을 안 읽고 mtime만
# 본다). PN_SINCE(이번 무장 정체가 시작된 시각) 뒤에 표식이 갈렸으면 그 정체 동안 사람
# 참견이 들어온 것이다 - 계약 2.
human_since_arm() {
  [ -n "$INBOX" ] && [ -f "$INBOX.human" ] || return 1
  local hm
  hm=$(python3 -c 'import os,sys; print(int(os.path.getmtime(sys.argv[1])))' "$INBOX.human" 2>/dev/null) || return 1
  [ "$hm" -ge "$PN_SINCE" ]
}

# 엔진 수정 서른여섯 번째 승인 §판정 2 - 참견을 넣은 뒤(PN_NUDGE_AT) TICKET_PLAN_KILL초
# 동안도 티켓 파일이 안 갈리면(PN_ARMED가 그 사실을 쥔다 - 갈렸으면 check_plan_nudge가 이미
# 재무장해 0으로 안 남는다) 참을 대상이다. 계약 1 - 이 판정이 세는 것은 엔진이 넣은 참견
# 하나이고, 사람이 넣은 줄은 여기 입력이 아니다(사람 표식은 아래 한 줄에서만 본다).
# 계약 2 - 사람 참견이 이번 정체에서 들어왔으면 끊지 않는다.
PN_NUDGE_AT=0
check_plan_kill() {
  [ "$TICKET_PLAN_KILL" = "0" ] && return 1
  [ "$PN_ARMED" = 0 ] || return 1
  [ -f "$TPATH" ] || return 1
  local now
  now=$(date +%s)
  [ $(( now - PN_NUDGE_AT )) -ge "$TICKET_PLAN_KILL" ] || return 1
  ! human_since_arm
}

# 엔진 수정 서른아홉 번째 승인 §판정 1 - 로드 평균과 네트워크 도달 여부를 한 번에 잰다.
# 대상은 이름이 아니라 **IP 리터럴**(1.1.1.1:443)이다 - 호스트명이면 `socket.create_connection`
# 앞의 DNS 조회(getaddrinfo)가 블로킹 C 호출이라 `signal.alarm`이 못 끊는다(실측: 망이 없는
# 샌드박스에서 리졸버가 알아서 물러날 때까지 9~11초가 걸렸다 - 수용조건 5의 2초 상한을
# 넘긴다). IP로 접속을 열면 DNS가 아예 안 걸려 `connect(timeout=2)` 하나로 상한이 실측대로
# 닫힌다. `signal.alarm(2)`는 남겨서 혹시 다른 경로로 이름 조회가 들어와도 이중으로 막는다.
# 실패는 "fail"만 남기고 세션에는 아무것도 안 한다(수용조건 4). 새 바이너리 의존성 0 -
# python3는 이미 이 파일 전역의 의존성이다.
health_probe() {
  python3 - <<'PY' 2>/dev/null
import os, signal, socket

def _timeout(*_a):
    raise TimeoutError

try:
    load = "%.2f" % os.getloadavg()[0]
except (AttributeError, OSError):
    load = "?"

signal.signal(signal.SIGALRM, _timeout)
signal.alarm(2)
try:
    socket.create_connection(("1.1.1.1", 443), timeout=2).close()
    net = "ok"
except Exception:
    net = "fail"
finally:
    signal.alarm(0)

print(load + "|" + net)
PY
}

# 한 줄 = 시각 - 워커 - 세션 id - 티켓 해시 - 1분 로드 평균 - 네트워크 도달 여부 - 자식 pid
# 생존(수용조건 2). `runner.log`에는 안 섞는다(§1798 주석 - reap_release가 그 파일을 다시
# 파싱해서, 섞으면 그 판정을 흔들 위험이 있다). 날짜마다 파일을 가르면 보존 기간 삭제(P409-2)가
# 파일 단위로 그대로 걸린다.
health_line() {
  local hdir hfile probe load net alive
  hdir="$WORKERS/health"
  mkdir -p "$hdir" 2>/dev/null || return
  hfile="$hdir/$(date '+%Y%m%d').log"
  probe=$(health_probe); probe="${probe:-?|fail}"
  IFS='|' read -r load net <<< "$probe"
  kill -0 "$CPID" 2>/dev/null && alive=alive || alive=dead
  printf '%s [%s] sid=%s hash=%s load1=%s net=%s pid=%s\n' \
    "$(date '+%F %T')" "$TICKET_NAME" "$SID" "$THASH" "$load" "$net" "$alive" >> "$hfile"
}

# MAXRUN 감시. 매달린 세션을 죽이는 것이 이 감시의 뜻이지 체인 길이를 재는 게 아니라서
# §4-11 재활용마다 죽이고 다시 세운다("티켓마다 새로 잰다"). is_result에 의한 종료는 이제
# 여기 없다 - main 루프가 먼저 봐야 재활용 여부를 결정할 수 있어서 그 판정을 main으로 옮겼다.
# TIMEOUT과 KILLED를 가르는 값은 경과다(§2-5 §로그) - T0가 그 시계다.
# 서른아홉 번째 승인 §판정 1 - 이 루프가 이미 POLL 간격으로 돌므로 새 프로세스·새 감시자 없이
# HSECONDS 분기 하나로 건강 로그를 얹는다.
start_watchdog() {
  T0=$SECONDS
  ( SECONDS=0
    HSECONDS=0
    while [ "$SECONDS" -lt "$TICKET_MAXRUN" ]; do
      kill -0 "$CPID" 2>/dev/null || exit 0
      if [ "$TICKET_HEALTH_INTERVAL" != 0 ] && [ $(( SECONDS - HSECONDS )) -ge "$TICKET_HEALTH_INTERVAL" ]; then
        health_line
        HSECONDS=$SECONDS
      fi
      sleep "$POLL"
    done
    kill -TERM "$CPID" 2>/dev/null; sleep 20; kill -KILL "$CPID" 2>/dev/null ) &
  WPID=$!
}

OUTOFFSET=0
start_watchdog
# bash의 `wait PID`는 그 PID가 속한 **파이프라인 전체**를 기다린다. 프롬프트를 파일로 옮기면서
# 엔진 앞에 `{ cat "$PRIMEF"; cat <&8; }`가 붙었고, 그 cat은 우리가 fd 9를 닫아야 EOF를 본다.
# 먼저 wait하면 서로를 기다려 교착한다 - 세션이 result를 내고 죽어도 워커가 티켓을 안 놓는다
# (2026-08-04 실측: 6/6이 init까지 갔는데 DONE 0, 죽은 엔진 옆에 cat만 남아 MAXRUN까지 잡혔다).
# 그래서 엔진만 따로 지켜보고, fd 9를 닫아 cat을 빼낸 다음에 job을 회수한다.
if [ -n "$INBOX" ]; then
  while :; do
    while kill -0 "$CPID" 2>/dev/null && ! is_result "$OUTF" "$OUTOFFSET"; do
      if check_plan_nudge; then
        # 참견 한 줄 - 최초 프롬프트·이어받기 프롬프트와 같은 FIFO, 같은 JSON 한 줄 모양이다.
        # 무엇을 켜야 하는지는 안 담는다(§판정 1 §뒤집는 조건 - 엔진이 계획을 읽고 진행을
        # 추론하면 이 승인 밖이다) - 갈래마다 지시 하나뿐이다(엔진 수정 서른일곱 번째 승인
        # §판정 1 - 절이 없으면 계획을 세우라는 문장, 있으면 종전 문장 그대로).
        if [ "$PN_KIND" = "section" ]; then
          PN_MSG="## 진행 계획을 지금 세워 주세요."
        else
          PN_MSG="## 진행 계획 상자 중 이미 끝난 항목이 있으면 지금 켜 주세요."
        fi
        python3 -c 'import json,sys
sys.stdout.write(json.dumps({"type":"user","message":{"role":"user","content":sys.argv[1]}},
                            ensure_ascii=False, separators=(",", ":")) + "\n")' \
          "$PN_MSG" >&9
        PN_ARMED=0
        PN_NUDGE_AT=$(date +%s)
        log "NUDGE $THASH plan"
      fi
      if check_plan_kill; then
        # 참견을 넣은 뒤에도 정체가 안 풀렸다 - 끊는다. 로그 줄은 새로 안 만든다(§경계 -
        # 새 로그 머리말 0), 아래 통일 판정부가 이 경로도 rc=143 · EL<MAXRUN이라 종전
        # "KILLED" 줄을 그대로 낸다. PN_KILL_FIRED만 남겨 DEATH_KIND를 killed가 아니라
        # other로 돌린다(그래야 attempts가 오르고 예산이 문다 - §판정 2 수용조건 10).
        PN_KILL_FIRED=1
        kill -TERM "$CPID" 2>/dev/null; sleep 5; kill -KILL "$CPID" 2>/dev/null
      fi
      sleep "$POLL"
    done
    kill -0 "$CPID" 2>/dev/null || break     # 스스로 끝났다(MAXRUN 강제종료 포함) - 재활용 없이 종료 경로

    # 엔진 수정 마흔한 번째 승인 §판정 1 - REUSE 판정 앞에서 밀린 백그라운드 작업을 먼저
    # 본다. 세 조건(이번 구간 ok - 티켓이 아직 .wip - 이번 구간에 밀림 문구)이 다 참이고
    # 이 티켓에서 유예를 TICKET_BG_MAX회 미만으로 썼을 때만 걸고, 하나라도 거짓이면 아래
    # REUSE 판정으로 그대로 내려간다(종전 경로 한 글자도 안 갈림).
    if [ "$TICKET_BG_GRACE" != "0" ] && [ "$BG_GRACE_USED" -lt "$TICKET_BG_MAX" ]; then
      BG_SEG=$(segment_result "$OUTF" "$OUTOFFSET")
      IFS='|' read -r _BGSID BG_SEGOK _BGREASON _BGRESET _BGCTX <<< "$BG_SEG"
      if bg_pending "$BG_SEGOK"; then
        BG_GRACE_USED=$((BG_GRACE_USED + 1))
        bg_wait_grow; BG_GROW_RC=$?
        if [ "$BG_GROW_RC" -eq 0 ]; then
          continue     # 1. 기다린다 - 자랐다. offset 그대로 두고 다음 result를 다시 기다린다
        fi
        # P435 결정 1 §2 - 이미 stopped였으면(BG_GROW_RC=2) 기다리지 않고 바로 밀되 문구가
        # 갈린다. 민 뒤 판정(아래 2-3걸음)은 두 갈래 다 같다.
        if [ "$BG_GROW_RC" -eq 2 ]; then
          BG_MSG="턴을 닫아 밀린 작업이 중단됐습니다. 같은 명령을 timeout을 명시해 포그라운드로 다시 돌리거나 폴링 대기로 넘겨 주세요."
        else
          BG_MSG="밀려 있는 백그라운드 작업의 출력을 확인해서 마무리하거나 폴링 대기로 넘겨 주세요."
        fi
        # 2. 민다 - 참견과 같은 FIFO·같은 JSON 한 줄 모양이다. 새 장치를 안 만든다.
        python3 -c 'import json,sys
sys.stdout.write(json.dumps({"type":"user","message":{"role":"user","content":sys.argv[1]}},
                            ensure_ascii=False, separators=(",", ":")) + "\n")' \
          "$BG_MSG" >&9
        log "NUDGE $THASH bg"
        if bg_wait_grow; then
          continue     # 주입 뒤에 자랐다. 1과 같이 offset 그대로 두고 돌아간다
        fi
        # 3. 끝낸다 - 주입 뒤에도 안 자랐다. 아래 REUSE·종료 경로가 종전 그대로 이어받는다.
      fi
    fi

    # 새 구간의 result다. §4-11 재활용 판정 5개 - ①은 여기 도달한 것 자체가(스트리밍+INBOX)
    # 참이므로 TICKET_REUSE만 본다. 하나라도 거짓이면 종전 그대로 죽인다.
    REUSE=""
    if [ "$TICKET_REUSE" != "0" ]; then
      SEG=$(segment_result "$OUTF" "$OUTOFFSET")
      IFS='|' read -r _SEGSID SEGOK _SEGREASON _SEGRESET SEGCTX <<< "$SEG"
      if [ "$SEGOK" = "ok" ] && [ ! -f "$TPATH" ]; then          # ②③
        case "$SEGCTX" in
          [0-9]*) [ "$SEGCTX" -lt "$TICKET_REUSE_CTX" ] && REUSE=1 ;;   # ④(파싱 실패면 예산 초과로 본다)
        esac
        if [ -n "$REUSE" ] && ! select_reuse_candidate "$TPERSONA"; then  # ⑤
          REUSE=""
        fi
      fi
    fi

    if [ -n "$REUSE" ]; then
      # 이어 받는 절차는 최초 디스패치의 축소판이다: assign(같은 sid) -> setpid(같은 CPID) ->
      # 짧은 프롬프트 한 줄을 FIFO에 -> setinbox(주입 뒤에 광고 - tick.sh 최초 주입과 같은 이유).
      log "DONE $THASH sid=$SID"
      python3 "$PY" assign "$RTPATH" "$SID" "${TPERSONA:-agent} / ${TICKET_NAME}-${SID:0:8}"
      python3 "$PY" setpid "$RTPATH" "$CPID"
      RPROMPT=$(printf "$TICKET_PROMPT_FMT" "$RTHASH")
      python3 -c 'import json,sys
sys.stdout.write(json.dumps({"type":"user","message":{"role":"user","content":sys.argv[1]}},
                            ensure_ascii=False, separators=(",", ":")) + "\n")' "$RPROMPT" >&9
      INJOFFSET=$(wc -l < "$OUTF")
      python3 "$PY" setinbox "$RTPATH" "$INBOX"
      RPRIOLOG=$(prio_log "$RTPRIO" "$RTBASE" "$RTEFF")
      log "DISPATCH $RTHASH kind=${RTKIND:--} persona=${TPERSONA:-none} sid=$SID log=$(basename "$LOGF") $RPRIOLOG"

      # 주입 뒤 TICKET_FEED_TIMEOUT 안에 출력이 안 자라면 STALL과 같은 경로다(§4-11 §규칙) -
      # 최초 디스패치의 started() 자리와 같다. 여긴 init 판정이 없으니 "줄이 자랐나"가 그 신호고,
      # 죽었는데도 안 자란 경우까지 STALL로 뭉친다(started()도 kill -0가 죽어서 빠져나온
      # 경우를 갈라 보지 않는다 - 같은 관용구).
      FED=0
      while [ "$FED" -lt "$TICKET_FEED_TIMEOUT" ] && kill -0 "$CPID" 2>/dev/null; do
        [ "$(wc -l < "$OUTF")" -gt "$INJOFFSET" ] && break
        sleep 1; FED=$((FED+1))
      done
      if [ "$(wc -l < "$OUTF")" -le "$INJOFFSET" ]; then
        kill -KILL "$CPID" 2>/dev/null
        log "STALL $RTHASH ${TICKET_FEED_TIMEOUT}s 안에 이어받기 주입 뒤 출력이 안 자랐다 - 기동 실패"
        # §4-12 §개정 — ①과 같은 조건. 이 창(자기 assign 뒤 TICKET_FEED_TIMEOUT) 안에 reap이
        # 먼저 풀고 다른 세션이 재할당했으면 그 산 claim은 안 건드린다.
        live_other "$RTPATH" || { OUT=$(reap_silent "$RTPATH"); [ -n "$OUT" ] && log "$OUT"; }
        kill "$WPID" 2>/dev/null; wait "$WPID" 2>/dev/null
        exec 9>&-; wait "$CPID" 2>/dev/null
        OUT=$(cat "$OUTF" 2>/dev/null); rm -f "$OUTF"
        printf '%s\n' "$OUT" >> "$LOGF"
        exit 1
      fi

      OUTOFFSET="$INJOFFSET"
      TPATH="$RTPATH"; THASH="$RTHASH"; TKIND="$RTKIND"
      PN_MTIME=""; PN_SINCE=0; PN_ARMED=1; PN_NUDGE_AT=0  # 새 티켓 - 참견 무장을 새로 잰다(옛 mtime과 안 겹친다)
      BG_GRACE_USED=0  # 새 티켓 - 유예 횟수도 새로 잰다
      kill "$WPID" 2>/dev/null; wait "$WPID" 2>/dev/null
      start_watchdog
      continue
    fi

    kill -TERM "$CPID" 2>/dev/null; sleep 5; kill -KILL "$CPID" 2>/dev/null
    break
  done
  exec 9>&-
fi
wait "$CPID"; RC=$?
kill "$WPID" 2>/dev/null; wait "$WPID" 2>/dev/null
[ -n "$INBOX" ] && rm -f "$INBOX" "$PRIMEF" "${PRIMEF:+$PRIMEF.fed}" "$INBOX.human"
OUT=$(cat "$OUTF" 2>/dev/null); rm -f "$OUTF"
printf '%s\n' "$OUT" >> "$LOGF"

# 실제 세션키와 판정을 응답에서 읽는다. 옛 경로는 응답 전체가 JSON 하나이고,
# stream-json은 JSONL이라 `result` 줄이 판정이다(전체 json.load는 거기서 깨진다).
# 셋째 칸 terminal_reason이 엔진 불능(api_error)과 진짜 세션 실패를 가른다. api_error_status
# 하나로는 못 가른다 - 429가 아닌 네트워크 실패(ENOTFOUND)엔 그 키가 없는데 똑같이 불능이다.
# 다만 그 키가 4xx(408·429 제외)로 **있으면** 그건 요청 자체가 틀렸다는 증거다 - 5분 뒤 같은
# 요청을 다시 보내도 같은 자리에서 같이 죽는다. 그때만 api_error에서 떼어 bad_request로 내려
# 쿨다운을 건너뛴다(2026-08-28: cache_control 5개짜리 400 하나가 큐를 6시간 세웠다 - 만료
# 직전 나간 워커가 또 400을 받아 창을 되감는 고리였다). segment_result의 사본은 안 건드린다 -
# 거기 reason은 재활용 판정에 안 쓰이고 버려진다(호출부 _SEGREASON).
# 넷째 칸은 리밋이 알려준 복귀 시각(epoch). `status: rejected`인 것만 센다 - 같은 이벤트가
# `allowed_warning`으로도 오고(실측 1,058건) 그건 아직 통과한 요청이라 기다릴 이유가 없다.
# reason 판정은 엔진 중립이다(§4-9 §개정 2026-08-05, 승인 04bd819d=(b)) - claude는 그대로
# result.terminal_reason을 읽고, codex(최상위 error 줄)·grok(result.errors, terminal_reason
# 키 없음)은 한도 낱말 셋(usage limit·rate limit·quota) 매치로 같은 api_error에 떨어진다.
# 값을 새로 안 만든다 - 셋 다 "api_error"라 [ "$REASON" = "api_error" ] 게이트는 무수정이다.
VERDICT=$(printf '%s' "$OUT" | python3 -c \
  'import json,sys
LIMIT_WORDS = ("usage limit", "rate limit", "quota")
raw = sys.stdin.read(); sid = ""; ok = ""; reason = ""; reset = ""
for ln in raw.splitlines():
    try: o = json.loads(ln)
    except Exception: continue
    if not isinstance(o, dict): continue
    if o.get("type") == "result":
        sid = o.get("session_id", "") or sid
        ok = "err" if o.get("is_error") else "ok"
        if "terminal_reason" in o:
            reason = o.get("terminal_reason", "") or ""
            st = o.get("api_error_status")
            if reason == "api_error" and isinstance(st, int) and 400 <= st < 500 \
                    and st not in (408, 429):
                reason = "bad_request"
        elif o.get("is_error"):
            errs = " ".join(str(e) for e in (o.get("errors") or [])).lower()
            if any(k in errs for k in LIMIT_WORDS):
                reason = "api_error"
    elif o.get("type") == "rate_limit_event":
        info = o.get("rate_limit_info") or {}
        if info.get("status") == "rejected" and isinstance(info.get("resetsAt"), int):
            reset = str(info["resetsAt"])
    elif o.get("type") == "error":
        msg = str(o.get("message", "")).lower()
        if any(k in msg for k in LIMIT_WORDS):
            reason = "api_error"
if not sid:
    try: sid = json.loads(raw).get("session_id", "")
    except Exception: pass
print("|".join((sid, ok, reason, reset)))' 2>/dev/null)
IFS='|' read -r REAL VERDICT REASON RESET <<< "$VERDICT"

# 스트리밍 입력에서는 우리가 죽여서 끝내므로 RC(143)는 판정이 아니다. `result` 줄이 판정이다.
if [ -n "$INBOX" ]; then
  [ "$VERDICT" = "ok" ] || FAILED=1
else
  [ $RC -ne 0 ] && FAILED=1
fi
if [ -n "${FAILED:-}" ]; then
  # P362-2(§엔진 수정 서른세 번째 승인) - 이 세션 자신의 판정(REASON·VERDICT·RC)에서 사유를
  # 미리 가른다 - reap_release가 runner.log를 다시 파싱하지 않고 그대로 쓴다. api_error(한도)
  # 와 killed(밖에서 끊김 - 선점 포함)는 그 세션의 실패가 아니라 attempts를 안 쓴다. 그 밖은
  # bad_request와 나머지(FAIL·TIMEOUT)로 갈려 각자 다른 예산을 문다(아래 REASON 게이트와
  # 순서가 같다 - api_error 우선, 그다음 bad_request).
  DEATH_KIND="other"
  EL=$((SECONDS - T0))
  if [ "$REASON" = "api_error" ]; then
    DEATH_KIND="api_error"
  elif [ "$REASON" = "bad_request" ]; then
    DEATH_KIND="bad_request"
  elif [ -z "${PN_KILL_FIRED:-}" ] && [ "$VERDICT" != "err" ]; then
    case $RC in
      143|137) [ "$EL" -lt "$TICKET_MAXRUN" ] && DEATH_KIND="killed" ;;
    esac
  fi
  # §판정 2 수용조건 10 - 참견을 무시해 우리가 끊은 세션은 "밖에서 끊김"(killed, attempts
  # 면제)이 아니라 other다. rc는 killed와 똑같이 143/137로 나오므로 위 case로는 못 가르고,
  # 끊은 그 자리(check_plan_kill)가 남긴 PN_KILL_FIRED로 가른다 - DEATH_KIND는 이미
  # "other"(맨 위 기본값)라 여기서 더 할 일이 없다.
  # 실행 실패(또는 상한 초과 강제종료) -> 할당 회수해서 다음 tick이 다시 집도록. 단 세션이
  # 이미 .done으로 닫은 뒤 죽었으면 $TPATH가 없다 - 되돌릴 할당이 없으므로 안 부른다
  # (§4-10 §자리 표 ①, 승인 04bd819d=(b)). 안 부르면 clear의 FileNotFoundError traceback도 안 난다.
  # 존재 여부는 release() 호출 **전에** 한 번만 잰다 - release가 성공하면 그 자체가 파일을
  # 열림 이름으로 rename해 지워버려서, 나중에 다시 재면 정상 케이스도 항상 "없다"로 읽힌다.
  # §4-12 §개정 — 남의 「산」 세션이 물고 있으면 손대지 않는다(그 부모나 TICKET_MAXRUN 감시가
  # 푼다). 죽었으면 종전대로 회수한다. 파일이 없으면 §4-10 ③이지만 무조건 CLOSED=1이 아니다
  # (P360-2) - 남의 리퍼가 부모보다 먼저 가져가도 파일이 똑같이 사라지므로, 해시로 다시 찾아
  # 지금 접미사를 봐야 "세션이 스스로 닫았다"와 "경합에서 졌다"가 갈린다.
  if [ -f "$TPATH" ] && live_other "$TPATH"; then
    OSID=$(sid_of "$TPATH")
    TAIL="할당 회수 안 함 · 지금 claim은 남의 산 세션 것이다(sid=${OSID:0:8})"
  elif [ -f "$TPATH" ]; then
    # P362-2 - reap_release가 이제 성공해도(REAP·ASK) 설명 문자열을 돌려준다(reclaim과 같은
    # 관례) - 빈 문자열만 성공으로 읽던 종전 게이트를 접두어로 가른다. REAP-FAIL만 진짜 실패다.
    OUT=$(reap_silent "$TPATH" "$DEATH_KIND")
    case "$OUT" in
      REAP-FAIL*)
        log "$OUT"
        TAIL="할당 회수 실패 - .wip 그대로(REAP-FAIL 참고)"
        ;;
      ASK*)
        log "$OUT"
        TAIL="할당 회수 + 답변 대기로 전환"
        ;;
      *)
        [ -n "$OUT" ] && log "$OUT"
        TAIL="할당 회수 + 백로그 복귀"
        ;;
    esac
  else
    DONE_SUFFIX="${TICKET_DONE:-.done}.md"     # 티켓 파일은 항상 `.md`로 끝난다
    if RP=$(python3 "$PY" find "$TICKET_ROOT" "$THASH" 2>/dev/null); then
      case "$RP" in
        *"$DONE_SUFFIX") CLOSED=1 ;;
        *) TAIL="할당 회수 안 함 · 리퍼가 먼저 가져갔다(경합 패배, P360-2)" ;;
      esac
    else
      TAIL="할당 회수 안 함 · 원본을 다시 못 찾음(P360-2)"
    fi
  fi
  # 엔진 불능이면 창을 건다. 티켓은 종전대로 백로그로 돌아가고, 다음 tick들이 게이트에서 멈춘다.
  # 리밋이 복귀 시각을 줬으면(실측 api_error의 80%, 앞으로 최대 4.2시간) 임의의 5분이 아니라
  # 그 시각까지 기다린다. 안 줬거나 이미 지난 값이면 300초로 떨어진다(실측 min이 -355초다).
  # 티켓이 닫혔든 말든 엔진이 불능인지 여부와는 무관하다 - 위 가드 밖에 그대로 둔다.
  if [ "$REASON" = "api_error" ]; then
    NOW=$(date +%s); UNTIL=$(( NOW + CDOWN_W )); KNOWN=0
    case "$RESET" in ''|*[!0-9]*) ;; *) KNOWN=1; [ "$RESET" -gt "$UNTIL" ] && UNTIL="$RESET" ;; esac
    arm_cdown "$UNTIL" "$KNOWN"
    log "NOTE 엔진 불능 - $((UNTIL - NOW))초 쿨다운(복귀 ${RESET:-미상})"
  elif [ "$REASON" = "bad_request" ]; then
    # 엔진은 멀쩡하고 우리가 보낸 요청이 틀렸다 - 창을 걸어 봐야 다음 워커가 같은 요청을 다시
    # 보낼 뿐이다. 창 없이 평범한 FAIL로 떨어뜨려 다른 티켓·다른 엔진은 계속 돌게 둔다.
    log "NOTE $THASH 요청 오류 - 쿨다운 없음(재시도해도 같은 자리에서 죽는다)"
  fi
  if [ -n "${CLOSED:-}" ]; then
    # 세션이 끝까지 수행하고 .done rename까지 자기 손으로 마친 뒤 죽었다 - 큐의 사실은 완료다.
    # FAIL이 아니라 §0-5 판정 1 화이트리스트에 이미 있는 DONE을 재사용해 사유만 붙인다.
    log "DONE $THASH sid=${REAL:-$SID} (세션은 rc=${RC}로 죽었다)"
    exit 0
  fi
  if [ "$VERDICT" = "err" ]; then
    # P400-1(§엔진 수정 서른여섯 번째 승인 §판정 1) - 위에서 이미 가른 DEATH_KIND를 그 줄에
    # 같이 적는다. `dead_reason`이 NOTE 상관 추정 없이 이 값을 바로 읽는다. 머리말은 그대로
    # FAIL이다 - 갈리는 것은 문장 안의 사유 한 칸뿐이다.
    log "FAIL $THASH 세션이 result is_error로 끝났다 reason=$DEATH_KIND -> $TAIL. 로그 $(basename "$LOGF")"
  else
    case $RC in
      143|137)
        EL=$((SECONDS - T0))
        if [ "$EL" -lt "$TICKET_MAXRUN" ]; then
          log "KILLED $THASH ${EL}s 만에 밖에서 종료(rc=$RC) -> $TAIL. 로그 $(basename "$LOGF")"
        else
          log "TIMEOUT $THASH ${TICKET_MAXRUN}s 초과 강제종료 -> $TAIL. 로그 $(basename "$LOGF")"
        fi ;;
      *)       log "FAIL $THASH rc=$RC -> $TAIL. 로그 $(basename "$LOGF")" ;;
    esac
  fi
  [ $RC -eq 0 ] && RC=1
  exit $RC
fi

# 같은 가정이다 - 정상 종료한 세션도 이미 티켓을 .done으로 닫았을 수 있다(§자리 표 ④).
# 여기는 회수가 아니라 남의 .wip에 내 세션키를 덮어쓰는 자리다 - owns로 「내 것」만 정정한다
# (§4-12 §개정, live_other가 아니라 owns를 쓰는 유일한 칸).
if [ -n "$REAL" ] && [ "$REAL" != "$SID" ] && owns "$TPATH"; then
  python3 "$PY" assign "$TPATH" "$REAL"
  log "NOTE $THASH 세션키 정정 $SID -> $REAL"
fi
rm -f "$CDOWN"          # 세션이 끝까지 갔다 = 엔진이 멀쩡하다. 창이 남아 있으면 여기서 푼다.
# 엔진 수정 서른네 번째 승인 §판정 2 - `result ok`가 곧 완료를 뜻하지 않는다. 티켓이 아직
# `.wip`이면 신선한 `## 블록`이 있는 경우만 종전대로 DONE이고, 그 밖은 턴을 닫고 죽은 것과
# 다르지 않다 - FAIL로 남긴다(새 로그 낱말 0, §0-5 판정 1 화이트리스트를 그대로 재사용).
# 종료코드는 안 건드린다 - 이 승인이 뒤집는 것은 로그 낱말 하나지 세션 종료 판정 자체가 아니다.
# P435 결정 2 - 이 run에서 밀린 백그라운드 작업을 한 번이라도 봤으면(BG_GRACE_USED>0)
# reason=bg를 단다. `dead_reason`이 이 값을 "백그라운드 중단"으로 갈라 `reclaim`을 답변
# 대기가 아니라 백오프로 보낸다 - 밀림이 없던 세션의 FAIL 줄은 그대로다.
if [ -f "$TPATH" ] && ! fresh_block_sh "$TPATH"; then
  if [ "${BG_GRACE_USED:-0}" -gt 0 ]; then
    log "FAIL $THASH 세션이 ok로 끝났는데 .wip을 남겼다(신선한 블록 없음) reason=bg sid=${REAL:-$SID}"
  else
    log "FAIL $THASH 세션이 ok로 끝났는데 .wip을 남겼다(신선한 블록 없음) sid=${REAL:-$SID}"
  fi
  exit 0
fi
# 엔진 수정 서른일곱 번째 승인 §판정 2 - `.wip`이 이미 없으면(위 갈래를 지나 여기 왔으니
# `.done`으로 닫힌 것이다) 계획 상자까지 본다. `plan_needs_nudge`는 파일 하나를 받아 그
# 안의 `## 진행 계획` 절에서 완료도 취소도 아닌 항목을 찾는 함수라 접미사를 안 가린다 -
# 판정 1 조건 2와 같은 함수 하나를 그대로 재사용한다(수용조건 5). 되돌리기는 `reap_silent`
# (엔진 `reap_release`)를 사유 `plan`으로 부른다 - 새 서브커맨드를 안 더한다(수용조건 13).
if [ ! -f "$TPATH" ]; then
  DONE_SUFFIX="${TICKET_DONE:-.done}.md"
  if RP=$(python3 "$PY" find "$TICKET_ROOT" "$THASH" 2>/dev/null); then
    case "$RP" in
      *"$DONE_SUFFIX")
        if plan_needs_nudge "$RP"; then
          OUT=$(reap_silent "$RP" "plan")
          log "FAIL $THASH 세션이 계획 상자를 안 켠 채 .done으로 닫았다 -> $OUT"
          exit 0
        fi
        ;;
    esac
  fi
fi
log "DONE $THASH sid=${REAL:-$SID}"
exit 0