@pmelab/gtd 7.11.1 → 8.0.0

package/README.md

@@ -107,16 +107,10 @@ handful of commands drive it:
   and a "Current state" panel showing where the active process rests, its
   pending changes, and which action leads where. The panel and diagram highlight
   refresh live (~every 3s) while the page is open, so advancing the process
-  elsewhere shows up without a manual refresh.
-- **`gtd edit [path]`** — open `<path>` (or, with no argument, the current
-  resting state's steering file, or the repo dir) in `${VISUAL:-$EDITOR}`,
-  blocking until it exits. Low-level plumbing — for "force an edit at the
-  current human gate, then keep driving", pass `--edit` to the loop instead (see
-  below).
-
-`gtd version` (or `gtd --version`/`-v`) prints the installed version and exits;
-`gtd help` (or `gtd --help`/`-h`) prints the command list. Both short-circuit
-before any repo work, so they run anywhere.
+  elsewhere shows up without a manual refresh. `gtd version` (or
+  `gtd --version`/`-v`) prints the installed version and exits; `gtd help` (or
+  `gtd --help`/`-h`) prints the command list. Both short-circuit before any repo
+  work, so they run anywhere.
 
 The loop is one beat, repeated: run `gtd next --json` and dispatch on `kind` —
 `"message"` means it's a human's move (stop and hand off); `"script"` means the
@@ -183,23 +177,20 @@ keep their own scratch/bookkeeping, independent of the per-file vars — relocat
 one steering file without touching it.
 
 Bare `gtd` (or `gtd loop`) is a ready-to-run driver for the whole protocol —
-point it at a repo and it runs the loop until it's your turn. It is the only
-command you run: at a human gate it now opens `${VISUAL:-$EDITOR}` on the gate's
-file for you automatically (answer a plan question, tick a review box, fix
-code), waits for you to save and exit, then captures your edit itself and keeps
-driving — or halts if you left nothing changed — so you never run
-`gtd step human` by hand. Pass `--no-edit` (or set `GTD_NO_EDIT`) to fall back
-to halting and printing the gate instead, if you'd rather edit and re-launch it
-yourself; pass `--edit`/`-e` to force the editor open at the gate right now,
-overriding an ambient `GTD_NO_EDIT`/`--no-edit`. Pass `--once` to restrict a run
-to exactly one beat — one human gate, one check, or one agent turn — instead of
-driving all the way to idle; it combines freely with `--edit`/`--no-edit`. Pass
-`--no-notify` (or set `GTD_NO_NOTIFY`) to suppress Herdr desktop notifications
-while keeping Herdr sidebar state reporting on. Bare `gtd` prints one line per
-event — colored and emoji on a real terminal, plain ASCII under `NO_COLOR` or
-when piped — and redirects the noisier agent/check/step subprocess output to a
-per-repo/per-worktree log file. `gtd log` opens that logfile in your editor. See
-[Driving the loop](docs/loop.md).
+point it at a repo and it runs the loop until it's your turn. It drives the
+autonomous states (agent turns, check runs) and stops at the first
+non-autonomous one: reaching a human gate it prints the gate and exits. You act
+by editing files (answer a plan question, tick a review box, fix code) and
+re-launching it — its opening move captures whatever you left, so you never run
+`gtd step human` by hand. Anything richer at that boundary — opening your
+editor, desktop notifications, terminal-multiplexer status — is the job of an
+outer wrapper around `gtd`, not of the loop itself. Pass `--once` to restrict a
+run to exactly one beat — one human-gate capture, one check, or one agent turn —
+instead of driving all the way to idle. Bare `gtd` prints one line per event —
+colored and emoji on a real terminal, plain ASCII under `NO_COLOR` or when piped
+— and redirects the noisier agent/check/step subprocess output to a
+per-repo/per-worktree log file (its path is the run's first output line, ready
+to `tail -f`). See [Driving the loop](docs/loop.md).
 
 Before wiring gtd into a repo, note the
 [repository requirements](docs/cli.md#repository-requirements) — most
@@ -225,14 +216,10 @@ diagnostics for it, though `gtd validate` and the `gtd step` gate still format
 and validate it like any other mode. Both halves are enforced by `gtd validate`
 and the `gtd step` gate.
 
-Herdr integration: a workflow state can declare an optional `label:` — a
-human-readable display name surfaced in `gtd next --json`/`gtd status`. The
-reference `bin/gtd` driver uses it to report its lifecycle
-(working/blocked/idle) to a [Herdr](https://herdr.dev) pane sidebar via the
-`herdr` CLI when running under Herdr (`HERDR_ENV=1`, a pane ID, and `herdr` on
-`$PATH`); outside Herdr this is a complete no-op. See
-[Driving the loop](docs/loop.md#herdr-integration-optional) for the full
-reporting contract.
+A workflow state can declare an optional `label:` — a human-readable display
+name surfaced in `gtd next --json`/`gtd status`. The reference `bin/gtd` driver
+uses it for its per-beat progress lines; an outer wrapper (a terminal
+multiplexer, a notifier) can use it the same way.
 
 ## Documentation
 

package/bin/gtd

@@ -3,33 +3,19 @@ set -euo pipefail
 
 # This file is the single published `bin` entry: `bin/gtd`. Before anything
 # else, it dispatches on $1:
-#   - `--no-edit` / `--edit` (`-e`) / `--once` / `--no-notify` (bare, or
-#     immediately after `loop`, in any order/combination — see the
-#     flag-parsing block below) -> stripped here; `--no-edit` disables the
-#     loop's automatic editor launching for this run, `--edit` forces it on
-#     for this run (overriding an ambient `GTD_NO_EDIT`/`--no-edit` — the two
-#     are mutually exclusive), `--once` restricts the loop to exactly one beat
-#     (one human gate, one script check+step, or one agent prompt+step) before
-#     exiting, and `--no-notify` (or `GTD_NO_NOTIFY`) suppresses the loop's
-#     Herdr desktop notifications for this run while leaving its silent Herdr
-#     pane-state reporting untouched. Dispatch then continues on the
-#     remaining arguments as if none of them had ever been given.
-#   - `edit [path]` -> handled entirely here in bash, never forwarded to the
-#     bundle: opens `${VISUAL:-$EDITOR}` on `path`, or (no `path` given) on the
-#     resolved rest's `.file` (or `.` when absent). Low-level plumbing now that
-#     `--edit` covers the common "force an edit, then keep driving" case; this
-#     subcommand remains for opening a specific path, or the current rest's
-#     file, WITHOUT driving the loop afterward.
-#   - `log` -> handled entirely here in bash, never forwarded to the bundle:
-#     opens `${VISUAL:-$EDITOR}` on the current repo/worktree's loop logfile
-#     (see `resolve_log_path`), refusing rather than opening an empty buffer
-#     when no loop has produced one yet.
-#   - no arguments, or exactly `loop` with no further arguments (other than the
-#     flags above) -> fall through into the loop body below (the loop protocol
-#     comment further down).
+#   - `--once` (bare, or immediately after `loop`) -> stripped here; restricts
+#     the loop to exactly one beat (one human-gate capture, one script
+#     check+step, or one agent prompt+step) before exiting. Dispatch then
+#     continues on the remaining arguments as if it had never been given.
+#   - no arguments, or exactly `loop` with no further arguments -> fall through
+#     into the loop body below (the loop protocol comment further down).
 #   - `loop` with an unrecognised extra argument -> usage error, exit 2.
 #   - anything else -> hand off to the bundle via `run_gtd`, forwarding all
 #     arguments unchanged (e.g. `bin/gtd status`, `bin/gtd step human`).
+# The loop's whole job is to drive the process until it rests at a
+# NON-AUTONOMOUS state (a human gate) or settles. Everything beyond that —
+# editors, desktop notifications, terminal-multiplexer status — is an OUTER
+# wrapper's responsibility, deliberately not this script's.
 # `run_gtd` is the ONE place that knows how to invoke "the bundle": by default
 # it resolves `dist/gtd.bundle.mjs` relative to this script's own location
 # (not cwd), but `GTD_BIN` (a dev/test override for the whole invocation
@@ -47,29 +33,11 @@ run_gtd() {
   fi
 }
 
-# Shared editor-launch helper — used by both the `edit` subcommand below and
-# the loop's human-gate flow further down. Resolves the editor git-style
-# ($VISUAL, then $EDITOR — no fallback to `vi`), then launches it blocking in
-# the foreground with the target path passed as a positional parameter
-# (never string-spliced into the command), so a multi-word command
-# (`code --wait`) and a path with special characters both work. A launch
-# failure (bad/missing editor binary) is a plain non-zero return, propagating
-# under `set -e`; the editor's own exit code is otherwise ignored entirely —
-# the outcome is judged from tree state afterward, not from this function.
-launch_editor() {
-  local target="$1" editor="${VISUAL:-${EDITOR:-}}"
-  if [[ -z "$editor" ]]; then
-    echo "gtd: no editor configured — set \$EDITOR (or \$VISUAL)" >&2
-    return 1
-  fi
-  bash -c "$editor \"\$1\"" gtd-edit "$target"
-}
-
 # ── Rendering primitives (capability detection, palette/markers, emitters) ──
-# Additive: nothing below calls these yet. `FANCY=1` only when stdout (fd 1)
-# is a real terminal AND `NO_COLOR` is unset — any pipe/redirect/non-tty
-# stdout, or `NO_COLOR` set to any value, gives plain ASCII with no escape
-# codes, per the NO_COLOR convention (https://no-color.org).
+# `FANCY=1` only when stdout (fd 1) is a real terminal AND `NO_COLOR` is unset
+# — any pipe/redirect/non-tty stdout, or `NO_COLOR` set to any value, gives
+# plain ASCII with no escape codes, per the NO_COLOR convention
+# (https://no-color.org).
 if [ -t 1 ] && [ -z "${NO_COLOR:-}" ]; then FANCY=1; else FANCY=0; fi
 
 if [[ "$FANCY" == 1 ]]; then
@@ -157,8 +125,6 @@ emit_log_pointer() {
 }
 
 # ── Git-derivation helpers (parse_subject, report_commits) ──────────────────
-# Additive: nothing below calls these yet. Replaces today's
-# head_before/head_after string comparisons in a later change.
 
 # parse_subject <subject> — sets S_ACTOR / S_FROM / S_TO / S_KIND. Patterns are
 # held in variables (rather than inlined) so bash's [[ =~ ]] doesn't need the
@@ -183,11 +149,14 @@ parse_subject() {
   fi
 }
 
-# report_commits <head_before> — walks <head_before>..HEAD in order, emitting
-# a transition/commit line per new commit; returns non-zero (having emitted
-# nothing) when there were no new commits.
+# report_commits — walks "$reported_head"..HEAD in order, emitting a
+# transition/commit line per new commit, and advances $reported_head to HEAD
+# when it reported at least one; returns non-zero (having emitted nothing,
+# and leaving $reported_head unchanged) when there were no new commits. Global
+# rather than per-beat so the review checkout window's HEAD rewinds between
+# beats never cause an already-reported commit to replay.
 report_commits() {
-  local head_before="$1" sha subject files reported=0
+  local sha subject files reported=0
   while IFS= read -r sha; do
     [[ -z "$sha" ]] && continue
     reported=1
@@ -198,11 +167,14 @@ report_commits() {
       transition) emit_transition "$S_FROM" "$S_TO" "$files" ;;
       capture | squash) emit_commit "$subject" "$files" ;;
     esac
-  done < <(git rev-list --reverse "$head_before"..HEAD)
+  done < <(git rev-list --reverse "$reported_head"..HEAD)
+  if [[ "$reported" == 1 ]]; then
+    reported_head="$(git rev-parse HEAD)"
+  fi
   [[ "$reported" == 1 ]]
 }
 
-# ── Log file (resolve_log_path, gtd log) ────────────────────────────────────
+# ── Log file (resolve_log_path) ─────────────────────────────────────────────
 
 # worktree_git_dir — the git dir of the working tree gtd is operating in,
 # derived purely from the cwd. GIT_DIR/GIT_WORK_TREE are scrubbed for this one
@@ -226,25 +198,16 @@ resolve_log_path() {
   fi
 }
 
-# --no-edit / --edit (-e) / --once / --no-notify govern only the loop driver,
-# recognised in exactly two positions — bare (e.g. `gtd --edit --once`) or
-# immediately after `loop` (e.g. `gtd loop --once`) — in any order, each at
-# most once. `--edit` and `--no-edit` are mutually exclusive (forcing and
-# suppressing the editor in the same run is not a coherent request);
-# `--no-notify` conflicts with nothing (it's orthogonal to editing and to
-# `--once`). A recognised, valid combination is stripped here before anything
-# below looks at "$@", so the bundle's own unknown-option guard never sees it;
-# anything else (an unknown flag, a duplicate/conflicting one, or a flag mixed
-# with a real subcommand) is left untouched and falls through to the existing
-# dispatch below, which forwards a non-flag first argument to the bundle
-# (whose own unknown-option guard rejects it) or rejects a `loop` invocation
-# carrying an unrecognised extra argument.
-edit_disabled=0
-edit_forced=0
+# --once governs only the loop driver, recognised in exactly two positions —
+# bare (`gtd --once`) or immediately after `loop` (`gtd loop --once`) — at
+# most once. When recognised it is stripped here before anything below looks
+# at "$@", so the bundle's own unknown-option guard never sees it; anything
+# else (an unknown flag, a duplicate --once, or --once mixed with a real
+# subcommand) is left untouched and falls through to the existing dispatch
+# below, which forwards a non-flag first argument to the bundle (whose own
+# unknown-option guard rejects it) or rejects a `loop` invocation carrying an
+# unrecognised extra argument.
 once_mode=0
-notify_disabled=0
-[[ -n "${GTD_NO_EDIT:-}" ]] && edit_disabled=1
-[[ -n "${GTD_NO_NOTIFY:-}" ]] && notify_disabled=1
 
 if [[ "${1:-}" == "loop" ]]; then
   loop_form=1
@@ -255,31 +218,17 @@ else
 fi
 
 valid_combo=1
-n_no_edit=0
-n_edit=0
 n_once=0
-n_no_notify=0
 for a in ${loop_flag_args[@]+"${loop_flag_args[@]}"}; do
   case "$a" in
-  --no-edit) n_no_edit=$((n_no_edit + 1)) ;;
-  --edit | -e) n_edit=$((n_edit + 1)) ;;
   --once) n_once=$((n_once + 1)) ;;
-  --no-notify) n_no_notify=$((n_no_notify + 1)) ;;
   *) valid_combo=0 ;;
   esac
 done
-if ((n_no_edit > 1 || n_edit > 1 || n_once > 1 || n_no_notify > 1 || (n_no_edit >= 1 && n_edit >= 1))); then
-  valid_combo=0
-fi
+((n_once > 1)) && valid_combo=0
 
-if [[ "$valid_combo" == 1 ]]; then
-  ((n_no_edit >= 1)) && edit_disabled=1
-  ((n_edit >= 1)) && edit_forced=1
-  ((n_once >= 1)) && once_mode=1
-  ((n_no_notify >= 1)) && notify_disabled=1
-  # --edit overrides an ambient GTD_NO_EDIT/--no-edit for THIS run — the
-  # explicit ask to force the editor wins over the suppressing default.
-  ((edit_forced)) && edit_disabled=0
+if [[ "$valid_combo" == 1 && "$n_once" == 1 ]]; then
+  once_mode=1
   if [[ "$loop_form" == 1 ]]; then
     set -- loop
   else
@@ -287,37 +236,6 @@ if [[ "$valid_combo" == 1 ]]; then
   fi
 fi
 
-if [[ "${1:-}" == "edit" ]]; then
-  shift
-  if [[ $# -gt 0 ]]; then
-    launch_editor "$1"
-  else
-    if ! peek_json="$(run_gtd next --json 2>&1)"; then
-      echo "gtd edit: could not determine the next step:" >&2
-      echo "$peek_json" >&2
-      exit 1
-    fi
-    file="$(jq -r '.file // empty' <<<"$peek_json")"
-    launch_editor "${file:-.}"
-  fi
-  exit 0
-fi
-
-if [[ "${1:-}" == "log" ]]; then
-  shift
-  if [[ $# -gt 0 ]]; then
-    echo "gtd log: takes no arguments" >&2
-    exit 2
-  fi
-  log_path="$(resolve_log_path)"
-  if [[ ! -f "$log_path" ]]; then
-    echo "gtd log: no loop log yet at $log_path" >&2
-    exit 1
-  fi
-  launch_editor "$log_path"
-  exit 0
-fi
-
 if [[ $# -gt 0 && "$1" != "loop" ]]; then
   run_gtd "$@"
   exit $?
@@ -326,16 +244,14 @@ if [[ "${1:-}" == "loop" && $# -gt 1 ]]; then
   echo "gtd: 'loop' takes no arguments" >&2
   exit 2
 fi
-# otherwise ($# -eq 0, or exactly "loop" with no further args, --no-edit
-# already stripped above): fall through into the existing loop body below,
-# unchanged in behavior.
+# 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
 # `gtd next --json` who's up and what they should do, dispatching on `kind`:
-#   - "message" (a human rest)  -> see handle_human_gate above: with editing on
-#     (the default) open the editor at the gate and step human, driving on a
-#     captured commit; with editing off (--no-edit/GTD_NO_EDIT), halt and tell
-#     the user what gtd is waiting on, unchanged from before this feature.
+#   - "message" (a human rest)  -> the non-autonomous halt: print the gate and
+#     exit 0. Acting on it (opening an editor, notifying, whatever) is an
+#     outer wrapper's job; this loop only ever drives the AUTONOMOUS states.
 #   - "script"  (a check rest) -> execute `content` (the emitted wrapper
 #     script) verbatim via bash — exit code deliberately ignored, the outcome
 #     lives in the tree — then `gtd step <actor>` to capture it; zero new
@@ -362,118 +278,16 @@ fi
 # resume-or-fresh flag are exported as $GTD_LOOP_MEMORY / $GTD_LOOP_SESSION_ID
 # / $GTD_LOOP_MEMORY_RESUME; the default adapter turns them into
 # `--resume`/`--session-id`. An adapter that ignores them keeps working.
-herdr_ok() { [ "${HERDR_ENV:-}" = 1 ] && [ -n "${HERDR_PANE_ID:-}" ] && command -v herdr >/dev/null 2>&1; }
-
-# Run a `herdr` invocation best-effort. Normally output is discarded and a
-# failure is swallowed (`|| true`) so a missing/incompatible herdr never blocks
-# the loop. Set GTD_HERDR_DEBUG=1 to instead surface every call and its exit
-# code on stderr — the escape hatch that makes a silent CLI-signature mismatch
-# (e.g. an arg herdr rejects) visible again.
-herdr_run() {
-  if [ "${GTD_HERDR_DEBUG:-}" = 1 ]; then
-    printf 'gtd/herdr: %s\n' "$*" >&2
-    herdr "$@" >&2
-    printf 'gtd/herdr: exit=%s\n' "$?" >&2
-  else
-    herdr "$@" >/dev/null 2>&1 || true
-  fi
-}
-
-# NOTE: herdr requires the positional <PANE_ID> BEFORE the options for
-# `pane` subcommands — passing it last makes herdr reject the first option as
-# `unknown option` (exit 2). Keep the pane id first here.
-herdr_report() {  # $1=state (working|blocked|idle)  $2=message
-  herdr_ok || return 0
-  herdr_run pane report-agent "$HERDR_PANE_ID" \
-    --source herdr:gtd --agent gtd --state "$1" --message "$2"
-}
-
-# Suppressible via GTD_NO_NOTIFY/--no-notify (set into $notify_disabled at
-# parse time, above) — the OS popup this call makes is the only thing that
-# opts out; herdr_report/herdr_release (silent sidebar status) are unaffected.
-herdr_notify() {  # $1=title  $2=body
-  [[ "$notify_disabled" == 1 ]] && return 0
-  herdr_ok || return 0
-  herdr_run notification show "$1" --body "$2" --sound request
-}
-
-herdr_release() {  # hand the pane back to Herdr's normal detection
-  herdr_ok || return 0
-  herdr_run pane release-agent "$HERDR_PANE_ID" --source herdr:gtd --agent gtd
-}
-
-# Shared human-gate handler for a "message" (human) rest — used both by the
-# opening move (when editing is on) and by every "message" rest the main loop
-# encounters. $1 is the rest's `next --json` blob.
-#
-# Editing OFF ($edit_disabled): today's behavior, unchanged — render the gate
-# via emit_gate and exit 0 without touching an editor.
-#
-# Editing ON (the default): open the editor on the rest's `.file` (or `.` when
-# absent), wait for it to exit, then run `gtd step human`:
-#   - a NEW commit was authored -> return normally so the caller keeps driving.
-#   - ZERO commits were authored -> halt, exit 0 (closing the editor without a
-#     capturable change means "done for now" — and keeps a gate with no `C`
-#     pattern, e.g. idle, from being reopened forever).
-#   - the step REFUSES (non-zero exit: malformed steering file, unfinished
-#     review) -> surface it verbatim and halt, exit non-zero — the same
-#     wording an opening-move refusal already used before this function
-#     existed.
-handle_human_gate() {
-  local json="$1" file label state step_out head_before head_after
-  label="$(jq -r '.label // .state' <<<"$json")"
-  state="$(jq -r .state <<<"$json")"
-
-  if [[ "$edit_disabled" == 1 ]]; then
-    herdr_report blocked "$label"
-    herdr_notify "gtd needs you — $(basename "$PWD")" "$label"
-    emit_gate "$state" "$label"
-    run_gtd next
-    exit 0
-  fi
-
-  file="$(jq -r '.file // empty' <<<"$json")"
-  herdr_report blocked "$label"
-  launch_editor "${file:-.}"
-  herdr_report working "$label"
-
-  head_before="$(git rev-parse HEAD 2>/dev/null || echo none)"
-  if ! step_out="$(run_gtd step human 2>&1)"; then
-    emit_error "could not capture your changes at the human gate:
-$step_out
-Fix the reported issue and re-run gtd-loop."
-    emit_log_pointer
-    exit 1
-  fi
-  head_after="$(git rev-parse HEAD 2>/dev/null || echo none)"
-  if [[ "$head_before" == "$head_after" ]]; then
-    herdr_report idle "$label"
-    herdr_release
-    emit_action "$M_HUMAN" "done for now (nothing captured)"
-    exit 0
-  fi
-  # A new commit was captured — render it, then return normally so the
-  # caller keeps driving, unless --once says this one human gate is the whole
-  # run.
-  report_commits "$head_before"
-  if [[ "$once_mode" == 1 ]]; then
-    exit 0
-  fi
-}
-
-trap 'code=$?; if [ "$code" -ne 0 ]; then
-        herdr_report blocked "${GTD_LAST_LABEL:-stopped}: exited $code"
-        herdr_notify "gtd stopped — $(basename "$PWD")" "${GTD_LAST_LABEL:-loop} failed (exit $code)"
-      fi' EXIT
 
 prev_state=""
 prev_content=""
+prev_head=""
 # Where the last "prompt" turn's `memory` scope + session id are remembered
 # across iterations and across restarts. In the git dir, never the work tree.
 memory_marker="$(worktree_git_dir 2>/dev/null || echo .git)/gtd-loop-memory"
 
 # Truncated once here (not every iteration), so the file always reflects the
-# current run but survives after the loop exits for a later `gtd log`.
+# current run but survives after the loop exits.
 log_path="$(resolve_log_path)"
 : >"$log_path"
 export GTD_LOOP_LOG="$log_path"
@@ -512,6 +326,12 @@ run_agent_turn() {
     >>"${GTD_LOOP_LOG:-/dev/null}" 2>&1
 }
 
+# The furthest commit already reported to the terminal by report_commits (see
+# its own comment) — a global high-water mark rather than a per-beat
+# head_before, so a review checkout window's HEAD rewind between beats never
+# causes an already-printed transition to replay.
+reported_head="$(git rev-parse HEAD 2>/dev/null || echo none)"
+
 # Opening move: capture the human's pending edit so gtd-loop is the ONLY command
 # a human runs. A human acts at a gate by editing files (a plan answer, a review
 # tick, a code fix) and re-launching the loop — they should never have to run
@@ -525,16 +345,9 @@ run_agent_turn() {
 # and a mid-cycle restart must simply resume driving, not fail. A clean gate is
 # a harmless no-op; a genuine refusal there (a malformed steering file, or an
 # edit no `on` pattern accepts) is surfaced and stops the loop rather than being
-# driven past.
-#
-# Editing ON: route through the exact same gate logic the main loop uses below
-# (open the editor there first, THEN step) instead of blindly stepping human
-# and moving on. Editing OFF: unchanged from before this function existed —
-# step silently, refusal surfaced and halts, a clean/committed gate just falls
-# into the loop below. Either way, --once treats a captured commit here as the
-# run's one beat and exits (see handle_human_gate's own once-mode exit for the
-# editing-ON path); a clean/no-op gate captures nothing, so it isn't a beat —
-# it falls into the loop below exactly as it would without --once.
+# driven past. --once treats a captured commit here as the run's one beat and
+# exits; a clean/no-op gate captures nothing, so it isn't a beat — it falls
+# into the loop below exactly as it would without --once.
 if ! peek_json="$(run_gtd next --json 2>&1)"; then
   emit_error "could not determine the next step:
 $peek_json
@@ -544,29 +357,20 @@ Run \`gtd status\` to inspect the repo."
 fi
 peek_kind="$(jq -r .kind <<<"$peek_json")"
 if [[ "$peek_kind" == "message" ]]; then
-  if [[ "$edit_disabled" == 1 ]]; then
-    opening_head_before="$(git rev-parse HEAD 2>/dev/null || echo none)"
-    if ! step_out="$(run_gtd step human 2>&1)"; then
-      emit_error "could not capture your changes at the human gate:
+  opening_head_before="$(git rev-parse HEAD 2>/dev/null || echo none)"
+  if ! step_out="$(run_gtd step human 2>&1)"; then
+    emit_error "could not capture your changes at the human gate:
 $step_out
 Fix the reported issue and re-run gtd-loop."
-      emit_log_pointer
-      exit 1
-    fi
-    if [[ "$once_mode" == 1 && "$opening_head_before" != "$(git rev-parse HEAD 2>/dev/null || echo none)" ]]; then
-      exit 0
-    fi
-  else
-    handle_human_gate "$peek_json"
+    emit_log_pointer
+    exit 1
   fi
-elif [[ "$edit_forced" == 1 ]]; then
-  # Honesty caveat: a forced edit only means something at a human gate — the
-  # machine isn't resting at one right now, so say so instead of pretending,
-  # and just keep driving.
-  if [[ "$FANCY" == 1 ]]; then
-    printf '%sℹ️  --edit: not at a human gate yet — continuing to drive%s\n' "$C_DIM" "$C_RESET"
-  else
-    printf '%s--edit: not at a human gate yet — continuing to drive%s\n' "$C_DIM" "$C_RESET"
+  # This branch reports nothing — advance the marker past whatever was just
+  # (silently) captured so the first loop-body beat below doesn't newly
+  # print it.
+  reported_head="$(git rev-parse HEAD 2>/dev/null || echo none)"
+  if [[ "$once_mode" == 1 && "$opening_head_before" != "$reported_head" ]]; then
+    exit 0
   fi
 fi
 
@@ -585,20 +389,18 @@ while true; do
   model="$(jq -r '.model // empty' <<<"$next_json")"
   memory="$(jq -r '.memory // empty' <<<"$next_json")"
   label="$(jq -r '.label // .state' <<<"$next_json")"
-  GTD_LAST_LABEL="$label"
 
   if [[ "$kind" == "message" ]]; then
-    # handle_human_gate exits 0/non-zero itself on a halt/refusal; it only
-    # returns here when a new commit was captured, so we keep driving.
-    handle_human_gate "$next_json"
-    continue
+    # The non-autonomous halt: print the gate, hand off, exit 0. The human
+    # (or an outer wrapper) edits and re-launches; the opening move above
+    # captures what they left.
+    emit_gate "$state" "$label"
+    run_gtd next
+    exit 0
   fi
 
-  herdr_report working "$label"
-
   if [[ "$kind" == "script" ]]; then
     emit_action "$M_CHECK" "$label"
-    head_before="$(git rev-parse HEAD 2>/dev/null || echo none)"
     # 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
@@ -611,9 +413,7 @@ while true; do
       exit 1
     fi
     printf '%s\n' "$step_out" >>"$GTD_LOOP_LOG"
-    if ! report_commits "$head_before"; then
-      herdr_report idle "$label"
-      herdr_release
+    if ! report_commits; then
       emit_settled "$state"
       exit 0
     fi
@@ -626,9 +426,14 @@ while true; do
   fi
 
   # kind == "prompt": stall detection (skills/loop/SKILL.md) — the same
-  # agent-owned state and content repeating means the last dispatch made no
-  # progress; stop rather than spin on it.
-  if [[ "$state" == "$prev_state" && "$content" == "$prev_content" ]]; then
+  # 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
+  # stall from a return lap back into the same state (e.g. checking ->
+  # fixing): a static prompt looks identical to last time, but a commit
+  # landed in between, so HEAD has moved and this isn't a stall.
+  cur_head="$(git rev-parse HEAD 2>/dev/null || echo none)"
+  if [[ "$state" == "$prev_state" && "$content" == "$prev_content" && "$cur_head" == "$prev_head" ]]; then
     next_out="$(run_gtd next 2>&1)" || true
     emit_error "no progress at '$state' — the agent's last turn changed nothing. Stopping to avoid spinning.
 $next_out"
@@ -637,6 +442,7 @@ $next_out"
   fi
   prev_state="$state"
   prev_content="$content"
+  prev_head="$cur_head"
 
   # Agent-memory scope: compare this turn's `memory` label against the last
   # prompt turn's (persisted in $memory_marker). Same non-empty label AND a
@@ -673,7 +479,6 @@ $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"
-  head_before="$(git rev-parse HEAD 2>/dev/null || echo none)"
   run_agent_turn "$content" "$resume"
 
   fix_attempt=0
@@ -704,7 +509,7 @@ Stopping rather than stepping with a malformed steering file."
   # A no-op step (nothing matched a declared pattern on a clean tree) reports
   # zero commits here — report_commits returns non-zero, and that's fine: the
   # NEXT iteration's stall check is what catches unchanged state/content.
-  report_commits "$head_before" || true
+  report_commits || true
   if [[ "$once_mode" == 1 ]]; then
     exit 0
   fi

package/dist/gtd.bundle.mjs

@@ -205450,12 +205450,9 @@ Commands:
   (no command), loop
                    Launch the loop driver (bin/gtd), which repeatedly drives
                    an agent through gtd next/gtd step calls until the
-                   workflow returns to its initial state again. A bare gtd
-                   invocation and gtd loop both launch it identically
-  edit [path]      Open \${VISUAL:-$EDITOR} on <path>, or — with no path — on
-                   the resolved rest's declared file (or the repo directory
-                   if it declares none). Handled entirely by bin/gtd, not
-                   this bundle
+                   workflow rests at a human gate (a non-autonomous state)
+                   or settles. A bare gtd invocation and gtd loop both
+                   launch it identically
   init             Scaffold a minimal .gtdrc.json for this repo, seeding the
                    default variables you are most likely to change (the test
                    command) and a Prettier formatting suggestion. gtd runs its

package/docs/cli.md

@@ -7,8 +7,9 @@ Commands:
   (no command), loop
                    Launch the loop driver (bin/gtd), which repeatedly drives
                    an agent through gtd next/gtd step calls until the
-                   workflow returns to its initial state again. A bare gtd
-                   invocation and gtd loop both launch it identically
+                   workflow rests at a human gate (a non-autonomous state)
+                   or settles. A bare gtd invocation and gtd loop both
+                   launch it identically
   init             Scaffold a minimal .gtdrc.json for this repo, seeding the
                    default variables you are most likely to change (the test
                    command) and a Prettier formatting suggestion. gtd runs its
@@ -45,12 +46,6 @@ Commands:
                    commits that would be lost
   next             Print the resolved rest's rendered script/prompt/message
                    (no mutation)
-  edit [path]      Open <path> (repo-relative) in $VISUAL/$EDITOR, blocking
-                   until the editor exits. With no argument, opens the
-                   resolved rest's declared file (or the repo root if it
-                   declares none). Never reads --no-edit/--edit/GTD_NO_EDIT.
-                   Low-level plumbing — --edit covers the common "force an
-                   edit, then keep driving" case
   status           Print the resolved rest's state/actor and which declared
                    pattern (if any) each pending change matches (no mutation)
   validate         Format and validate the steering file the resolved rest
@@ -69,15 +64,9 @@ Options:
   --no-open        (gtd visualize only) do not open the browser
   --cost=<n>       (gtd step only) record the invocation's token cost
   --model=<name>   (gtd step only, with --cost) tag that cost's model
-  --no-edit        (bare gtd or gtd loop only) disable the loop's automatic
-                   editor launching at human gates
-  --edit, -e       (bare gtd or gtd loop only) force the editor open at the
-                   current human gate, overriding --no-edit/GTD_NO_EDIT; a
-                   no-op note (not an error) when not at a human gate
   --once           (bare gtd or gtd loop only) run exactly one loop beat (one
-                   human gate, one script check+step, or one agent
-                   prompt+step), then exit — combines freely with
-                   --edit/--no-edit
+                   human-gate capture, one script check+step, or one agent
+                   prompt+step), then exit
   --version, -v    Print version and exit
   --help, -h       Print this help and exit
 ```
@@ -101,49 +90,30 @@ to plain-text mode. A bare `--cost`/`--model` with no value, a non-numeric or
 negative `--cost`, an empty `--model`, `--model` without `--cost`, or either
 flag on any command other than `gtd step` are all usage errors.
 
-`--no-edit`, `--edit`/`-e`, and `--once` are separate, bash-level flags handled
-entirely by `bin/gtd` itself, stripped before anything reaches the bundle — see
-below.
-
-## `--no-edit`, `--edit`, `--once`
-
-Three flags on the loop driver only (`--edit` also has the short form `-e`),
-each recognized bare (`gtd --no-edit`) or immediately after `loop`
-(`gtd loop --no-edit`) — the two positions are equivalent, since bare `gtd` and
-`gtd loop` are themselves equivalent. All three combine freely with each other,
-in any order (e.g. `gtd --edit --once`, `gtd loop --once --edit`), except
-`--edit`/`--no-edit` together, which conflict (forcing and suppressing the
-editor in the same run is not a coherent request). Any other placement (e.g.
-`gtd step --once`), a duplicated flag (`gtd --once --once`), or the
-`--edit`/`--no-edit` conflict is a usage error, surfaced via whatever guard the
-misplaced argument first reaches (the compiled bundle's own
-unknown-option/unknown-command rejection for a misplaced flag, or
+`--once` is a separate, bash-level flag handled entirely by `bin/gtd` itself,
+stripped before anything reaches the bundle — see below.
+
+## `--once`
+
+A flag on the loop driver only, recognized bare (`gtd --once`) or immediately
+after `loop` (`gtd loop --once`) — the two positions are equivalent, since bare
+`gtd` and `gtd loop` are themselves equivalent. Any other placement (e.g.
+`gtd step --once`) or a duplicated flag (`gtd --once --once`) is a usage error,
+surfaced via whatever guard the misplaced argument first reaches (the compiled
+bundle's own unknown-option/unknown-command rejection for a misplaced flag, or
 `gtd: 'loop' takes no arguments` for one misplaced after `loop`) — never
-silently ignored or silently resolved one way.
-
-**`--no-edit`** (or the `GTD_NO_EDIT` environment variable, any non-empty value)
-disables the loop's default behavior of launching an editor at human gates,
-restoring the halt-and-print-and-exit behavior with no editor involved.
-
-**`--edit`** (`-e`) is `--no-edit`'s mirror: it forces the editor open at the
-current human gate, overriding an ambient `GTD_NO_EDIT`/`--no-edit` default for
-this one run. It is only meaningful when the machine currently rests at a human
-gate — the honesty caveat: at any other rest, forcing an edit is undefined, so
-`bin/gtd` prints a note that it isn't at a human gate yet and simply keeps
-driving, rather than pretending to force something. Both flags govern only the
-loop's own automatic launching — `gtd edit` invoked directly never reads either
-(see [`gtd edit`](#gtd-edit-path) above).
-
-**`--once`** restricts the loop to exactly one beat — one human gate, one script
-check+step, or one agent prompt+step — then exits, instead of driving all the
-way back to idle/settled. Precisely: at most one commit/transition is made;
-whichever of the three kinds the currently-resolved rest is, that one gets
+silently ignored.
+
+**`--once`** restricts the loop to exactly one beat — one human-gate capture,
+one script check+step, or one agent prompt+step — then exits, instead of driving
+all the way back to idle/settled. Precisely: at most one commit/transition is
+made; whichever of the three kinds the currently-resolved rest is, that one gets
 processed (including any internal `gtd validate` fix-reprompt rounds a producing
 agent turn needs — those are all part of finishing the ONE prompt beat, not
 separate beats) and the loop exits 0 immediately after, without re-peeking at
 what comes next. A clean human gate with nothing to capture (the opening move's
-silent capture attempt under `--no-edit`, or a no-op editor session) is not a
-beat and falls through to the driver's ordinary halt, same as without `--once`.
+silent capture attempt) is not a beat and falls through to the driver's ordinary
+halt, same as without `--once`.
 
 See [Driving the loop](loop.md) and `skills/loop/SKILL.md` for the full
 gate-flow description.
@@ -470,46 +440,6 @@ which are JSON-only. `--json` emits
   when the state has no `on` (a commit state); a per-edge `describe` is likewise
   omitted when that edge declares none.
 
-## `gtd edit [path]`
-
-Low-level plumbing: for the common case of "force an edit at the current human
-gate, then keep driving the loop", use `--edit` (below) instead. `gtd edit`
-itself only opens an editor on a path — it never drives anything afterward,
-which makes it the right tool for opening a SPECIFIC path (or peeking at the
-current rest's file) without starting a loop.
-
-Handled entirely in `bin/gtd`'s own bash — unlike every other subcommand, it is
-**never forwarded** to the compiled bundle (`dist/gtd.bundle.mjs`).
-
-With `<path>` given (repo-relative), opens it in `${VISUAL:-$EDITOR}` (git's own
-precedence — `$VISUAL` first, then `$EDITOR`; no fallback to `vi`), blocking in
-the foreground until the editor exits. It creates nothing if `<path>` doesn't
-exist — the path is handed straight to the editor command verbatim. The editor's
-own exit code is ignored entirely; success is judged from tree state afterward,
-not from this command.
-
-With no argument, it peeks with `gtd next --json` to find the resolved rest's
-declared `.file`, and opens that (repo-relative), or the repo directory (`.`)
-when the resolved state declares no `file:`. If `gtd next --json` itself fails
-(e.g. not in a repo), it prints an error and exits non-zero without attempting
-to open an editor:
-
-```
-gtd edit: could not determine the next step:
-<gtd next --json's own error output>
-```
-
-`gtd edit` **never** reads `--no-edit`/`--edit`/`GTD_NO_EDIT` — those govern
-only the loop's own automatic editor launching at human gates (see
-[Driving the loop](loop.md) and `skills/loop/SKILL.md`), not this command.
-Invoked directly, `gtd edit` always launches, unconditionally.
-
-If neither `$VISUAL` nor `$EDITOR` is set, no editor is launched:
-
-```
-gtd: no editor configured — set $EDITOR (or $VISUAL)
-```
-
 ## Running `script` rests (no `gtd` subcommand)
 
 There is no `gtd` subcommand that executes a workflow script — gtd never runs a

package/docs/loop.md

@@ -52,38 +52,17 @@ capture happens within the same run or a later one. A review nobody is going to
 finish is ended with [`gtd abandon`](cli.md#gtd-abandon---json), which drops the
 process's commits and keeps their content as uncommitted changes.
 
-**Editing is on by default.** Reaching a `"message"` rest, `bin/gtd` opens
-`${VISUAL:-$EDITOR}` on the rest's declared `.file` (or the repo root `.` when
-the state declares none), blocking until the editor exits, then runs
-`gtd step human` to capture whatever changed:
-
-- a new commit was captured → the loop keeps driving on its own; re-launching is
-  never necessary;
-- zero commits were captured (a clean tree once the editor closed) → the loop
-  halts, exit 0 — "done for now";
-- the step refuses (a malformed steering file, or an edit matching no declared
-  pattern) → the refusal is surfaced verbatim and the loop halts non-zero,
-  exactly as a manual `gtd step human` refusal would.
-
-Set `GTD_NO_EDIT` (any non-empty value), or pass `--no-edit` — see
-[`cli.md`](cli.md#--no-edit---edit---once) for its exact syntax and positioning
-— to disable this and restore the original halt-and-print behavior: the loop
-prints the gate via `gtd next` and exits 0 without touching an editor, leaving
-the human to edit and re-launch the loop themselves.
-
-Pass `--edit` (`-e`) to force the editor open at the current human gate right
-now, overriding an ambient `GTD_NO_EDIT`/`--no-edit` for this one run — useful
-when a shell profile sets `GTD_NO_EDIT` by default but you want to edit
-interactively just this once. It only means something when the machine is
-actually resting at a human gate: at any other rest, `bin/gtd` prints a note
-that it isn't at one yet and simply keeps driving, rather than pretending to
-force something undefined.
-
-Pass `--once` to restrict the loop to exactly one beat — one human gate, one
-script check+step, or one agent prompt+step — then exit, instead of driving all
-the way to idle/settled. It combines freely with `--edit`/`--no-edit` (e.g.
-`gtd --edit --once` forces the editor at the current gate, captures the edit,
-and stops right there rather than continuing to drive).
+**The loop drives only the autonomous states.** Reaching a `"message"` rest, it
+prints the gate via `gtd next` and exits 0 — the human edits and re-launches the
+loop, whose opening move captures what they left. Anything richer at that
+boundary (opening an editor on the gate's file, desktop notifications,
+terminal-multiplexer status) is deliberately an OUTER wrapper's responsibility,
+not `bin/gtd`'s.
+
+Pass `--once` — see [`cli.md`](cli.md#--once) for its exact syntax and
+positioning — to restrict the loop to exactly one beat — one human-gate capture,
+one script check+step, or one agent prompt+step — then exit, instead of driving
+all the way to idle/settled.
 
 ```bash
 gtd next --json   # ask who's up and what they should do
@@ -106,21 +85,17 @@ when the machine rests at a `"message"` gate — so `gtd` is the only command a
 human runs. `bin/gtd` is the packaged entry point: invoked bare, or with `loop`
 as its first argument, it runs this exact script; any other first argument (e.g.
 `next`, `step`, `status`) hands off to `node dist/gtd.bundle.mjs` instead. The
-loop body it runs adds six things on top of the reference script above: it opens
-an editor at every `"message"` gate instead of just printing it (see "Editing is
-on by default" above; `--no-edit`/`GTD_NO_EDIT` fall back to the reference
-script's plain print-and-exit, while `--edit`/`-e` forces it on for this run
-even over an ambient `GTD_NO_EDIT`); it can restrict itself to exactly one beat
-via `--once` instead of driving to idle/settled; it stops with a diagnostic if
-the same `"prompt"` state/content repeat with no progress (see
-`skills/loop/SKILL.md`'s "Stall detection"); it lets `GTD_LOOP_AGENT_CMD` swap
-in any coding agent CLI in place of the default `claude -p`, receiving the
-prompt via `$GTD_LOOP_PROMPT`; it exports the resolved state's optional `model`
-hint as `$GTD_LOOP_MODEL`, appending `--model "$GTD_LOOP_MODEL"` to the default
-`claude -p` invocation whenever it's non-empty; and it acts on the optional
-`memory` scope hint (see "Agent memory scope" below) — continuing one agent
-session across consecutive same-scope turns and starting fresh when the scope
-changes.
+loop body it runs adds five things on top of the reference script above: it can
+restrict itself to exactly one beat via `--once` instead of driving to
+idle/settled; it stops with a diagnostic if the same `"prompt"` state/content
+repeat with no progress (see `skills/loop/SKILL.md`'s "Stall detection"); it
+lets `GTD_LOOP_AGENT_CMD` swap in any coding agent CLI in place of the default
+`claude -p`, receiving the prompt via `$GTD_LOOP_PROMPT`; it exports the
+resolved state's optional `model` hint as `$GTD_LOOP_MODEL`, appending
+`--model "$GTD_LOOP_MODEL"` to the default `claude -p` invocation whenever it's
+non-empty; and it acts on the optional `memory` scope hint (see "Agent memory
+scope" below) — continuing one agent session across consecutive same-scope turns
+and starting fresh when the scope changes.
 
 `bin/gtd` resolves both its bundle hand-off and the loop's own internal `gtd`
 calls against `dist/gtd.bundle.mjs` next to its own location. Set `GTD_BIN` — a
@@ -181,11 +156,8 @@ The driver — not the prompt text — owns ending the agent's turn
 (`gtd step "$actor"` right after the agent acts): every default-workflow agent
 prompt says explicitly not to run `gtd step agent` itself.
 
-`bin/gtd log` opens the current repo/worktree's loop logfile —
-`"$(worktree_git_dir)/gtd-loop.log"` by default, or `$GTD_LOOP_LOG` verbatim
-when set — in `${VISUAL:-$EDITOR}`, the same editor resolution `bin/gtd edit`
-uses. It takes no arguments and errors out (rather than opening an empty buffer)
-if no loop has produced a log yet. `worktree_git_dir` derives the git dir from
+The loop's logfile lives at `"$(worktree_git_dir)/gtd-loop.log"` by default, or
+`$GTD_LOOP_LOG` verbatim when set. `worktree_git_dir` derives the git dir from
 the cwd with `GIT_DIR`/`GIT_WORK_TREE` scrubbed, so an inherited `GIT_DIR`
 (leaked from a parent git process, a hook, or another worktree's shell) can
 never key the log — or the loop's memory marker — to a different worktree; two
@@ -205,8 +177,8 @@ by a `📄 see <log>` pointer (plain: `see <log>`).
 The three previously terminal-visible subprocess streams — the agent turn's own
 output, the check script's own output, and `gtd step`'s own output — are no
 longer printed directly: they're appended to the per-repo/per-worktree log file
-(truncated once at the start of the run) instead, and surfaced with
-`bin/gtd log` above.
+(truncated once at the start of the run) instead — the loop prints the log's
+path as its first line, ready to `tail -f`.
 
 ## Agent memory scope
 
@@ -245,45 +217,3 @@ example, to drive a different agent CLI:
 ```bash
 GTD_LOOP_AGENT_CMD='my-agent-cli --prompt "$GTD_LOOP_PROMPT"' gtd
 ```
-
-## Herdr integration (optional)
-
-`bin/gtd` optionally reports its lifecycle to [Herdr](https://herdr.dev) (a
-terminal multiplexer for coding agents) via a `herdr` CLI binary, entirely at
-the driver's edge — gtd core never talks to Herdr. Every call is best-effort
-(guarded, output discarded, `|| true`), so a missing/failing `herdr` binary
-never blocks, slows, or fails the loop. Because that guard also hides a herdr
-CLI-signature mismatch, set `GTD_HERDR_DEBUG=1` to surface every `herdr` call
-and its exit code on stderr instead.
-
-The reporting is a no-op unless all three guard conditions hold: `HERDR_ENV=1`,
-a non-empty `$HERDR_PANE_ID`, and `herdr` on `$PATH`. When they do, `gtd` makes
-three kinds of calls (note the positional `<PANE_ID>` comes BEFORE the options —
-herdr's `pane` subcommands reject a trailing pane id):
-
-- `herdr pane report-agent "$HERDR_PANE_ID" --source herdr:gtd --agent gtd --state <state> --message <label>`
-- `herdr pane release-agent "$HERDR_PANE_ID" --source herdr:gtd --agent gtd`
-- `herdr notification show <title> --body <label> --sound request`
-
-mapped onto the loop's states like this:
-
-| Loop moment                                                                          | Call(s)                                                                  |
-| ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------ |
-| Top of every non-`"message"` iteration                                               | `report-agent --state working`                                           |
-| Right before halting at a `"message"` (human) gate (editing off)                     | `report-agent --state blocked` + `notification show`                     |
-| While the editor is open at a human gate (editing on)                                | `report-agent --state blocked`, flipped back to `working` once it closes |
-| Right before a clean settle (a script rest, zero new commits)                        | `report-agent --state idle` + `release-agent`                            |
-| Any non-zero exit (stall guard, validate-cap, `gtd next` failure, unhandled failure) | `report-agent --state blocked` + `notification show`, via an `EXIT` trap |
-
-`working`/`blocked` reports use the resolved rest's `label` (falling back to
-`state`, per the field above); the trap falls back to `$GTD_LAST_LABEL`, the
-label tracked from the last completed iteration, when it fires outside the
-normal per-iteration flow. `report-agent` claims display authority for the
-`herdr:gtd` source, so `working` is re-reported every lap rather than once, to
-stay fresh against Herdr's own heuristic detection of the inner agent process.
-
-Set `GTD_NO_NOTIFY` (any non-empty value) or pass `--no-notify` to suppress the
-two `notification show` calls above (the human-gate halt and the exit trap) for
-this run — the OS popup + sound only. `report-agent`/`release-agent` (the silent
-Herdr sidebar status) are untouched either way, mirroring
-`--no-edit`/`GTD_NO_EDIT`'s flag/env shape.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "7.11.1",
+  "version": "8.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {