@oneie/claude 0.6.0 → 0.8.0

package/scripts/do-preflight.sh

@@ -0,0 +1,117 @@
+#!/usr/bin/env bash
+# do-preflight.sh <slug> [--fix] — refuse to launch a plan into a broken environment.
+#
+# manifest: needs-env
+#
+# WHY. Every expensive failure on 2026-08-31 was an ENVIRONMENT fault discovered
+# only AFTER the run had spent itself:
+#
+#   - an unreachable model made W2 return nothing; W3 edited nothing, W4 verified
+#     an empty diff, and the plan reported "batch total loss". 41 agents and 3.7M
+#     tokens to learn that a model name was wrong.
+#   - `.env` was not linked into the worktree, so real-TypeDB tests failed with
+#     no_gateway_key and two verifiers hand-classified 4-7 red files as
+#     "environmental" before they could score their gate.
+#   - four abandoned gates held the box at load 138 and one held a governor slot,
+#     so live cycles starved and verifiers began SKIPPING their gates and passing
+#     cycles anyway.
+#   - a cycle line the writers could tick was invisible to the engine's reader.
+#
+# Not one of those is a code defect, and every one is checkable in seconds. This
+# is the cheap deterministic gate that runs first, so a run is never spent
+# discovering something a grep could have said.
+#
+# Exit 0 = safe to launch. Exit 1 = a blocker (do not launch). Exit 2 = usage.
+set -uo pipefail
+
+SLUG="${1:-}"; shift 2>/dev/null || true
+FIX=0
+for f in "$@"; do case "$f" in --fix) FIX=1 ;; esac; done
+[ -n "$SLUG" ] || { echo "usage: do-preflight.sh <slug> [--fix]" >&2; exit 2; }
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+WT="$ROOT/.do-worktrees/$SLUG"
+bad=0; warn=0
+ok()   { printf '  ok    %s\n' "$1"; }
+fail() { printf '  FAIL  %s\n' "$1"; bad=$((bad+1)); }
+note() { printf '  warn  %s\n' "$1"; warn=$((warn+1)); }
+
+echo "do-preflight: $SLUG"
+
+# 1. The plan must PARSE. do-plan-json refuses (non-zero, no stdout) on a plan
+#    missing worktree/outcome/batches/cycles, which is the failure that used to
+#    surface as an LLM summarising a 30KB file down to 6.8KB.
+if plan=$(node "$ROOT/.claude/scripts/do-plan-json.mjs" "$SLUG" 2>&1); then
+  ok "plan parses ($(printf '%s' "$plan" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(len(d["cycles"]), "cycles,", len(d["batches"]), "batches")' 2>/dev/null || echo 'ok'))"
+else
+  fail "plan does not parse: $(printf '%s' "$plan" | head -1)"
+fi
+
+# 2. Worktree + the gitignored deps a worktree cannot inherit. A missing .env is
+#    not a slow test -- it makes a verifier argue with its own gate and teaches
+#    whoever reads the report that red is normal.
+if [ -d "$WT" ]; then
+  ok "worktree present"
+  for dep in .env node_modules; do
+    for where in "one.ie/web/$dep" "$dep"; do
+      [ -e "$ROOT/$where" ] || continue
+      if [ -e "$WT/$where" ]; then ok "linked: $where"; else
+        if [ "$FIX" = "1" ]; then
+          mkdir -p "$(dirname "$WT/$where")" && ln -s "$ROOT/$where" "$WT/$where" 2>/dev/null \
+            && ok "linked: $where (repaired)" || fail "could not link $where"
+        else
+          fail "MISSING in worktree: $where — real-infra tests will fail as 'environmental'. Re-run with --fix"
+        fi
+      fi
+      break
+    done
+  done
+else
+  note "no worktree yet at .do-worktrees/$SLUG (do-auto --setup-only will cut one)"
+fi
+
+# 3. The cycle-line shape must agree across its four implementations, or the
+#    engine reads a different set of open cycles than the writers can tick.
+if bash "$ROOT/.claude/scripts/do-cycle-shape-check.sh" >/dev/null 2>&1; then
+  ok "cycle-line shape parity (reader == writer)"
+else
+  fail "cycle-shape parity RED — run .claude/scripts/do-cycle-shape-check.sh"
+fi
+
+# 4. A workflow with a syntax error does not fail loudly; it never launches.
+if node "$ROOT/.claude/scripts/wf-check.mjs" >/dev/null 2>&1; then
+  ok "workflow scripts parse + seam checks"
+else
+  fail "wf-check RED — run node .claude/scripts/wf-check.mjs"
+fi
+
+# 5. The box. A saturated box is why verifiers started skipping gates and
+#    reporting passes anyway, so this is an ACCURACY check, not only a speed one.
+orph=$(bash "$ROOT/.claude/scripts/gate-reaper.sh" --once --dry-run 2>/dev/null | grep -c 'WOULD reap' || true)
+if [ "${orph:-0}" -gt 0 ]; then
+  if [ "$FIX" = "1" ]; then
+    bash "$ROOT/.claude/scripts/gate-reaper.sh" --once >/dev/null 2>&1
+    ok "reaped ${orph} abandoned gate(s)"
+  else
+    fail "${orph} abandoned gate(s) burning the box — re-run with --fix, or gate-reaper.sh --once"
+  fi
+else
+  ok "no abandoned gates"
+fi
+
+head=$(bash -c ". '$ROOT/.claude/scripts/lib/govern.sh'; gate_headroom" 2>/dev/null || echo 99)
+loadi=$(uptime | sed -E 's/.*load averages?: ([0-9.]+).*/\1/' | cut -d. -f1)
+cores=$(sysctl -n hw.ncpu 2>/dev/null || echo 8)
+if [ "${loadi:-0}" -gt $(( cores * 3 )) ]; then
+  note "load ${loadi} on ${cores} cores — gates will run slow; the governor will queue them"
+else
+  ok "load ${loadi} on ${cores} cores, memory funds ${head} concurrent cycle(s)"
+fi
+
+echo
+if [ "$bad" -gt 0 ]; then
+  echo "do-preflight: $bad blocker(s) — DO NOT LAUNCH. Every one of these is cheaper to fix now than to discover mid-run."
+  exit 1
+fi
+echo "do-preflight: clear${warn:+ ($warn warning(s))} — safe to launch $SLUG"
+exit 0

package/scripts/do-project.sh

@@ -0,0 +1,157 @@
+#!/usr/bin/env bash
+# do-project.sh — project a promise's deliverables: into an idempotent subtask spec.
+# Parent = the promise (born with tags slug:<slug> — resolveTaskBySlug cannot retrofit).
+# One child per deliverable; notes first line is accept: <that accept:> verbatim.
+# Emits JSON. Does not POST. Re-projecting with --existing <prior.json> yields new_rows=0.
+# Usage:  do-project.sh <slug> [--existing prior.json]   |   do-project.sh --self-test
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
+
+# Lifted from do-promise-lint.sh — do not fork a second YAML parser.
+unquote() {
+  local line="$1"
+  case "$line" in
+    \"*) printf '%s' "$line" | sed -E 's/^"(.*)"[[:space:]]*(#.*)?$/\1/' | sed 's/\\"/"/g' ;;
+    \'*) printf '%s' "$line" | sed -E "s/^'(.*)'[[:space:]]*(#.*)?\$/\1/" | sed "s/''/'/g" ;;
+    *)   printf '%s' "$line" | sed -E 's/[[:space:]]+#.*$//' ;;
+  esac
+}
+fm() { awk '/^---[[:space:]]*$/{c++;next} c==1{print} c>=2{exit}' "$1"; }
+extract_proof() {
+  local line
+  line="$(fm "$1" | awk '/^proof:/{print;exit}')"
+  [ -z "$line" ] && return 1
+  line="${line#proof:}"
+  unquote "$(printf '%s' "$line" | sed -E 's/^[[:space:]]+//')"
+}
+deliverables_block() {
+  fm "$1" | awk '/^deliverables:/{on=1;next} on && /^[a-zA-Z_-]+:/{exit} on{print}'
+}
+
+if [ "${1:-}" = "--self-test" ]; then
+  S="$(cd "$(dirname "$0")" && pwd)"; f=0
+  dir="$(mktemp -d)"; trap 'rm -rf "$dir"' EXIT
+  cat >"$dir/proj.md" <<'F'
+---
+title: Project fixture
+slug: proj
+deliverables:
+  - item: "alpha row"
+    accept: "test -f a"
+  - item: "beta row"
+    accept: "test -f b"
+proof: "test -f a && test -f b"
+---
+F
+  cat >"$dir/gap.md" <<'F'
+---
+title: Gap
+slug: gap
+deliverables:
+  - item: "alpha row"
+proof: "true"
+---
+F
+  out1="$(PROMISE_FILE="$dir/proj.md" "$S/do-project.sh" proj)" || { echo "  FAIL first project exited $?"; exit 1; }
+  echo "$out1" >"$dir/once.json"
+  case "$out1" in *"\"slug:proj\""*) printf '  ok   parent carries slug:proj\n' ;;
+                 *) printf '  FAIL parent missing slug:proj: %s\n' "$out1"; f=1 ;; esac
+  case "$out1" in *"accept: test -f a"*) printf '  ok   child carries accept: verbatim\n' ;;
+                 *) printf '  FAIL child missing accept: %s\n' "$out1"; f=1 ;; esac
+  case "$out1" in *"\"new_rows\":3"*) printf '  ok   first project inserts 3 rows\n' ;;
+                 *) printf '  FAIL first new_rows: %s\n' "$out1"; f=1 ;; esac
+  out2="$(PROMISE_FILE="$dir/proj.md" "$S/do-project.sh" proj --existing "$dir/once.json")" || { echo "  FAIL second project exited $?"; f=1; out2=""; }
+  case "$out2" in *"\"new_rows\":0"*) printf '  ok   second project new_rows=0\n' ;;
+                 *) printf '  FAIL second diff not empty: %s\n' "$out2"; f=1 ;; esac
+  set +e
+  PROMISE_FILE="$dir/gap.md" "$S/do-project.sh" gap >/dev/null 2>&1; rc=$?
+  set -e
+  [ "$rc" -ne 0 ] && printf '  ok   missing accept: refused (exit %s)\n' "$rc" \
+    || { printf '  FAIL missing accept: should refuse\n'; f=1; }
+  [ "$f" -eq 0 ] && echo "do-project: self-test green" || echo "do-project: self-test FAILED"
+  exit "$f"
+fi
+
+slug="${1:-}"
+[ -z "$slug" ] && { echo "usage: do-project.sh <slug> [--existing prior.json] | --self-test" >&2; exit 4; }
+shift
+existing=""
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --existing) existing="${2:-}"; shift 2 ;;
+    *) echo "unknown flag $1" >&2; exit 4 ;;
+  esac
+done
+
+file="${PROMISE_FILE:-$ROOT/text/$slug.md}"
+[ -f "$file" ] || { echo "do-project: no promise at ${file#"$ROOT"/}" >&2; exit 3; }
+
+block="$(deliverables_block "$file")"
+[ -z "$block" ] && { echo "do-project: no deliverables: in ${file#"$ROOT"/}" >&2; exit 1; }
+
+items=""; accepts=""
+while IFS= read -r raw; do
+  [ -z "$raw" ] && continue
+  val="$(unquote "$(printf '%s' "$raw" | sed -E 's/^[[:space:]]*-[[:space:]]*item:[[:space:]]*//')")"
+  items="${items}${val}
+"
+done <<EOF
+$(printf '%s\n' "$block" | grep '^[[:space:]]*-[[:space:]]*item:' || true)
+EOF
+while IFS= read -r raw; do
+  [ -z "$raw" ] && continue
+  val="$(unquote "$(printf '%s' "$raw" | sed -E 's/^[[:space:]]*accept:[[:space:]]*//')")"
+  accepts="${accepts}${val}
+"
+done <<EOF
+$(printf '%s\n' "$block" | grep '^[[:space:]]*accept:' || true)
+EOF
+
+n_items="$(printf '%s' "$items" | grep -c . || true)"
+n_acc="$(printf '%s' "$accepts" | grep -c . || true)"
+if [ "$n_items" -lt 1 ] || [ "$n_items" -ne "$n_acc" ]; then
+  echo "do-project: refuse — $n_items item(s) but $n_acc accept(s); every deliverable needs accept:" >&2
+  exit 1
+fi
+
+title="$(fm "$file" | awk '/^title:/{sub(/^title:[[:space:]]*/,"");print;exit}')"
+title="$(unquote "$title")"
+[ -z "$title" ] && title="$slug"
+proof="$(extract_proof "$file" || true)"
+
+pairf="$(mktemp)"
+paste -d $'\t' <(printf '%s' "$items" | grep -v '^$') <(printf '%s' "$accepts" | grep -v '^$') >"$pairf"
+python3 - "$slug" "$title" "$proof" "$existing" "$pairf" <<'PY'
+import json, sys
+slug, title, proof, existing_path, pairf = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5]
+pairs = [ln.rstrip("\n").split("\t", 1) for ln in open(pairf) if ln.strip()]
+if not proof:
+    proof = " && ".join(p[1] for p in pairs)
+prior = {"parent": None, "children": []}
+if existing_path:
+    prior = json.load(open(existing_path))
+prior_tags = (prior.get("parent") or {}).get("tags") or []
+parent_exists = ("slug:%s" % slug) in prior_tags
+prior_titles = {c.get("title") for c in (prior.get("children") or []) if c.get("title")}
+parent = {
+    "title": title,
+    "tags": ["slug:%s" % slug],
+    "notes": "accept: %s" % proof,
+    "insert": not parent_exists,
+    "create": "tasks:create",
+}
+children, new_rows = [], 1 if parent["insert"] else 0
+for item, accept in pairs:
+    ins = item not in prior_titles
+    children.append({
+        "title": item,
+        "notes": "accept: %s" % accept,
+        "insert": ins,
+        "steps": ["tasks:subtask", "tasks:notes"],
+    })
+    if ins:
+        new_rows += 1
+print(json.dumps({"parent": parent, "children": children, "new_rows": new_rows}, separators=(",", ":")))
+PY
+rm -f "$pairf"

package/scripts/do-promise-lint.sh

@@ -57,6 +57,31 @@ assumes_entries() { # $1 = file
     | while IFS= read -r l; do unquote "$l"; echo; done
 }
 
+# exec_dry — IC6: catch a path-shape-fragile proof at PROMISE, before it dies
+# at settle. Runs proof: for real (env -i, from $base) and inspects stderr for
+# the classic bug: two deliverables' accept: joined by `&&`, each independently
+# written assuming CWD=repo-root, e.g. "cd A && test 1 && cd A && test 2" — the
+# second bare `cd A` runs from inside A (after the first leg), tries A/A, dies.
+# Subshell-wrapped legs ("(cd A && test 1) && (cd A && test 2)") reset CWD
+# between legs and never hit this. A non-zero exit alone is NOT a failure here —
+# red-before-green proofs are legitimately red; only the path-shape death is.
+exec_dry() { # $1 = file, $2 = base dir (default $ROOT)
+  local file="$1" base="${2:-$ROOT}" proof err
+  proof="$(extract_proof "$file")"
+  if [ -z "$proof" ]; then
+    echo "[promise-lint:exec-dry] FAIL — no proof: to test"
+    return 1
+  fi
+  err="$(cd "$base" && env -i HOME="$HOME" PATH="$PATH" bash -c "$proof" 2>&1 1>/dev/null)"
+  if printf '%s' "$err" | grep -qE 'cd: .*No such file or directory'; then
+    echo "[promise-lint:exec-dry] FAIL — path-shape death (a repeated bare 'cd X &&' leg dies once a prior leg already moved CWD into X):"
+    printf '%s\n' "$err" | grep -E 'cd: .*No such file or directory' | sed 's/^/  /'
+    return 1
+  fi
+  echo "[promise-lint:exec-dry] OK — proof is path-shape safe (a non-zero exit here is fine; red-before-green is legitimate)"
+  return 0
+}
+
 lint() { # $1 = slug, $2 = file, $3 = no_run (true/false), $4 = red (true/false)
   local slug="$1" file="$2" no_run="$3" red="$4" fails=0
   echo "[promise-lint] slug=$slug file=${file#"$ROOT"/}"
@@ -106,6 +131,28 @@ lint() { # $1 = slug, $2 = file, $3 = no_run (true/false), $4 = red (true/false)
 $(printf '%s\n' "$block" | grep '^[[:space:]]*accept:')
 EOF
 
+  # user-visible ⇒ page: a deliverable that explicitly names a page/route/view
+  # (kind prefix `route:`/`page:`/`view:`/`component:`, an .astro / src/pages/
+  # path, or the phrase "a page") must be proven by at least one accept: that
+  # actually checks the page — curl / browser-check / do-prove / an http(s) URL /
+  # a `--route /x` flag / a src/pages/ or .astro file check.
+  # Heuristic is deliberately conservative (deliverables text only, NOT the
+  # world: block) so settled promises whose UI is proven via vitest/grep
+  # (brain, chat) don't retro-fail; it catches new promises that schedule a
+  # page but never load it.
+  local vis_re='(route|page|view|component):|src/pages/|\.astro| a page '
+  local page_proof_re='curl|browser-check|do-prove|https?://|--route[[:space:]]+/|src/pages/|\.astro'
+  local vis_item
+  vis_item="$(printf '%s\n' "$block" | grep -E '^[[:space:]]*-[[:space:]]*item:' | grep -iE "$vis_re" | head -1)"
+  if [ -n "$vis_item" ]; then
+    if ! printf '%s\n' "$block" | grep '^[[:space:]]*accept:' | grep -qiE "$page_proof_re"; then
+      echo "[promise-lint] FAIL — user-visible deliverable but no page-load proof:"
+      echo "[promise-lint]   $(printf '%s' "$vis_item" | sed -E 's/^[[:space:]]*//')"
+      echo "[promise-lint]   add a route/component deliverable whose accept: loads the page (curl / browser-check / do-prove.sh --route /x / src/pages file check)"
+      fails=$((fails+1))
+    fi
+  fi
+
   # assumes: — client-side dependencies must be green at the making
   if [ "$no_run" != true ]; then
     local a_n=0
@@ -139,6 +186,60 @@ EOF
   return 1
 }
 
+# check_ui_coupling — IC9 lint coupling: when a promise's derives: block has
+# `ui: true`, its proof: must invoke `do-ui-gate.sh <slug>` (that promise's own
+# filename stem) — a UI-bearing promise can't settle without its screens
+# actually being gate-checked.
+check_ui_coupling() { # $1 = file
+  local file="$1" slug ui_val proof
+  slug="$(basename "$file" .md)"
+  ui_val="$(fm "$file" | awk '/^derives:/{on=1;next} on && /^[a-zA-Z_-]+:/{exit} on && /^[[:space:]]*ui:/{sub(/^[[:space:]]*ui:[[:space:]]*/,"");print;exit}')"
+  ui_val="$(unquote "$ui_val" | sed -E 's/^[[:space:]]+|[[:space:]]+$//g')"
+  if [ "$ui_val" != "true" ]; then
+    echo "[promise-lint:ui-coupling] skip — derives.ui != true (slug=$slug)"
+    return 0
+  fi
+  proof="$(extract_proof "$file")"
+  if printf '%s' "$proof" | grep -qF "do-ui-gate.sh $slug"; then
+    echo "[promise-lint:ui-coupling] OK — proof invokes do-ui-gate.sh $slug"
+    return 0
+  fi
+  echo "[promise-lint:ui-coupling] FAIL — derives.ui: true but proof: does not invoke 'do-ui-gate.sh $slug'"
+  return 1
+}
+
+# ── self-test: ui-coupling fixtures, zero network ────────────────────────────
+if [ "${1:-}" = "--self-test-ui-coupling" ]; then
+  dir="$(mktemp -d)"; trap 'rm -rf "$dir"' EXIT
+  cat >"$dir/uinocheck.md" <<'F'
+---
+derives:
+  ui:        true
+proof: "true"
+---
+F
+  cat >"$dir/uigood.md" <<'F'
+---
+derives:
+  ui:        true
+proof: "bash .claude/scripts/do-ui-gate.sh uigood"
+---
+F
+  cat >"$dir/nouify.md" <<'F'
+---
+derives:
+  ui:        false
+proof: "true"
+---
+F
+  fails=0
+  check_ui_coupling "$dir/uinocheck.md" >/dev/null && { echo "FAIL: expected ui-coupling FAIL when ui:true but proof lacks do-ui-gate.sh"; fails=$((fails+1)); }
+  check_ui_coupling "$dir/uigood.md" >/dev/null || { echo "FAIL: expected ui-coupling PASS when proof invokes do-ui-gate.sh <slug>"; fails=$((fails+1)); }
+  check_ui_coupling "$dir/nouify.md" >/dev/null || { echo "FAIL: expected ui-coupling PASS (skip) when ui:false"; fails=$((fails+1)); }
+  echo "[promise-lint] self-test-ui-coupling: 3 fixtures, $fails failed"
+  exit "$fails"
+fi
+
 # ── self-test: fixtures, zero network ────────────────────────────────────────
 if [ "${1:-}" = "--self-test" ]; then
   dir="$(mktemp -d)"; trap 'rm -rf "$dir"' EXIT
@@ -194,6 +295,22 @@ assumes:
   - "false"
 proof: "test -f a"
 ---
+F
+  cat >"$dir/pagegap.md" <<'F'
+---
+deliverables:
+  - item: "route: /foo — user sees the page"
+    accept: "grep -q foo a.ts"
+proof: "grep -q foo a.ts"
+---
+F
+  cat >"$dir/pagegood.md" <<'F'
+---
+deliverables:
+  - item: "route: /foo — user sees the page"
+    accept: "curl -sf https://one.ie/foo"
+proof: "curl -sf https://one.ie/foo"
+---
 F
   fails=0
   lint good "$dir/good.md" true false >/dev/null        || { echo "FAIL good → 0"; fails=$((fails+1)); }
@@ -203,19 +320,48 @@ F
   lint emptyproof "$dir/emptyproof.md" true false >/dev/null && { echo "FAIL emptyproof → 1"; fails=$((fails+1)); }
   lint badassume "$dir/badassume.md" false false >/dev/null && { echo "FAIL badassume → 1"; fails=$((fails+1)); }
   lint redcheck "$dir/gap.md" true true >/dev/null      && { echo "FAIL red-on-gap → 1"; fails=$((fails+1)); }
-  echo "[promise-lint] self-test: 7 fixtures, $fails failed"
+  lint pagegap "$dir/pagegap.md" true false >/dev/null  && { echo "FAIL pagegap → 1 (user-visible, no page proof)"; fails=$((fails+1)); }
+  lint pagegood "$dir/pagegood.md" true false >/dev/null || { echo "FAIL pagegood → 0"; fails=$((fails+1)); }
+  echo "[promise-lint] self-test: 9 fixtures, $fails failed"
+  exit "$fails"
+fi
+
+# ── self-test: exec-dry fixtures, zero network ───────────────────────────────
+if [ "${1:-}" = "--self-test-exec-dry" ]; then
+  dir="$(mktemp -d)"; trap 'rm -rf "$dir"' EXIT
+  mkdir -p "$dir/leg"
+  touch "$dir/leg/marker"
+  cat >"$dir/failcase.md" <<'F'
+---
+proof: "cd leg && test -f marker && cd leg && test -f marker"
+---
+F
+  cat >"$dir/passcase.md" <<'F'
+---
+proof: "(cd leg && test -f marker) && (cd leg && test -f marker)"
+---
+F
+  fails=0
+  exec_dry "$dir/failcase.md" "$dir" >/dev/null && { echo "FAIL: expected exec-dry FAIL on repeated bare 'cd leg &&' legs"; fails=$((fails+1)); }
+  exec_dry "$dir/passcase.md" "$dir" >/dev/null || { echo "FAIL: expected exec-dry PASS on subshell-wrapped legs"; fails=$((fails+1)); }
+  echo "[promise-lint] self-test-exec-dry: 2 fixtures, $fails failed"
   exit "$fails"
 fi
 
 # ── main ─────────────────────────────────────────────────────────────────────
 SLUG="${1:-}"; [ -z "$SLUG" ] && { grep '^# ' "$0" | sed 's/^# //' | sed -n '3,24p'; exit 4; }
 shift
-NO_RUN=false; RED=false
+NO_RUN=false; RED=false; EXEC_DRY=false
 while [ $# -gt 0 ]; do
   case "$1" in
-    --no-run) NO_RUN=true; shift ;;
-    --red)    RED=true; shift ;;
+    --no-run)   NO_RUN=true; shift ;;
+    --red)      RED=true; shift ;;
+    --exec-dry) EXEC_DRY=true; shift ;;
     *) echo "unknown flag $1"; exit 4 ;;
   esac
 done
+if $EXEC_DRY; then
+  exec_dry "${PROMISE_FILE:-$ROOT/text/$SLUG.md}"
+  exit $?
+fi
 lint "$SLUG" "${PROMISE_FILE:-$ROOT/text/$SLUG.md}" "$NO_RUN" "$RED"