@pmelab/gtd 8.0.0 → 8.2.0

package/bin/gtd

@@ -44,12 +44,12 @@ if [[ "$FANCY" == 1 ]]; then
   C_RESET=$'\e[0m'; C_BOLD=$'\e[1m'; C_DIM=$'\e[2m'
   C_CYAN=$'\e[36m'; C_GREEN=$'\e[32m'; C_YELLOW=$'\e[33m'; C_RED=$'\e[31m'
   M_TRANS="➡️"; M_AGENT="🤖"; M_CHECK="🔧"; M_HUMAN="✍️"
-  M_FIX="🔁"; M_COMMIT="✅"; M_SETTLE="🎉"; M_ERROR="❌"; M_ELLIPSIS="…"
+  M_FIX="🔁"; M_COMMIT="✅"; M_SETTLE="🎉"; M_ERROR="❌"; M_WARN="⚠️"; M_ELLIPSIS="…"
 else
   C_RESET=""; C_BOLD=""; C_DIM=""
   C_CYAN=""; C_GREEN=""; C_YELLOW=""; C_RED=""
   M_TRANS="->"; M_AGENT="[agent]"; M_CHECK="[check]"; M_HUMAN="[you]"
-  M_FIX="[fix]"; M_COMMIT="[commit]"; M_SETTLE="[done]"; M_ERROR="[err]"; M_ELLIPSIS="..."
+  M_FIX="[fix]"; M_COMMIT="[commit]"; M_SETTLE="[done]"; M_ERROR="[err]"; M_WARN="[warn]"; M_ELLIPSIS="..."
 fi
 
 # emit_file_rows <files> — render a commit's changed files as dim, indented
@@ -114,8 +114,10 @@ emit_error() {
 }
 
 # emit_log_pointer — the "see the log" line printed right after every
-# emit_error call, to stderr: suppression must never hide a failure, so every
-# error points at where the redirected subprocess output actually went.
+# emit_error call, to stderr: it names the log as the OVERFLOW channel — the
+# failing execution's own output is already replayed inline (see emit_block/
+# emit_output_since below); the log is where the rest of it, and the full
+# run's other output, lives.
 emit_log_pointer() {
   if [[ "$FANCY" == 1 ]]; then
     printf '%s📄 see %s%s\n' "$C_DIM" "$GTD_LOOP_LOG" "$C_RESET" >&2
@@ -124,6 +126,58 @@ emit_log_pointer() {
   fi
 }
 
+# Suppressed subprocess output goes to $GTD_LOOP_LOG in full, but a FAILING
+# execution also replays inline: mark the log's size before the call, print
+# what was appended since. Bounded to the last $ERR_TAIL_LINES lines — the log
+# holds the rest, and the overflow row says where.
+ERR_TAIL_LINES=20
+
+# log_offset — the log's current size in bytes (0 when it doesn't exist yet).
+log_offset() {
+  local n=0
+  if [[ -n "${GTD_LOOP_LOG:-}" && -f "$GTD_LOOP_LOG" ]]; then n="$(wc -c <"$GTD_LOOP_LOG")"; fi
+  printf '%s' "${n// /}"
+}
+
+# emit_block <text> — replay captured subprocess output to stderr, dim and
+# indented like emit_file_rows, capped at the LAST $ERR_TAIL_LINES lines with
+# an overflow row naming the log. Empty <text> prints nothing. CSI escapes are
+# stripped under FANCY=0 (the plain-ASCII promise), using a sed form (\e, not
+# \x1b) that both BSD and GNU sed accept.
+emit_block() {
+  local text="$1" total overflow
+  [[ -z "$text" ]] && return 0
+  if [[ "$FANCY" == 0 ]]; then
+    text="$(sed $'s/\e\\[[0-9;]*[a-zA-Z]//g' <<<"$text")"
+  fi
+  total="$(wc -l <<<"$text")"
+  total="${total// /}"
+  if ((total > ERR_TAIL_LINES)); then
+    overflow=$((total - ERR_TAIL_LINES))
+    printf '   %s%s (%d earlier lines in %s)%s\n' "$C_DIM" "$M_ELLIPSIS" "$overflow" "$GTD_LOOP_LOG" "$C_RESET" >&2
+    text="$(tail -n "$ERR_TAIL_LINES" <<<"$text")"
+  fi
+  while IFS= read -r line; do
+    printf '   %s%s%s\n' "$C_DIM" "$line" "$C_RESET" >&2
+  done <<<"$text"
+}
+
+# emit_output_since <offset> — emit_block over the log bytes appended since
+# <offset>.
+emit_output_since() {
+  local offset="$1" bytes=""
+  if [[ -n "${GTD_LOOP_LOG:-}" && -f "$GTD_LOOP_LOG" ]]; then
+    bytes="$(tail -c "+$((offset + 1))" "$GTD_LOOP_LOG" 2>/dev/null || true)"
+  fi
+  emit_block "$bytes"
+}
+
+# emit_warn <message> — a surfaced but NON-fatal failure (a check script that
+# exited non-zero).
+emit_warn() {
+  printf '%s %s%s%s\n' "$M_WARN" "$C_YELLOW" "$1" "$C_RESET" >&2
+}
+
 # ── Git-derivation helpers (parse_subject, report_commits) ──────────────────
 
 # parse_subject <subject> — sets S_ACTOR / S_FROM / S_TO / S_KIND. Patterns are
@@ -247,7 +301,7 @@ fi
 # otherwise ($# -eq 0, or exactly "loop" with no further args, --once already
 # stripped above): fall through into the loop body below.
 
-# Drives the v3 pattern-machine loop (see docs/loop.md): each iteration asks
+# Drives the v3 pattern-machine loop: each iteration asks
 # `gtd next --json` who's up and what they should do, dispatching on `kind`:
 #   - "message" (a human rest)  -> the non-autonomous halt: print the gate and
 #     exit 0. Acting on it (opening an editor, notifying, whatever) is an
@@ -264,8 +318,7 @@ fi
 # adapter invoked at a "prompt" rest; the default adapter appends `--model
 # "$GTD_LOOP_MODEL"` only when it's non-empty.
 #
-# `.memory` (optional, opaque — see skills/loop/SKILL.md "Agent memory scope")
-# is the agent-memory scope label. gtd never interprets it; the driver does:
+# `.memory` (optional, opaque) is the agent-memory scope label. gtd never interprets it; the driver does:
 # consecutive "prompt" turns emitting the SAME label continue ONE agent
 # session (so the agent still remembers its previous turn), and a changed
 # label — or the first turn, or an unset label — starts fresh. That is what
@@ -376,9 +429,10 @@ fi
 
 while true; do
   if ! next_json="$(run_gtd next --json 2>&1)"; then
-    echo "gtd-loop: could not determine the next step:" >&2
-    echo "$next_json" >&2
-    echo "Run \`gtd status\` to inspect the repo." >&2
+    emit_error "could not determine the next step:
+$next_json
+Run \`gtd status\` to inspect the repo."
+    emit_log_pointer
     exit 1
   fi
 
@@ -395,17 +449,29 @@ while true; do
     # (or an outer wrapper) edits and re-launches; the opening move above
     # captures what they left.
     emit_gate "$state" "$label"
-    run_gtd next
+    if ! gate_out="$(run_gtd next 2>&1)"; then
+      emit_error "$gate_out"
+      emit_log_pointer
+      exit 1
+    fi
+    printf '%s\n' "$gate_out"
     exit 0
   fi
 
   if [[ "$kind" == "script" ]]; then
     emit_action "$M_CHECK" "$label"
-    # Execute the emitted wrapper verbatim; its exit code is deliberately
-    # ignored (`|| true` under `set -e`) — the script encodes its outcome in
-    # the tree, and `gtd step` captures whatever it left there via the state's
-    # own `on` patterns. Its own output goes to the log, not the terminal.
-    bash -c "$content" >>"$GTD_LOOP_LOG" 2>&1 || true
+    # Execute the emitted wrapper verbatim; its exit code decides nothing
+    # (the script encodes its outcome in the tree, and `gtd step` captures
+    # whatever it left there via the state's own `on` patterns) but a non-zero
+    # exit is surfaced as a warning — its own output goes to the log, and to
+    # the terminal too when it exits non-zero.
+    script_offset="$(log_offset)"
+    script_status=0
+    bash -c "$content" >>"$GTD_LOOP_LOG" 2>&1 || script_status=$?
+    if ((script_status != 0)); then
+      emit_warn "the check script at '$state' exited $script_status — continuing; the outcome is whatever it left in the tree:"
+      emit_output_since "$script_offset"
+    fi
     if ! step_out="$(run_gtd step "$actor" 2>&1)"; then
       printf '%s\n' "$step_out" >>"$GTD_LOOP_LOG"
       emit_error "$step_out"
@@ -425,7 +491,7 @@ while true; do
     continue
   fi
 
-  # kind == "prompt": stall detection (skills/loop/SKILL.md) — the same
+  # kind == "prompt": stall detection — the same
   # agent-owned state and content repeating, WITH NO COMMIT authored since the
   # last time we saw this beat, means the last dispatch made no progress; stop
   # rather than spin on it. The HEAD check is what distinguishes a genuine
@@ -479,24 +545,42 @@ $next_out"
   # driver-side equivalent, so the next rest is only ever handed a well-formed
   # file. gtd itself never validates at step time — this is the loop's job.
   emit_action "$M_AGENT" "$label"
-  run_agent_turn "$content" "$resume"
+  turn_offset="$(log_offset)"
+  agent_status=0
+  run_agent_turn "$content" "$resume" || agent_status=$?
+  if ((agent_status != 0)); then
+    emit_error "the agent turn at '$state' failed (exit $agent_status):"
+    emit_output_since "$turn_offset"
+    emit_log_pointer
+    exit 1
+  fi
 
   fix_attempt=0
   while ! validate_out="$(run_gtd validate 2>&1)"; do
     fix_attempt=$((fix_attempt + 1))
     if ((fix_attempt > 3)); then
+      printf '%s\n' "$validate_out" >>"$GTD_LOOP_LOG"
       emit_error "'$state' still fails \`gtd validate\` after 3 fix attempts:
 $validate_out
 Stopping rather than stepping with a malformed steering file."
       emit_log_pointer
       exit 1
     fi
+    printf '%s\n' "$validate_out" >>"$GTD_LOOP_LOG"
+    emit_action "$M_FIX" "attempt $fix_attempt"
     # Resume the same session when there is one (the agent just wrote the file);
     # otherwise a fresh invocation still gets the findings via the prompt.
     fix_resume=0
     [[ -n "$session_id" ]] && fix_resume=1
-    emit_action "$M_FIX" "attempt $fix_attempt"
-    run_agent_turn "$content"$'\n\n'"Your last turn does not pass \`gtd validate\`. Fix these format violations, then finish:"$'\n'"$validate_out" "$fix_resume"
+    turn_offset="$(log_offset)"
+    agent_status=0
+    run_agent_turn "$content"$'\n\n'"Your last turn does not pass \`gtd validate\`. Fix these format violations, then finish:"$'\n'"$validate_out" "$fix_resume" || agent_status=$?
+    if ((agent_status != 0)); then
+      emit_error "the agent's fix attempt $fix_attempt at '$state' failed (exit $agent_status):"
+      emit_output_since "$turn_offset"
+      emit_log_pointer
+      exit 1
+    fi
   done
 
   if ! step_out="$(run_gtd step "$actor" 2>&1)"; then