Manifest

# --- /manifest: collect in-flight work from the remote (read-only) ---

# Must be a git repo; otherwise degrade quietly and exit 0 (BR-6/BR-7 — never hard-fail).
git rev-parse --git-dir >/dev/null 2>&1 || { echo "/manifest: not a git repository — nothing to derive" >&2; exit 0; }

# Helpers — defined AND invoked within THIS one fenced block (shell state does not cross
# fences; LESSON-020). with_timeout bounds a network call (BR-14e), portably no-op when no
# timeout binary exists. emit_field strips both quote styles (\047 = single quote), CR, and
# trailing space. clean_field neutralizes untrusted render values to a safe display charset
# and caps length, so a hostile spec/PR field cannot inject into the rendered manifest or
# the agent's context (LESSON-008 item #3).
with_timeout() {
  if command -v timeout >/dev/null 2>&1; then timeout 20 "$@"
  elif command -v gtimeout >/dev/null 2>&1; then gtimeout 20 "$@"
  else "$@"; fi
}
# NOTE: bare $<digit> (shell positionals AND awk fields) is clobbered by Skill
# argument templating before this block ever reaches a shell — always write the
# brace/paren forms ${1} (shell) and $(1)/$(0) (awk) inside this file.
emit_field() { awk -v k="${1}" 'index($(0),k)==1{sub(/^[^:]*:[[:space:]]*/,"");gsub(/[\047"\r]/,"");sub(/[[:space:]]+$/,"");print;exit}'; }
clean_field() { printf '%s' "${1}" | tr -c 'A-Za-z0-9 ._/:-' ' ' | cut -c1-60; }

# Forge adapter: open-PR derivation routes through pr_list/pr_view (REQ-520 BR-8)
# instead of direct gh. Sourced in THIS fence (shell state does not cross fences).
# The GitHub backend forwards args verbatim, so the existing --json/--jq pipelines
# below stay byte-identical (BR-3); the branch-only ls-remote fallback (Step 2b)
# is pure git and unchanged (BR-8).
if [ -f .adlc/partials/forge.sh ]; then . .adlc/partials/forge.sh; else . ~/.claude/skills/partials/forge.sh; fi

TAB=$(printf '\t')
raw=$(mktemp "${TMPDIR:-/tmp}/manifest.XXXXXX") || { echo "/manifest: mktemp failed — skipping manifest" >&2; exit 0; }
trap 'rm -f "$raw"' EXIT

# Step 1 — sync ONCE. Pre-flight callers already fetched and pass MANIFEST_SKIP_FETCH=1.
if [ "${MANIFEST_SKIP_FETCH:-0}" != "1" ]; then
  with_timeout git fetch origin --quiet 2>/dev/null || echo "/manifest: fetch skipped/timed out — using cached remote refs" >&2
fi

# Self REQ id(s), NEWLINE-separated for portable iteration (no unquoted word-splitting,
# which zsh does not do). self_disp is the space-joined form for the header line.
self_nl=$(printf '%s' "${ARGUMENTS:-${MANIFEST_SELF:-}}" | grep -oE 'REQ-[0-9]{3,6}' | sort -u)
if [ -z "$self_nl" ]; then
  self_nl=$(git rev-parse --abbrev-ref HEAD 2>/dev/null | grep -oE 'REQ-[0-9]{3,6}')
fi
self_disp=$(printf '%s' "$self_nl" | tr '\n' ' ' | sed 's/[[:space:]]*$//')

gh_ok=0
if command -v gh >/dev/null 2>&1 && gh auth status >/dev/null 2>&1; then gh_ok=1; fi

# Step 2a — open PRs (one batched, bounded call; includes drafts). grep both extracts AND
# validates the REQ id (BR-5); non-matching branches are ignored (BR-4).
if [ "$gh_ok" = "1" ]; then
  with_timeout adlc_forge_pr_list --state open --limit 200 \
    --json headRefName,author,isDraft,createdAt,url \
    --jq '.[] | [.headRefName, (.author.login // "unknown"), (if .isDraft then "draft" else "ready" end), .createdAt, .url] | @tsv' \
    2>/dev/null | while IFS="$TAB" read -r branch author state created url; do
      req=$(printf '%s' "$branch" | grep -oE '^feat/REQ-[0-9]{3,6}-' | grep -oE 'REQ-[0-9]{3,6}')
      [ -n "$req" ] || continue
      printf '%s\t%s\t%s\t%s\t%s\t%s\n' "$req" "$branch" "$state" "$author" "$created" "$url"
    done >> "$raw"
fi

# Step 2b — pushed feat/REQ-* branches with no PR (local read; dedup by REQ id, PR wins).
git branch -r --list 'origin/feat/REQ-*' 2>/dev/null | sed 's#^[ *]*origin/##' | while read -r branch; do
  req=$(printf '%s' "$branch" | grep -oE '^feat/REQ-[0-9]{3,6}-' | grep -oE 'REQ-[0-9]{3,6}')
  [ -n "$req" ] || continue
  if cut -f1 "$raw" 2>/dev/null | grep -qxF "$req"; then continue; fi
  printf '%s\t%s\t%s\t%s\t%s\t%s\n' "$req" "$branch" "no-pr" "-" "-" "-"
done >> "$raw"

# Step 2c — synthesize a row per self REQ not yet present (BR-13). At /proceed Step 0 the
# REQ has no remote PR/branch yet, so self must be added from local state.
cur_branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
printf '%s\n' "$self_nl" | while read -r sr; do
  [ -n "$sr" ] || continue
  if cut -f1 "$raw" 2>/dev/null | grep -qxF "$sr"; then continue; fi
  sb="-"
  case "$cur_branch" in *"$sr"*) sb="$cur_branch" ;; esac
  printf '%s\t%s\t%s\t%s\t%s\t%s\n' "$sr" "$sb" "local" "-" "-" "-"
done >> "$raw"

# Step 3 — enrich component/domain PER FIELD (local -> remote -> unknown). The branch is
# charset-validated before any git show (BR-5, ADR-6, LESSON-008); a branch failing the
# check is still rendered (sanitized) but never used in a git command.
echo "MANIFEST_BEGIN self=${self_disp:-none} gh=${gh_ok}"
while IFS="$TAB" read -r req branch state author created url; do
  comp=""
  dom=""
  # find, not an ls glob: zsh errors on unmatched globs ("no matches found") instead of
  # passing the pattern through, so a glob here breaks sh/bash/zsh parity (BR-10).
  loc=$(find .adlc/specs -type f -path "*/${req}-*/requirement.md" 2>/dev/null | sort | head -1)
  if [ -n "$loc" ]; then
    comp=$(emit_field "component:" < "$loc")
    dom=$(emit_field "domain:" < "$loc")
  fi
  if [ -z "$comp" ] || [ -z "$dom" ]; then
    if printf '%s' "$branch" | grep -qE '^feat/REQ-[0-9]{3,6}-[A-Za-z0-9._-]+$'; then
      sp=$(git ls-tree -r --name-only "origin/$branch" 2>/dev/null | grep -E "^\.adlc/specs/$req-[A-Za-z0-9._-]+/requirement\.md$" | head -1)
      if [ -n "$sp" ]; then
        spec=$(git show "origin/$branch:$sp" 2>/dev/null)
        [ -n "$comp" ] || comp=$(printf '%s\n' "$spec" | emit_field "component:")
        [ -n "$dom" ] || dom=$(printf '%s\n' "$spec" | emit_field "domain:")
      fi
    fi
  fi
  [ -n "$comp" ] || comp="unknown"
  [ -n "$dom" ] || dom="unknown"
  printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' "$req" "$(clean_field "$branch")" "$state" "$(clean_field "$author")" "$created" "$(clean_field "$comp")" "$(clean_field "$dom")" "$url"
done < "$raw" | sort -t"$TAB" -k1,1 -u
echo "MANIFEST_END"
[ "$gh_ok" = "1" ] || echo "/manifest: gh unavailable — PR fields shown as '-'; branch-only view (BR-6)." >&2

# --- REQ-483: deterministic merge order + footprints (from PR bodies) ---
# Merge order: PR-backed REQs sorted by opened (createdAt) then REQ id (BR-8, lock-free).
echo "ORDER_BEGIN"
awk -F"$TAB" '$(5) != "-" { n=$(1); sub(/^REQ-/,"",n); print $(5) "\t" (n+0) "\t" $(1) }' "$raw" 2>/dev/null | sort -t"$TAB" -k1,1 -k2,2n | awk -F"$TAB" '{ print NR "\t" $(3) "\t" $(1) }'
echo "ORDER_END"
# Footprints: parse the fenced adlc-footprint block from each in-flight PR body.
# tick = three backticks via octal, so no literal fence appears inside this sh fence.
# Footprint paths are UNTRUSTED: reject any '..' segment + non-safe charset before use (BR-13, LESSON-008).
tick=$(printf '\140\140\140')
echo "FOOTPRINT_BEGIN"
if [ "$gh_ok" = "1" ]; then
  while IFS="$TAB" read -r f_req f_branch f_state f_author f_created f_url; do
    num=$(printf '%s' "$f_url" | grep -oE '[0-9]+$')
    [ -n "$num" ] || continue
    body=$(with_timeout adlc_forge_pr_view "$num" --json body -q .body 2>/dev/null)
    [ -n "$body" ] || continue
    printf '%s\n' "$body" | sed -n "/^${tick}adlc-footprint/,/^${tick}/{ /^${tick}/d; p; }" | while IFS= read -r fpline; do
      [ -n "$fpline" ] || continue
      case "$fpline" in *:*) fp_repo=${fpline%%:*}; fp=${fpline#*:} ;; *) fp_repo=""; fp=$fpline ;; esac
      case "$fp" in *..*) continue ;; esac
      printf '%s' "$fp" | grep -qE '^[A-Za-z0-9_./*-]+$' || continue
      printf '%s' "$fp_repo" | grep -qE '^[A-Za-z0-9_.-]*$' || fp_repo="?"
      m=$(git ls-files -- "$fp" 2>/dev/null)
      if [ -n "$m" ]; then
        printf '%s\n' "$m" | while IFS= read -r mm; do printf '%s\t%s\t%s\n' "$f_req" "$fp_repo" "$mm"; done
      else
        printf '%s\t%s\t%s\n' "$f_req" "$fp_repo" "$fp"
      fi
    done
  done < "$raw"
fi
echo "FOOTPRINT_END"

# --- REQ-483: stale-blocker detection (BR-11). One batched pr_list call. ---
echo "STALE_BEGIN"
if [ "$gh_ok" = "1" ]; then
  stale_n=7
  if [ -f .adlc/config.yml ]; then
    cfg_n=$(grep -oE '^[[:space:]]*stale_days:[[:space:]]*[0-9]+' .adlc/config.yml 2>/dev/null | grep -oE '[0-9]+$' | head -1)
    [ -n "$cfg_n" ] && stale_n="$cfg_n"
  fi
  cutoff=$(date -u -v-"${stale_n}"d +%Y-%m-%d 2>/dev/null || date -u -d "${stale_n} days ago" +%Y-%m-%d 2>/dev/null)
  if [ -n "$cutoff" ]; then
    with_timeout adlc_forge_pr_list --state open --limit 200 --json headRefName,updatedAt \
      --jq '.[] | [.headRefName, .updatedAt] | @tsv' 2>/dev/null | while IFS="$TAB" read -r s_branch s_upd; do
        s_req=$(printf '%s' "$s_branch" | grep -oE '^feat/REQ-[0-9]{3,6}-' | grep -oE 'REQ-[0-9]{3,6}')
        [ -n "$s_req" ] || continue
        s_day=$(printf '%s' "$s_upd" | cut -c1-10)
        [ -n "$s_day" ] || continue
        if awk -v a="$s_day" -v b="$cutoff" 'BEGIN{ exit !(a < b) }'; then
          printf '%s\t%s\n' "$s_req" "$s_day"
        fi
      done
  fi
fi
echo "STALE_END"