@techgoblin/gobstack 0.4.4-beta.6 → 0.4.4-beta.7

package/bin/goblin-init

@@ -5,10 +5,13 @@
 #               [--branch <name>] [--email <addr>] [--gate <cmd>]
 #               [--emit <p[,p..]>] [--scope project|global] [--yes] [--dry-run]
 #
-# One screen per question, answered steps collapsing into the ✔/◆/○ rail above. Every
-# question has a flag: with the flags set (or --yes, or a non-tty stdin) the wizard asks
-# nothing and runs from the flags and the defaults — non-interactive parity is structural,
-# not a mode. Over a pipe the ANSI redraw degrades to a numbered cascade (rustup shape).
+# One screen per question, answered steps collapsing into the ✔/◆/○ rail above. On a tty
+# the whole wizard frame (logotype, header, answered rows, rail) is redrawn in place from
+# a saved buffer of the wizard's own lines — never by counting printed output, which the
+# installer/emit engines would break. Every question has a flag: with the flags set (or
+# --yes, or a non-tty stdin) the wizard asks nothing and runs from the flags and the
+# defaults — non-interactive parity is structural, not a mode. Over a pipe the redraw
+# degrades to a numbered cascade (rustup shape) with zero cursor motion.
 #
 # The wizard is a FRONT END over the existing engines, never a second installer:
 #   .goblin/ + the payload   -> bin/goblin-install  (its refusal contract — an existing
@@ -47,9 +50,11 @@ VERSION=$(cat "$SRC/VERSION" 2>/dev/null || printf 'unknown')
 # nearest 16-colour slot. NO_COLOR or a piped stdout turns colour off entirely.
 TTY_OUT=0; [ -t 1 ] && TTY_OUT=1
 TTY_IN=0;  [ -t 0 ] && TTY_IN=1
-C_ACCENT="" C_GREEN="" C_TEXT="" C_MUTED="" C_DIM="" C_RED="" C_YELLOW="" C_RESET="" C_BOLD=""
+C_ACCENT="" C_GREEN="" C_TEXT="" C_MUTED="" C_DIM="" C_RED="" C_YELLOW="" C_RESET=""
+# Single-accent discipline: one accent (#F54E00) + green + text + muted + dim. No bold
+# is ever emitted — bold was a second emphasis voice and is gone from every screen.
 if [ "$TTY_OUT" -eq 1 ] && [ -z "${NO_COLOR:-}" ]; then
-  C_RESET=$'\033[0m'; C_BOLD=$'\033[1m'
+  C_RESET=$'\033[0m'
   case "${COLORTERM:-}" in
     truecolor|24bit)
       C_ACCENT=$'\033[38;2;245;78;0m'; C_GREEN=$'\033[38;2;74;222;128m'
@@ -64,41 +69,64 @@ if [ "$TTY_OUT" -eq 1 ] && [ -z "${NO_COLOR:-}" ]; then
 fi
 
 # ---------------------------------------------------------------- the rail ----
-# 6 steps; the ✔/◆/○ vocabulary. The rail is redrawn in place on a tty (cursor-up +
-# clear-below, no library); over a pipe each screen degrades to one numbered line.
+# 6 steps; the ✔/◆/○ vocabulary. The rail is redrawn in place on a tty from a SAVED
+# BUFFER of the wizard's own lines (RAIL_BUF) — never by counting the output between
+# draws, because the installer/emit engines print freely and break naive accounting.
+# Over a pipe nothing is saved and nothing rewinds: each screen is one numbered line.
 STEP_LABELS=("platforms" "class" "branch/email" "first gate" "emit" "done")
 STEP_VAL=("" "" "" "" "" "")
-RAIL_LINES=0
-Q_LINES=0
 CURRENT=1
 
-q() { # one printed line of the current screen (counted so the redraw can rewind it)
+# rail_say: one line of wizard output on a tty — stored in the redraw buffer AND
+# printed with a VT100 clear-line prefix (the redraw may overwrite a longer old line).
+# Over a pipe this is exactly printf '%s\n' and nothing is stored.
+rail_say() {
+  if [ "$TTY_OUT" -eq 1 ]; then
+    RAIL_BUF+=("$*")
+    printf '\033[2K%s\n' "$*"
+  else
+    printf '%s\n' "$*"
+  fi
+}
+# rail_seed: the pre-draw frame (logo + header). On a tty it only FILLS the buffer —
+# rail_draw prints it; over a pipe nothing is buffered and it prints directly.
+rail_seed() {
+  if [ "$TTY_OUT" -eq 1 ]; then
+    RAIL_BUF+=("$*")
+  else
+    printf '%s\n' "$*"
+  fi
+}
+# rail_note: a line that prints now but never joins the redraw buffer (engine output,
+# transcripts, the verify echo): the next redraw wipes it with its clear-below.
+rail_note() {
   printf '%s\n' "$*"
-  Q_LINES=$((Q_LINES + 1))
 }
 rail_rewind() {
-  if [ "$TTY_OUT" -eq 1 ] && [ $((RAIL_LINES + Q_LINES)) -gt 0 ]; then
-    printf '\033[%dA\033[J' "$((RAIL_LINES + Q_LINES))"
+  if [ "$TTY_OUT" -eq 1 ]; then
+    printf '\033[%dA\033[J' "${#RAIL_BUF[@]}"
   fi
-  RAIL_LINES=0; Q_LINES=0
 }
-rail_print() { # the summary column: ✔ answered (with its value) · ◆ asking · ○ pending
-  local i glyph col label
+rail_draw() { # reprint the saved buffer, then the live rail row for $CURRENT
+  local i line glyph col label
+  if [ "$TTY_OUT" -eq 0 ]; then return 0; fi
+  for line in "${RAIL_BUF[@]}"; do
+    printf '\033[2K%s\n' "$line"
+  done
   for i in 1 2 3 4 5 6; do
     label="${STEP_LABELS[$((i - 1))]}"
     if [ "$i" -lt "$CURRENT" ]; then
-      printf '  %s✔%s %d. %-13s%s%s%s\n' "$C_GREEN" "$C_RESET" "$i" "$label" "$C_TEXT" "${STEP_VAL[$((i - 1))]}" "$C_RESET"
+      glyph="✔"; col="$C_GREEN"
     elif [ "$i" -eq "$CURRENT" ]; then
-      printf '  %s◆%s %d. %-13s' "$C_ACCENT" "$C_RESET" "$i" "$label"
-      RAIL_LINES=$((RAIL_LINES + 1))
-      return 0   # the asking row is printed by the screen itself, after its question
+      glyph="◆"; col="$C_ACCENT"
     else
-      printf '  %s○%s %d. %-13s\n' "$C_DIM" "$C_RESET" "$i" "$label"
+      glyph="○"; col="$C_DIM"
     fi
-    RAIL_LINES=$((RAIL_LINES + 1))
+    printf '\033[2K  %s%s %d. %-13s%s%s%s\n' "${col}${glyph}" "$C_RESET" "$i" "$label" "$C_TEXT" "${STEP_VAL[$((i - 1))]}" "$C_RESET"
   done
 }
-cascade() { # the pipe-degraded shape: one numbered line per screen
+rail_reset() { RAIL_BUF=(); }
+cascade() { # the pipe-degraded shape: one numbered line per screen (zero cursor motion)
   printf 'gob init [%d/6] %s\n' "$CURRENT" "$1"
 }
 
@@ -108,7 +136,7 @@ ask_value() {
   if [ "$TTY_IN" -eq 0 ]; then REPLY="$dflt"; return 0; fi
   printf '      %s%s%s %s─ %s' "$C_TEXT" "$label" "$C_RESET" "$C_DIM" "$dflt"
   read -r REPLY
-  printf '\n'; Q_LINES=$((Q_LINES + 1))
+  rail_say ""
   [ -n "$REPLY" ] || REPLY="$dflt"
   return 0
 }
@@ -146,18 +174,25 @@ TARGET=$(g_expand_tilde "$TARGET")
 TARGET=$(cd "$TARGET" && pwd)
 
 # ------------------------------------------------------------ screen 1: welcome
-printf '%s\n' "${C_ACCENT}▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █${C_RESET}"
-printf '%s\n' "${C_ACCENT}█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █${C_RESET}"
-printf '%s\n' "${C_ACCENT}█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██${C_RESET}"
-printf '%s\n' "${C_ACCENT}▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █${C_RESET}"
-printf '%s\n' "${C_DIM}     discipline around whatever executes${C_RESET}"
-printf '\n'
-printf '%s\n' "${C_TEXT}  gob init${C_RESET} ${C_MUTED}— first-run setup (gobstack v$VERSION)${C_RESET}"
-printf '%s\n' "  ${C_MUTED}6 steps · every step has a flag · nothing is written until the plan is confirmed${C_RESET}"
-printf '\n'
+# The logotype and the header ride the redraw buffer (rail_say): every later screen
+# redraws logo + header + rail as one stable frame. Over a pipe rail_say is plain
+# printf and nothing is buffered — the cascade keeps zero cursor motion.
 CURRENT=1
-if [ "$TTY_OUT" -eq 1 ]; then rail_print
-else cascade "welcome: gobstack v$VERSION — the guided first run"; fi
+rail_reset
+rail_seed "${C_ACCENT}▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █${C_RESET}"
+rail_seed "${C_ACCENT}█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █${C_RESET}"
+rail_seed "${C_ACCENT}█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██${C_RESET}"
+rail_seed "${C_ACCENT}▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █${C_RESET}"
+rail_seed "     ${C_MUTED}discipline around whatever executes${C_RESET}"
+rail_seed ""
+rail_seed "${C_TEXT}  gob init${C_RESET} ${C_MUTED}— first-run setup (gobstack v$VERSION)${C_RESET}"
+rail_seed "  ${C_MUTED}6 steps · every step has a flag · nothing is written until the plan is confirmed${C_RESET}"
+rail_seed ""
+if [ "$TTY_OUT" -eq 1 ]; then
+  rail_draw
+else
+  cascade "welcome: gobstack v$VERSION — the guided first run"
+fi
 
 # Platform enum assembled from fragments (the MD_SLUG precedent): a literal tool name in
 # bin/ trips MD-01's model-name pattern, and run-tests.sh greps this directory.
@@ -170,7 +205,7 @@ PLATFORMS="$PLA hermes copilot cursor opencode codex $GEM"
 # ---------------------------------------------------------- screen 2: detect --
 CURRENT=2
 rail_rewind
-if [ "$TTY_OUT" -eq 1 ]; then rail_print; fi
+if [ "$TTY_OUT" -eq 1 ]; then rail_draw; fi
 DET_ROWS=""
 DET_N=0
 for p in $PLATFORMS; do
@@ -194,19 +229,17 @@ for p in $PLATFORMS; do
     DET_N=$((DET_N + 1))
   fi
 done
-STEP_VAL[0]="  $C_DIM$DET_N detected$C_RESET"
+STEP_VAL[0]="$C_DIM$DET_N detected$C_RESET"
 if [ "$TTY_OUT" -eq 1 ]; then
-  printf '  %s✔%s %d. %-13s%s%s%s\n' "$C_GREEN" "$C_RESET" 2 "platforms" "$C_TEXT" "$DET_N detected" "$C_RESET"
-  RAIL_LINES=$((RAIL_LINES + 1))
+  rail_say ""
+  rail_say "  ✔ 1. platforms      $C_TEXT$DET_N detected$C_RESET"
   if [ "$DET_N" -eq 0 ]; then
-    printf '      %sno platform detected here — the wizard will still install the harness; emit later with gob emit%s\n' "$C_YELLOW" "$C_RESET"
-    RAIL_LINES=$((RAIL_LINES + 1))
+    rail_say "      ${C_YELLOW}no platform detected here — the wizard will still install the harness; emit later with gob emit$C_RESET"
   else
     while IFS=$'\t' read -r p proj glob hit; do
       [ -n "$p" ] || continue
       case "$glob" in "~"*) glob="${glob/\~/$HOME}" ;; esac
-      printf '      %s✔%s %-9s %s %s(%s)%s\n' "$C_GREEN" "$C_RESET" "$p" "$glob" "$C_DIM" "$hit" "$C_RESET"
-      RAIL_LINES=$((RAIL_LINES + 1))
+      rail_say "      $C_GREEN✔$C_RESET $C_TEXT$p$C_RESET $glob $C_DIM($hit)$C_RESET"
     done <<< "$DET_ROWS"
   fi
 else
@@ -216,23 +249,23 @@ fi
 # ------------------------------------------------------------ screen 3: class -
 CURRENT=3
 rail_rewind
-if [ "$TTY_OUT" -eq 1 ]; then rail_print; fi
+if [ "$TTY_OUT" -eq 1 ]; then rail_draw; fi
 CLASS_DEFAULT=1
 if [ -z "$CLASS" ]; then
   if [ "$TTY_IN" -eq 1 ]; then
-    q ""
-    q "      ${C_MUTED}what kind of work does this repo do?$C_RESET"
-    q "      $C_TEXT  1 ▸ app        shipped features, PRs, review gates        ${C_DIM}(class A)$C_RESET"
-    q "      $C_TEXT  2   service    backend jobs, config, unattended runs      ${C_DIM}(class B)$C_RESET"
-    q "      $C_TEXT  3   game       playable builds, perf budgets              ${C_DIM}(class C)$C_RESET"
-    q "      $C_TEXT  4   research   specs, replays, reference corpora          ${C_DIM}(class D)$C_RESET"
-    q "      $C_TEXT  5   agent      fleets, loops, unattended automation       ${C_DIM}(class E)$C_RESET"
-    q "      $C_TEXT  6   desktop    the shell you live in, perf budget         ${C_DIM}(class F)$C_RESET"
-    q "      ${C_MUTED}↑ number + Enter · Enter = app · the class letter works too (A-F)$C_RESET"
+    rail_say ""
+    rail_say "      ${C_MUTED}what kind of work does this repo do?$C_RESET"
+    rail_say "      $C_TEXT  1 ▸ app        shipped features, PRs, review gates        ${C_DIM}(class A)$C_RESET"
+    rail_say "      $C_TEXT  2   service    backend jobs, config, unattended runs      ${C_DIM}(class B)$C_RESET"
+    rail_say "      $C_TEXT  3   game       playable builds, perf budgets              ${C_DIM}(class C)$C_RESET"
+    rail_say "      $C_TEXT  4   research   specs, replays, reference corpora          ${C_DIM}(class D)$C_RESET"
+    rail_say "      $C_TEXT  5   agent      fleets, loops, unattended automation       ${C_DIM}(class E)$C_RESET"
+    rail_say "      $C_TEXT  6   desktop    the shell you live in, perf budget         ${C_DIM}(class F)$C_RESET"
+    rail_say "      ${C_MUTED}↑ number + Enter · Enter = app · the class letter works too (A-F)$C_RESET"
     printf '      '
     read -r REPLY_CLASS
     ASKED_ANY=1
-    printf '\n'; Q_LINES=$((Q_LINES + 1))
+    rail_say ""
   else
     REPLY_CLASS="1"
     cascade "class: app (default; --class app|service|game|research|agent|desktop or A-F)"
@@ -258,10 +291,9 @@ case "$CLASS" in
     exit 2 ;;
 esac
 CLASS_NAME=$(ls "$SRC"/presets/"$CLASS"-*.yaml 2>/dev/null | head -n 1)
-STEP_VAL[1]="  $C_TEXT$CLASS ($([ -n "$CLASS_NAME" ] && basename "$CLASS_NAME" .yaml | cut -d- -f2-))$C_RESET"
+STEP_VAL[1]="$C_TEXT$CLASS ($([ -n "$CLASS_NAME" ] && basename "$CLASS_NAME" .yaml | cut -d- -f2-))$C_RESET"
 if [ "$TTY_OUT" -eq 1 ]; then
-  printf '  %s✔%s %d. %-13s%s%s%s\n' "$C_GREEN" "$C_RESET" 3 "class" "$C_TEXT" "$CLASS$([ -n "$CLASS_NAME" ] && printf ' — %s' "$(basename "$CLASS_NAME" .yaml | cut -d- -f2-)")$C_RESET"
-  RAIL_LINES=$((RAIL_LINES + 1))
+  rail_say "  ✔ $((CURRENT - 1)). class            $C_TEXT$CLASS$([ -n "$CLASS_NAME" ] && printf ' — %s' "$(basename "$CLASS_NAME" .yaml | cut -d- -f2-)")$C_RESET"
 else
   cascade "class: $CLASS"
 fi
@@ -269,15 +301,15 @@ fi
 # ----------------------------------------------------- screen 4: branch/email --
 CURRENT=4
 rail_rewind
-if [ "$TTY_OUT" -eq 1 ]; then rail_print; fi
+if [ "$TTY_OUT" -eq 1 ]; then rail_draw; fi
 DEF_BRANCH=$( cd "$TARGET" && git rev-parse --abbrev-ref HEAD 2>/dev/null )
 case "$DEF_BRANCH" in ""|HEAD) DEF_BRANCH=main ;; esac
 DEF_EMAIL=$( cd "$TARGET" && git config user.email 2>/dev/null )
 [ -n "$DEF_EMAIL" ] || DEF_EMAIL="you@example.com"
 if [ -z "$BRANCH" ] || [ -z "$EMAIL" ]; then
   if [ "$TTY_IN" -eq 1 ]; then
-    q ""
-    q "      ${C_MUTED}the forge contract — the identity this repo commits with (CM-01)$C_RESET"
+    rail_say ""
+    rail_say "      ${C_MUTED}the forge contract — the identity this repo commits with (CM-01)$C_RESET"
     ask_value "default branch" "$DEF_BRANCH"; BRANCH="${BRANCH:-$REPLY}"
     ask_value "owner email" "$DEF_EMAIL"; EMAIL="${EMAIL:-$REPLY}"
   else
@@ -288,29 +320,27 @@ if [ -z "$BRANCH" ] || [ -z "$EMAIL" ]; then
 fi
 BRANCH="${BRANCH:-$DEF_BRANCH}"
 EMAIL="${EMAIL:-$DEF_EMAIL}"
-STEP_VAL[2]="  $C_TEXT$BRANCH · $EMAIL$C_RESET"
+STEP_VAL[2]="$C_TEXT$BRANCH · $EMAIL$C_RESET"
 if [ "$TTY_OUT" -eq 1 ]; then
-  printf '  %s✔%s %d. %-13s%s%s · %s%s\n' "$C_GREEN" "$C_RESET" 4 "branch/email" "$C_TEXT" "$BRANCH" "$EMAIL" "$C_RESET"
-  RAIL_LINES=$((RAIL_LINES + 1))
+  rail_say "  ✔ $((CURRENT - 1)). branch/email   $C_TEXT$BRANCH · $EMAIL$C_RESET"
 fi
 
 # -------------------------------------------------------- screen 5: first gate -
 CURRENT=5
 rail_rewind
-if [ "$TTY_OUT" -eq 1 ]; then rail_print; fi
+if [ "$TTY_OUT" -eq 1 ]; then rail_draw; fi
 GATE_DEFAULT="bash tests/run-tests.sh"
 if [ -z "$GATE" ]; then
   if [ "$TTY_IN" -eq 1 ]; then
-    q ""
-    q "      ${C_MUTED}one real command that must stay green — suggested for a bash suite:$C_RESET"
+    rail_say ""
+    rail_say "      ${C_MUTED}one real command that must stay green — suggested for a bash suite:$C_RESET"
     if [ -f "$TARGET/tests/run-tests.sh" ]; then
-      q "      $C_DIM$GATE_DEFAULT$C_RESET"
+      rail_say "      $C_DIM$GATE_DEFAULT$C_RESET"
       ask_value "gate command" "$GATE_DEFAULT"; GATE="$REPLY"
     else
       ask_value "gate command" "true"; GATE="$REPLY"
       if [ "$GATE" = "true" ]; then
-        q "      ${C_YELLOW}no tests/run-tests.sh found — a placeholder gate is allowed but it proves nothing; replace it in .goblin/goblin.yaml$C_RESET"
-        Q_LINES=$((Q_LINES + 1))
+        rail_say "      ${C_YELLOW}no tests/run-tests.sh found — a placeholder gate is allowed but it proves nothing; replace it in .goblin/goblin.yaml$C_RESET"
       fi
     fi
   else
@@ -318,16 +348,15 @@ if [ -z "$GATE" ]; then
     cascade "gate: $GATE (default)"
   fi
 fi
-STEP_VAL[3]="  $C_TEXT$GATE$C_RESET"
+STEP_VAL[3]="$C_TEXT$GATE$C_RESET"
 if [ "$TTY_OUT" -eq 1 ]; then
-  printf '  %s✔%s %d. %-13s%s%s%s\n' "$C_GREEN" "$C_RESET" 5 "first gate" "$C_TEXT" "$GATE" "$C_RESET"
-  RAIL_LINES=$((RAIL_LINES + 1))
+  rail_say "  ✔ $((CURRENT - 1)). first gate      $C_TEXT$GATE$C_RESET"
 fi
 
 # --------------------------------------------------------- screen 6: the plan --
 CURRENT=6
 rail_rewind
-if [ "$TTY_OUT" -eq 1 ]; then rail_print; fi
+if [ "$TTY_OUT" -eq 1 ]; then rail_draw; fi
 
 # The emit selection: pre-tick the DETECTED platforms (in doctor's enum order).
 EMIT_SELECTED=""
@@ -355,19 +384,19 @@ fi
 EMIT_N=$(printf '%s' "$EMIT_SELECTED" | awk 'NF' | wc -l | tr -d '[:space:]')
 
 if [ "$TTY_IN" -eq 1 ] && [ -z "$EMIT" ] && [ "$YES" -eq 0 ]; then
-  q ""
-  q "      ${C_MUTED}emit now — the skills go into:$C_RESET"
+  rail_say ""
+  rail_say "      ${C_MUTED}emit now — the skills go into:$C_RESET"
   for p in $PLATFORMS; do
     hit=""
     while IFS=$'	' read -r dp _a _b _c; do [ "$dp" = "$p" ] && hit=1; done <<< "$DET_ROWS"
     [ -n "$hit" ] || continue
-    q "      ${C_GREEN}✔$C_RESET $C_TEXT$p$C_RESET"
+    rail_say "      ${C_GREEN}✔$C_RESET $C_TEXT$p$C_RESET"
   done
-  q "      ${C_DIM}Enter = these; or type platform names to override$C_RESET"
+  rail_say "      ${C_MUTED}Enter = these; or type platform names to override$C_RESET"
   printf '      '
   read -r REPLY_EMIT
   ASKED_ANY=1
-  printf '\n'; Q_LINES=$((Q_LINES + 1))
+  rail_say ""
   if [ -n "$REPLY_EMIT" ]; then
     EMIT_SELECTED=""
     for w in $REPLY_EMIT; do
@@ -377,16 +406,18 @@ if [ "$TTY_IN" -eq 1 ] && [ -z "$EMIT" ] && [ "$YES" -eq 0 ]; then
     done
   fi
 fi
-STEP_VAL[4]="  $C_TEXT$EMIT_N platform(s) · scope $SCOPE$C_RESET"
+STEP_VAL[4]="$C_TEXT$EMIT_N platform(s) · scope $SCOPE$C_RESET"
 if [ "$TTY_OUT" -eq 1 ]; then
-  printf '  %s✔%s %d. %-13s%s%d platform(s) · scope %s%s\n' "$C_GREEN" "$C_RESET" 6 "emit" "$C_TEXT" "$EMIT_N" "$SCOPE" "$C_RESET"
-  RAIL_LINES=$((RAIL_LINES + 1))
+  rail_say "  ✔ $((CURRENT - 1)). emit             $C_TEXT$EMIT_N platform(s) · scope $SCOPE$C_RESET"
 fi
 
 # ---- the plan box: the wizard never writes until this has been on the screen ----
+# Spacing: one blank line separates the rail from the box (the spacing pass); the box
+# carries two-space inner padding on every row so the columns align across rows.
 BOX=""
 add() { BOX="$BOX$1
 "; }
+add ""
 add "  ${C_DIM}╭──────────────────────────────────────────────────────╮${C_RESET}"
 add "  ${C_DIM}│${C_RESET}  ${C_GREEN}✔${C_RESET} ${C_TEXT}install${C_RESET}      $C_DIM.goblin/ + the payload into$C_RESET $C_TEXT$TARGET$C_RESET"
 add "  ${C_DIM}│${C_RESET}  ${C_GREEN}✔${C_RESET} ${C_TEXT}class${C_RESET}       $C_TEXT$CLASS$C_RESET ${C_DIM}· branch $C_TEXT$BRANCH$C_RESET ${C_DIM}· email$C_RESET $C_TEXT$EMAIL$C_RESET"
@@ -400,10 +431,11 @@ if [ "$DRYRUN" -eq 1 ]; then
 fi
 # A question the wizard genuinely asked (a screen that waited on read) buys the confirm;
 # flag/non-tty runs already stated their answer as a flag — proceeding is the contract.
+# Single-accent: the confirm prompt is muted + dim, never bold, never a second accent.
 if [ "$YES" -eq 0 ] && [ "${ASKED_ANY:-0}" -eq 1 ]; then
   printf '%s\n' "$BOX"
   if [ "$TTY_IN" -eq 1 ]; then
-    printf '      %sproceed?%s %s[Enter = yes]%s ' "$C_BOLD" "$C_RESET" "$C_DIM" "$C_RESET"
+    printf '      %sproceed?%s %s[Enter = yes]%s ' "$C_MUTED" "$C_RESET" "$C_DIM" "$C_RESET"
     read -r REPLY_GO
     case "$REPLY_GO" in n*|N*) g_info "aborted — nothing was written"; exit 0 ;; esac
   else
@@ -416,7 +448,14 @@ fi
 # carry: the declared identity (branch/owner_email) and the first gate, patched into
 # .goblin/goblin.yaml right after install renders it. The patch is fail-closed — the
 # gate must read back through the engine's own parser or the run stops here.
-if [ "$TTY_OUT" -eq 0 ]; then printf 'gob init [run] goblin-install --target %s --class %s\n' "$TARGET" "$CLASS"; fi
+# rail_note, not rail_say: engine output below is never redrawn over, and the wizard
+# never rewinds past its own buffer by counting lines it did not print.
+if [ "$TTY_OUT" -eq 1 ]; then
+  rail_note ""
+  rail_note "  ${C_MUTED}running: goblin-install --target $TARGET --class $CLASS${C_RESET}"
+else
+  printf 'gob init [run] goblin-install --target %s --class %s\n' "$TARGET" "$CLASS"
+fi
 bash "$SRC/bin/goblin-install" --target "$TARGET" --class "$CLASS" --yes
 EXIT_INSTALL=$?
 if [ "$EXIT_INSTALL" -ne 0 ]; then
@@ -453,7 +492,11 @@ fi
 
 EMITTED=0
 for p in $EMIT_SELECTED; do
-  [ "$TTY_OUT" -eq 0 ] && printf 'gob init [run] goblin-emit --platform %s --scope %s\n' "$p" "$SCOPE"
+  if [ "$TTY_OUT" -eq 0 ]; then
+    printf 'gob init [run] goblin-emit --platform %s --scope %s\n' "$p" "$SCOPE"
+  else
+    rail_note "  ${C_MUTED}running: goblin-emit --platform $p --scope $SCOPE${C_RESET}"
+  fi
   bash "$SRC/bin/goblin-emit" --platform "$p" --scope "$SCOPE" --target "$TARGET"
   EXIT_EMIT=$?
   if [ "$EXIT_EMIT" -ne 0 ]; then
@@ -464,9 +507,9 @@ for p in $EMIT_SELECTED; do
 done
 
 # --------------------------------------------------- screen 6b: done + verify --
-if [ "$TTY_OUT" -eq 1 ]; then
-  printf '\n'
-else
+# Spacing pass: exactly one blank line before each done-screen section; the engine's
+# verify output and this screen's own summary stay visually separated.
+if [ "$TTY_OUT" -eq 0 ]; then
   printf 'gob init [verify] .goblin/bin/goblin-verify\n'
 fi
 if [ "$DRYRUN" -eq 0 ]; then
@@ -494,12 +537,12 @@ if [ "$DRYRUN" -eq 0 ]; then
     else
       printf '  %sgob verify: %s passed, %s failed, %s skipped · exit %s%s\n' "$C_RED" "$PASSED" "$FAILED" "$SKIPPED" "$VERIFY_RC" "$C_RESET"
     fi
-    printf '\n'
   else
     g_info "gob init [verify] exit $VERIFY_RC: $PASSED passed, $FAILED failed, $ADVISORY advisory, $SKIPPED skipped"
   fi
 
-  printf '  %snext:%s\n' "$C_BOLD" "$C_RESET"
+  printf '\n'
+  printf '  %snext:%s\n' "$C_MUTED" "$C_RESET"
   printf '    1. %sthe %s skipped checks ARE your checklist — gob verify names each one%s\n' "$C_TEXT" "$SKIPPED" "$C_RESET"
   printf '    2. %sreplace the placeholder gate in .goblin/goblin.yaml with your real commands (P8 step 3)%s\n' "$C_TEXT" "$C_RESET"
   printf '    3. %snot emitted here: gob emit --platform <p> --scope global%s\n' "$C_TEXT" "$C_RESET"

package/docs/w6-tty-redraw-pty-transcript.txt

@@ -0,0 +1,334 @@
+Script started on 2026-10-02 00:53:48+07:00 [COMMAND="bash /home/harvey/projects/goblin-stack/bin/goblin-init --target /tmp/ptyfinal/repo --yes" <not executed on terminal>]
+
+
+
+
+
+
+
+
+▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █
+█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █
+█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██
+▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █
+     discipline around whatever executes
+
+  gob init — first-run setup (gobstack v0.4.4)
+  6 steps · every step has a flag · nothing is written until the plan is confirmed
+
+  ◆ 1. platforms    
+  ○ 2. class        
+  ○ 3. branch/email 
+  ○ 4. first gate   
+  ○ 5. emit         
+  ○ 6. done         
+▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █
+█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █
+█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██
+▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █
+     discipline around whatever executes
+
+  gob init — first-run setup (gobstack v0.4.4)
+  6 steps · every step has a flag · nothing is written until the plan is confirmed
+
+  ✔ 1. platforms    
+  ◆ 2. class        
+  ○ 3. branch/email 
+  ○ 4. first gate   
+  ○ 5. emit         
+  ○ 6. done         
+
+  ✔ 1. platforms      0 detected
+      no platform detected here — the wizard will still install the harness; emit later with gob emit
+▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █
+█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █
+█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██
+▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █
+     discipline around whatever executes
+
+  gob init — first-run setup (gobstack v0.4.4)
+  6 steps · every step has a flag · nothing is written until the plan is confirmed
+
+
+  ✔ 1. platforms      0 detected
+      no platform detected here — the wizard will still install the harness; emit later with gob emit
+  ✔ 1. platforms    0 detected
+  ✔ 2. class        
+  ◆ 3. branch/email 
+  ○ 4. first gate   
+  ○ 5. emit         
+  ○ 6. done         
+
+      what kind of work does this repo do?
+        1 ▸ app        shipped features, PRs, review gates        (class A)
+        2   service    backend jobs, config, unattended runs      (class B)
+        3   game       playable builds, perf budgets              (class C)
+        4   research   specs, replays, reference corpora          (class D)
+        5   agent      fleets, loops, unattended automation       (class E)
+        6   desktop    the shell you live in, perf budget         (class F)
+      ↑ number + Enter · Enter = app · the class letter works too (A-F)
+      
+  ✔ 2. class            A — shipped-software
+▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █
+█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █
+█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██
+▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █
+     discipline around whatever executes
+
+  gob init — first-run setup (gobstack v0.4.4)
+  6 steps · every step has a flag · nothing is written until the plan is confirmed
+
+
+  ✔ 1. platforms      0 detected
+      no platform detected here — the wizard will still install the harness; emit later with gob emit
+
+      what kind of work does this repo do?
+        1 ▸ app        shipped features, PRs, review gates        (class A)
+        2   service    backend jobs, config, unattended runs      (class B)
+        3   game       playable builds, perf budgets              (class C)
+        4   research   specs, replays, reference corpora          (class D)
+        5   agent      fleets, loops, unattended automation       (class E)
+        6   desktop    the shell you live in, perf budget         (class F)
+      ↑ number + Enter · Enter = app · the class letter works too (A-F)
+
+  ✔ 2. class            A — shipped-software
+  ✔ 1. platforms    0 detected
+  ✔ 2. class        A (shipped-software)
+  ✔ 3. branch/email 
+  ◆ 4. first gate   
+  ○ 5. emit         
+  ○ 6. done         
+
+      the forge contract — the identity this repo commits with (CM-01)
+      default branch ─ main
+      owner email ─ t@t.co
+  ✔ 3. branch/email   main · t@t.co
+▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █
+█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █
+█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██
+▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █
+     discipline around whatever executes
+
+  gob init — first-run setup (gobstack v0.4.4)
+  6 steps · every step has a flag · nothing is written until the plan is confirmed
+
+
+  ✔ 1. platforms      0 detected
+      no platform detected here — the wizard will still install the harness; emit later with gob emit
+
+      what kind of work does this repo do?
+        1 ▸ app        shipped features, PRs, review gates        (class A)
+        2   service    backend jobs, config, unattended runs      (class B)
+        3   game       playable builds, perf budgets              (class C)
+        4   research   specs, replays, reference corpora          (class D)
+        5   agent      fleets, loops, unattended automation       (class E)
+        6   desktop    the shell you live in, perf budget         (class F)
+      ↑ number + Enter · Enter = app · the class letter works too (A-F)
+
+  ✔ 2. class            A — shipped-software
+
+      the forge contract — the identity this repo commits with (CM-01)
+
+
+  ✔ 3. branch/email   main · t@t.co
+  ✔ 1. platforms    0 detected
+  ✔ 2. class        A (shipped-software)
+  ✔ 3. branch/email main · t@t.co
+  ✔ 4. first gate   
+  ◆ 5. emit         
+  ○ 6. done         
+
+      one real command that must stay green — suggested for a bash suite:
+      bash tests/run-tests.sh
+      gate command ─ bash tests/run-tests.sh
+  ✔ 4. first gate      bash tests/run-tests.sh
+▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █
+█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █
+█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██
+▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █
+     discipline around whatever executes
+
+  gob init — first-run setup (gobstack v0.4.4)
+  6 steps · every step has a flag · nothing is written until the plan is confirmed
+
+
+  ✔ 1. platforms      0 detected
+      no platform detected here — the wizard will still install the harness; emit later with gob emit
+
+      what kind of work does this repo do?
+        1 ▸ app        shipped features, PRs, review gates        (class A)
+        2   service    backend jobs, config, unattended runs      (class B)
+        3   game       playable builds, perf budgets              (class C)
+        4   research   specs, replays, reference corpora          (class D)
+        5   agent      fleets, loops, unattended automation       (class E)
+        6   desktop    the shell you live in, perf budget         (class F)
+      ↑ number + Enter · Enter = app · the class letter works too (A-F)
+
+  ✔ 2. class            A — shipped-software
+
+      the forge contract — the identity this repo commits with (CM-01)
+
+
+  ✔ 3. branch/email   main · t@t.co
+
+      one real command that must stay green — suggested for a bash suite:
+      bash tests/run-tests.sh
+
+  ✔ 4. first gate      bash tests/run-tests.sh
+  ✔ 1. platforms    0 detected
+  ✔ 2. class        A (shipped-software)
+  ✔ 3. branch/email main · t@t.co
+  ✔ 4. first gate   bash tests/run-tests.sh
+  ✔ 5. emit         
+  ◆ 6. done         
+  ✔ 5. emit             0 platform(s) · scope project
+
+  running: goblin-install --target /tmp/ptyfinal/repo --class A
+created 50 · updated 0 · unchanged 0 · skipped 0
+
+next:
+  1. cd /tmp/ptyfinal/repo && git add -A && git commit   # the install is a change like any other
+  2. .goblin/bin/goblin-verify   # or add .goblin/bin to PATH
+  3. edit .goblin/goblin.yaml: replace the default gate with your real commands (P8 step 3)
+  4. hermes skills trust /tmp/ptyfinal/repo   # one-time, so the project-tier skills load
+
+automations (optional; neither writes outside this repo, and A-02 has no agent in it):
+  bash /tmp/ptyfinal/repo/.goblin/automations/drift-audit.sh --dry-run        # read the record first
+  cp /tmp/ptyfinal/repo/.goblin/automations/drift-audit.sh ~/.hermes/scripts/
+  hermes cron create "0 9 * * 1" --name "Drift audit - weekly" --no-agent \
+      --script drift-audit.sh --deliver <channel>
+  P13/P14 in docs/FLOWS.md; the whole model in automations/README.md
+      PASS  IN-01  the install record exists and names its version
+      PASS  IN-02  41 installed files hashed
+      PASS  IN-03  the manifest is complete: every rule carries a check or is advisory, inside the enum
+      PASS  IN-04  0 pre-existing file(s) left untouched
+      PASS  HP-01  (test -f HANDOFF.md)
+      PASS  HP-02  (for h in 'START HERE' 'STATE|STATUS' 'GATES?' 'NEXT STEPS|NEXT' 'NOT VERIFIED|UNVERIFIED|NOT PROVEN|UNPROVEN|PENDING[^.]*DEVICE TEST'; do grep -qiE "^#{2,3}[[:space:]]+[^[:alpha:]]*($h)\b" HANDOFF.md || { echo "missing section: $h"; exit 1; }; done)
+      PASS  HP-03  1 gate line(s) inside the Gates section, each with a measured date (anchored on the declared gate name(s): commit todo_ceiling)
+      ADV   HP-04  A stale sentence is corrected in place with a dated parenthetical, never deleted. (advisory)
+      PASS  HP-05  names 3c96403 (ancestor of HEAD 3c96403)
+      PASS  SP-01  (ls ./*-SPEC.md >/dev/null 2>&1)
+      FAIL  SP-02  (test -z "$(git ls-files --others --exclude-standard -- '*-SPEC.md')" -> exit 1)
+      PASS  SP-03  (awk '/^[[:space:]]*[-*][[:space:]]/ && /AC[0-9]*:/ && !/`|==|===|exit|<|>/ {print; bad=1} END{exit bad}' ./*-SPEC.md)
+      PASS  GT-01  2 declared gate(s), each with a cmd
+      PASS  GT-02  commit=0 todo_ceiling=0 · client_js_bytes 0 (ceiling 0) · measured 2026-10-02
+      PASS  GT-03  (test -f .goblin/last-gate-line && [ .goblin/last-gate-line -nt "$(git rev-parse --git-dir)/logs/HEAD" ])
+      PASS  GT-04  ratchet client_js_bytes ceiling 0
+      PASS  GT-05  client_js_bytes 0 (ceiling 0)
+      PASS  HS-01  not an asserting harness (report utility): gate.sh
+1 asserting harness(es), 1 report utility(ies)
+      SKIP  HS-02  no pinned pre-change commit yet (replay.commit empty or unknown) - REPLAY not provable
+      ADV   HS-03  Source probes read text with comments blanked first. (advisory)
+      PASS  CM-01  (test "$(git log -1 --format='%ae')" = "$(grep '^owner_email:' .goblin/goblin.yaml | cut -d' ' -f2)")
+      ADV   CM-02  The commit message was written to a file, not passed with -m. (advisory)
+      FAIL  CM-03  9 dirty entr(y|ies), max_dirty 0
+      PASS  MD-01  (for d in skills manifest bin templates presets .goblin .hermes; do [ -d "$d" ] || continue; grep -rniE '(d[e]epseek|cl[a]ude|g[p]t-[0-9]|gr[o]k|g[e]mini|g[l]m-[0-9]|k[i]mi)[a-z0-9.:_-]*' "$d" && exit 1; done; exit 0)
+      ADV   MD-02  no model mapping configured (/tmp/ptyfinal/home/projects/fleet-model.yaml absent) - advisory
+      ADV   MD-03  Role-pinned fan-out goes through kanban, not a model-less subagent spawn. (advisory)
+      PASS  PG-01  0 review note(s)
+      PASS  PG-02  0 review note(s) classified
+      PASS  PG-03  0 review note(s) patch-id checked
+      ADV   PG-04  Never bypass what the forge enforces. (advisory)
+      PASS  PG-05  1 workflow file(s) checked for a self-skipping required check
+      PASS  PG-06  goblin-gate.yml: runs the verifier, which executes every declared gate
+1 workflow file(s) compared with the 2 declared gate(s)
+      PASS  DS-01  unchanged: .goblin/state.json=missing
+      PASS  DS-02  snapshot .goblin/state.json=missing
+      ADV   DOC-01 A significant change updates the docs that teach it. (advisory)
+      ADV   DOC-02 System-level changes are recorded wherever the project's standard says they live. (advisory)
+      PASS  SK-01  
+      PASS  SK-02  20 installed skill file(s) hashed
+      PASS  SK-03  advisory 10 of ceiling 10 (0 free slots: the next advisory row FAILs)
+      PASS  SK-04  
+      PASS  PT-01  (for d in skills manifest bin templates presets .goblin .hermes; do [ -d "$d" ] || continue; grep -rniE --exclude=goblin.yaml --exclude=installed.json '(h[a]rvey|tech-g[o]blin|/h[o]me/[a-z]+|g[o]blin-ui|op[e]n-door|sup[r]eme|bb[t]ech|c[l]v)' "$d" && exit 1; done; exit 0)
+      PASS  PT-02  declared main, actual main
+      PASS  CL-01  part pr-gate: optional, present
+part review-panel: optional, present
+part tokens: optional, absent
+      PASS  CL-02  archive: false - the full class requirement applies
+      PASS  SC-01  0 tracked secret file(s)
+      PASS  SC-02  the whole secret family is ignored (.env, .env.local, .env.production proved by git)
+      PASS  SC-03  0 client-visible secret-shaped name(s); no build output to scan for clause 2
+      PASS  SC-04  0 cookie write(s) checked; a JS-written cookie is readable by any script - reported, not failed
+      PASS  SC-05  0 write handler(s), 0 waived; 11 dir(s) declared
+      SKIP  SC-06  no package.json - there is no dependency manifest to lock
+      SKIP  SC-07  no audit record yet. Run .goblin/bin/goblin-audit once, deliberately, then commit
+.goblin/audit.tsv: SC-07 reads the record and never the network
+      SKIP  SC-08  no package-lock.json - there is no install-hook surface to enumerate
+      ADV   SC-09  Auth is applied consistently across sibling routes. (advisory)
+      SKIP  PF-01  no perf baseline recorded yet: run `find .next/static dist/assets dist -type f -name '*.js' -exec cat {} + 2>/dev/null | wc -c` on a pinned commit, then write
+perf.baseline_commit, perf.baseline_value, perf.measured and the matching ratchet ceiling
+      PASS  AU-01  2 automation producer(s) scanned, none opens with a network or forge verb
+      SKIP  AU-02  no reports/*/report.yaml - nothing to dedup
+      SKIP  AU-03  no reports/ - no reporter run in this repo to audit
+      PASS  AU-04  
+      PASS  BN-00  8 ban(s), each with an enforcement row and a named replacement
+      SKIP  BN-01  No `any` in application TypeScript. (no matching files: src) 
+      SKIP  BN-02  No `@ts-ignore` / `@ts-expect-error` suppressions. (no matching files: src) 
+      SKIP  BN-03  No direct network call from a component. (not enabled in bans: - add BN-03 to .goblin/goblin.yaml to turn it on) 
+      SKIP  BN-05  No import across a declared layer boundary. (no matching files: src) 
+      SKIP  BN-06  No renderer with Node access (`nodeIntegration: true`). (not enabled in bans: - add BN-06 to .goblin/goblin.yaml to turn it on) 
+      SKIP  BN-07  No renderer with context isolation or the process sandbox turned off. (not enabled in bans: - add BN-07 to .goblin/goblin.yaml to turn it on) 
+      SKIP  BN-08  No dangerous webPreferences. (not enabled in bans: - add BN-08 to .goblin/goblin.yaml to turn it on) 
+      SKIP  BN-09  No synchronous IPC and no `@electron/remote`. (not enabled in bans: - add BN-09 to .goblin/goblin.yaml to turn it on) 
+      SKIP  FM-01  feature_map: is empty - no map is declared, so there is nothing to index
+      SKIP  FM-02  feature_map: is empty - no map is declared, so there are no entry paths to resolve
+      SKIP  VA-01  verify_doctor: is empty - no doctor is declared, so "the generated skill was executed once" is not provable here
+      SKIP  JG-01  no loop record in this repo - no judge verdict to check
+      ADV   JG-02  no model mapping configured (/tmp/ptyfinal/home/projects/fleet-model.yaml absent) - advisory
+remedy: add a `judge:` entry beside the code lane in the file declared as models_file: in /tmp/ptyfinal/repo/.goblin/goblin.yaml
+      ADV   JG-03  A judge lane that has never returned a non-`done` verdict is escalated. (advisory)
+      SKIP  LP-01  no loop has run in this repo
+      SKIP  LP-02  no loop has run in this repo
+      SKIP  LP-03  no loop has run in this repo
+      SKIP  LP-04  no loop has run in this repo
+      SKIP  LP-05  no loop has run in this repo
+      SKIP  RC-01  reference_manifest: is empty - no reference corpus is declared, so there is nothing for a build to match against
+      SKIP  RC-02  reference_manifest: is empty - there is no manifest to shape-check (RC-01 skips for the same reason)
+      SKIP  RC-03  no manifests/ directory - this is not a lab repo with a reference corpus, so there are no tracked bytes to check
+      SKIP  RC-04  no manifests/*.sha256 - no acquisition record is declared, so there is none to read
+      41 passed, 2 failed, 11 advisory, 28 skipped
+      of those 11 advisory: the matrix labels 10 row(s) advisory; the difference is the non-advisory row(s) reporting ADV by design (an unresolved lane) and any labelled row skipped by an opt-out
+      cannot see: whether a check in the harness dir tests the right path rather than
+      merely passing; whether the forge is bound by the workflow CL-01 found; whether a human
+      read the diff;
+      whether the model mapping names a family that actually differs (MD-02 reports it
+      and cannot change it); and whether .goblin/installed.json — the record every drift
+      check trusts — was itself rewritten. It is not signed, so one edit to it (with the
+      matching edit to the file it protects) defeats IN-02, SK-02 and HS-01 at once
+      (docs/LIMITS.md #18). The ban lane carries the same blind spot and two of its own:
+      the ban table is a manifest file under the same unsigned record, so a defanged ban
+      passes BN-00 (docs/LIMITS.md #28); a ban probe is a TEXT probe with no AST, so a
+      `Record<string, any>` is missed and a `: any` inside a string is reported
+      (docs/LIMITS.md #27); and no check here can reach a ban IN CONTEXT — the row proves
+      the forbidden path fails mechanically, never that the ban reached the agent that
+      wrote the line. The judge/loop lane adds its own: every JG-/LP- row reads a RECORD, so
+      it proves a handle, a pin, a budget and a pointer exist — never that the loop made
+      progress (a changed pointer is a proxy, docs/LIMITS.md #33), never which lane returned
+      a verdict, and never that the predicate was the right one or was really run. The CI lane
+      adds its own: PG-05 and PG-06 read a workflow's TEXT, so PG-05 sees a job whose gate step is
+      conditional and cannot see branch protection, the required-check list, or a forge that never
+      ran the job at all, and PG-06 proves a declared gate is INVOKED in a file under
+      .github/workflows/ — never that the forge marks that job required, never that it is the job
+      the forge waits on, and never that the workflow can fail (that is PG-05). A required check
+      that reports Success after skipping its gate is a green light for a commit whose gate never
+      ran (docs/CI.md). The reference-corpus lane adds its own: RC-01 matches EXACT sha256 only,
+      so a resized, recoloured or re-encoded reference asset, or copied text inside a shipped
+      string, passes it unseen; RC-02 proves the manifest is well-shaped, never that its entries
+      are the right hashes (as strong as tamper hashing, and installed.json is unsigned); RC-03
+      reads the tracked tree and cannot see a payload renamed and re-encoded; and RC-04 proves an
+      acquisition record EXISTS, never that the number beside it came from the store (HP-03's
+      defect, one artifact over). No row here reaches a reference asset in CONTEXT either.
+      engine: mode=vendored cli_sha256=2d37cf1c9f38a582ad60f3f75d2fcd53d10b743905dc3274eab6511c5c5ea008 enforcement_tsv_sha256=fd474c268b0852587c632910c503144fbcfe5e211ed2182902949a79fc5282b1
+
+  gob verify: 41 passed, 2 failed, 28 skipped · exit 1
+
+  next:
+    1. the 28 skipped checks ARE your checklist — gob verify names each one
+    2. replace the placeholder gate in .goblin/goblin.yaml with your real commands (P8 step 3)
+    3. not emitted here: gob emit --platform <p> --scope global
+    4. hermes skills trust /tmp/ptyfinal/repo   # one-time, so the project-tier skills load
+
+  ▙ the goblin sees you. the gate is RED — start there.
+
+Script done on 2026-10-02 00:53:50+07:00 [COMMAND_EXIT_CODE="0"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techgoblin/gobstack",
-  "version": "0.4.4-beta.6",
+  "version": "0.4.4-beta.7",
   "description": "Agent-discipline toolkit: one verify command, an enforcement matrix, and LIMITS. bash engine, npm shim.",
   "bin": {
     "goblin": "bin/goblin.js",