llm-wb 0.1.0-beta.0

package/scripts/00.chat/local-merge/verify-chat-ready-to-merge-local-main/smoke-test.sh

@@ -0,0 +1,244 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# agentic-artifact:
+#   schema: agentic-artifact/v2
+#   id: chat.script.local-merge.verify-chat-ready-to-merge-local-main.smoke-test
+#   version: 1
+#   status: active
+#   layer: 00.chat
+#   domain: local-merge
+#   disciplines:
+#   - agentic
+#   kind: script
+#   purpose: Smoke test local-main merge readiness verifier classifications.
+#   portability:
+#     class: reusable
+#     targets:
+#     - llm-workbench
+#   used_by:
+#   - id: chat.workflows.chat-promote-to-main
+#     path: .agentic/00.chat/workflows/chat-promote-to-main.md
+#   - id: chat.script.local-merge.verify-chat-ready-to-merge-local-main
+#     path: scripts/00.chat/local-merge/verify-chat-ready-to-merge-local-main/script.sh
+#   effects:
+#   - branches
+#   - commits
+#   - worktrees
+#   - writes-files
+
+SOURCE_ROOT="$(git rev-parse --show-toplevel)"
+TMP_ROOT="$(mktemp -d "${TMPDIR:-/tmp}/local-convergence-verifier-smoke.XXXXXX")"
+
+cleanup() {
+  rm -rf "$TMP_ROOT"
+}
+
+trap cleanup EXIT
+
+fail() {
+  echo "ERROR: $*" >&2
+  exit 1
+}
+
+copy_verifier_scripts() {
+  local repo="$1"
+
+  mkdir -p "$repo/scripts/00.chat/local-merge/verify-chat-ready-to-merge-local-main" "$repo/scripts/00.chat/session-log/paths" "$repo/scripts/00.chat/worktree/paths"
+  cp "$SOURCE_ROOT/scripts/00.chat/local-merge/verify-chat-ready-to-merge-local-main/script.sh" "$repo/scripts/00.chat/local-merge/verify-chat-ready-to-merge-local-main/script.sh"
+  cp "$SOURCE_ROOT/scripts/00.chat/worktree/paths/lib.sh" "$repo/scripts/00.chat/worktree/paths/lib.sh"
+  cp "$SOURCE_ROOT/scripts/00.chat/session-log/paths/lib.sh" "$repo/scripts/00.chat/session-log/paths/lib.sh"
+}
+
+init_repo() {
+  local name="$1"
+  local repo="$TMP_ROOT/$name/repo"
+
+  mkdir -p "$repo"
+  copy_verifier_scripts "$repo"
+
+  git -C "$repo" init -q -b main
+  git -C "$repo" config user.name "Smoke Test"
+  git -C "$repo" config user.email "smoke@example.invalid"
+
+  printf 'base\n' > "$repo/base.txt"
+  git -C "$repo" add base.txt scripts
+  git -C "$repo" commit -q -m "initial"
+
+  printf '%s\n' "$repo"
+}
+
+canonical_worktree_path() {
+  local repo="$1"
+  local branch="$2"
+
+  (
+    cd "$repo"
+    # shellcheck source=../worktree/paths/lib.sh
+    source scripts/00.chat/worktree/paths/lib.sh
+    chat_worktree_path_for_branch "$repo" "$branch"
+  )
+}
+
+write_session_log() {
+  local repo="$1"
+  local session="$2"
+  local branch="$3"
+  local worktree="$4"
+  local latest_sha="$5"
+  local log_path="$repo/commitLogs/2026/jun/16/$session/README.md"
+
+  mkdir -p "$(dirname "$log_path")"
+  cat > "$log_path" <<EOF
+# Chat Session: $session
+
+<!-- agentic-session
+id: $session
+task: smoke test local convergence
+branch: $branch
+worktree: $worktree
+layer: shared
+mode: implementation
+workflow: .agentic/shared/workflows/change-shared-process.md
+status: ready
+latest_commit_sha: $latest_sha
+-->
+
+## Commits
+
+- Commit: \`$latest_sha\`
+EOF
+}
+
+create_chat_branch_with_log() {
+  local repo="$1"
+  local session="$2"
+  local latest_sha="${3:-}"
+  local branch="chat/$session"
+  local worktree
+  local task_sha
+
+  worktree="$(canonical_worktree_path "$repo" "$branch")"
+
+  git -C "$repo" switch -q -c "$branch"
+  printf 'work\n' > "$repo/work-$session.txt"
+  git -C "$repo" add "work-$session.txt"
+  git -C "$repo" commit -q -m "task work"
+  task_sha="$(git -C "$repo" rev-parse HEAD)"
+
+  if [ -z "$latest_sha" ]; then
+    latest_sha="$task_sha"
+  fi
+
+  write_session_log "$repo" "$session" "$branch" "$worktree" "$latest_sha"
+  git -C "$repo" add "commitLogs/2026/jun/16/$session/README.md"
+  git -C "$repo" commit -q -m "record session log"
+  git -C "$repo" switch -q main
+  mkdir -p "${worktree%/*}"
+  git -C "$repo" worktree add -q "$worktree" "$branch"
+}
+
+run_expect_state() {
+  local repo="$1"
+  local branch="$2"
+  local state="$3"
+  local should_succeed="$4"
+  local out="$TMP_ROOT/output"
+  local err="$TMP_ROOT/error"
+
+  if [ "$should_succeed" = "yes" ]; then
+    (
+      cd "$repo"
+      bash scripts/00.chat/local-merge/verify-chat-ready-to-merge-local-main/script.sh "$branch"
+    ) > "$out" 2> "$err" || {
+      cat "$out" >&2
+      cat "$err" >&2
+      fail "expected verifier success for $state"
+    }
+  else
+    if (
+      cd "$repo"
+      bash scripts/00.chat/local-merge/verify-chat-ready-to-merge-local-main/script.sh "$branch"
+    ) > "$out" 2> "$err"; then
+      cat "$out" >&2
+      fail "expected verifier failure for $state"
+    fi
+  fi
+
+  if ! grep -q "State: $state" "$out"; then
+    cat "$out" >&2
+    cat "$err" >&2
+    fail "expected state $state"
+  fi
+}
+
+repo="$(init_repo eligible)"
+session="2026-06-16-22-32-eligible"
+branch="chat/$session"
+create_chat_branch_with_log "$repo" "$session"
+run_expect_state "$repo" "$branch" "eligible" "yes"
+
+repo="$(init_repo renamed-log)"
+session="2026-06-16-22-32-renamed-log"
+branch="chat/$session"
+create_chat_branch_with_log "$repo" "$session"
+worktree="$(canonical_worktree_path "$repo" "$branch")"
+git -C "$worktree" mv \
+  "commitLogs/2026/jun/16/$session" \
+  "commitLogs/2026/jun/16/2026-06-16-22-32-short-log-name"
+git -C "$worktree" commit -q -m "rename session log folder"
+run_expect_state "$repo" "$branch" "eligible" "yes"
+
+repo="$(init_repo behind)"
+session="2026-06-16-22-33-behind"
+branch="chat/$session"
+worktree="$(canonical_worktree_path "$repo" "$branch")"
+write_session_log "$repo" "$session" "$branch" "$worktree" "$(git -C "$repo" rev-parse HEAD)"
+git -C "$repo" add "commitLogs/2026/jun/16/$session/README.md"
+git -C "$repo" commit -q -m "record shared session log"
+git -C "$repo" branch "$branch"
+printf 'main update\n' > "$repo/main-update.txt"
+git -C "$repo" add main-update.txt
+git -C "$repo" commit -q -m "main update"
+mkdir -p "${worktree%/*}"
+git -C "$repo" worktree add -q "$worktree" "$branch"
+run_expect_state "$repo" "$branch" "blocked-behind" "no"
+
+repo="$(init_repo diverged)"
+session="2026-06-16-22-34-diverged"
+branch="chat/$session"
+create_chat_branch_with_log "$repo" "$session"
+printf 'main update\n' > "$repo/main-update.txt"
+git -C "$repo" add main-update.txt
+git -C "$repo" commit -q -m "main update"
+run_expect_state "$repo" "$branch" "blocked-diverged" "no"
+
+repo="$(init_repo dirty-chat)"
+session="2026-06-16-22-35-dirty-chat"
+branch="chat/$session"
+create_chat_branch_with_log "$repo" "$session"
+worktree="$(canonical_worktree_path "$repo" "$branch")"
+printf 'dirty\n' > "$worktree/dirty.txt"
+run_expect_state "$repo" "$branch" "blocked-dirty-chat-worktree" "no"
+
+repo="$(init_repo missing-log)"
+session="2026-06-16-22-36-missing-log"
+branch="chat/$session"
+git -C "$repo" branch "$branch"
+run_expect_state "$repo" "$branch" "blocked-missing-log" "no"
+
+repo="$(init_repo missing-worktree)"
+session="2026-06-16-22-37-missing-worktree"
+branch="chat/$session"
+create_chat_branch_with_log "$repo" "$session"
+worktree="$(canonical_worktree_path "$repo" "$branch")"
+git -C "$repo" worktree remove "$worktree" >/dev/null
+run_expect_state "$repo" "$branch" "blocked-missing-worktree" "no"
+
+repo="$(init_repo log-mismatch)"
+session="2026-06-16-22-38-log-mismatch"
+branch="chat/$session"
+create_chat_branch_with_log "$repo" "$session" "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"
+run_expect_state "$repo" "$branch" "blocked-log-head-mismatch" "no"
+
+echo "local merge readiness verifier smoke test passed."

package/scripts/00.chat/main-refresh/README.md

@@ -0,0 +1,39 @@
+<!-- agentic-artifact:
+  schema: agentic-artifact/v2
+  id: chat.script.main-refresh.readme
+  version: 1
+  status: active
+  layer: 00.chat
+  domain: main-refresh
+  disciplines:
+  - agentic
+  kind: script-domain-readme
+  purpose: Explain scripts for refreshing chat branches from local main.
+  portability:
+    class: required
+    targets:
+    - llm-workbench
+  used_by:
+  - id: chat.workflows.chat-refresh-from-main
+    path: .agentic/00.chat/workflows/chat-refresh-from-main.md
+  - id: chat.script.main-refresh.rehearse-refresh-from-main.readme
+    path: scripts/00.chat/main-refresh/rehearse-refresh-from-main/README.md
+-->
+# Main Refresh Scripts
+
+Main-refresh scripts help a chat branch catch up with local `main` without
+rewriting history or hiding conflicts.
+
+The domain is split into inspection, readiness classification, rehearsal, and
+apply steps. Rehearsal lets the harness discover conflicts in a disposable
+preflight branch/worktree before the real chat branch is changed.
+
+Conflict capabilities in this domain:
+
+- `classify-conflict/` classifies known main-refresh conflict shapes using the
+  governed conflict type standard.
+- `verify-conflict-audit/` checks that conflicted paths have matching
+  `## Main Refresh Conflicts` session-log entries before a resolved preflight
+  is applied or promoted.
+
+These scripts do not push. They coordinate local chat branch refresh behavior.

package/scripts/00.chat/main-refresh/apply-rehearsed-refresh/README.md

@@ -0,0 +1,32 @@
+<!-- agentic-artifact:
+  schema: agentic-artifact/v2
+  id: chat.script.main-refresh.apply-rehearsed-refresh.readme
+  version: 1
+  status: active
+  layer: 00.chat
+  domain: main-refresh
+  disciplines:
+  - agentic
+  kind: guide
+  purpose: Explain how the harness applies a rehearsed main refresh to a chat branch.
+  portability:
+    class: required
+    targets:
+    - llm-workbench
+  used_by:
+  - id: chat.script.main-refresh.apply-rehearsed-refresh
+    path: scripts/00.chat/main-refresh/apply-rehearsed-refresh/script.sh
+-->
+# Apply Rehearsed Refresh
+
+This capability answers: the refresh rehearsal worked, so how do we apply that
+tested result to the real chat branch?
+
+It fast-forwards the current chat branch to the tested preflight branch, checks
+that the expected commit was applied, removes the temporary preflight worktree,
+deletes the preflight branch, and cleans up stale sibling preflight branches
+when they are already ancestors of the promoted chat branch.
+
+It refuses to run if the active chat worktree is dirty, the preflight worktree
+is dirty, the branch is not a preflight branch, or the preflight branch no
+longer descends from the current chat branch.

package/scripts/00.chat/main-refresh/apply-rehearsed-refresh/script.sh

@@ -0,0 +1,198 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# agentic-artifact:
+#   schema: agentic-artifact/v2
+#   id: chat.script.main-refresh.apply-rehearsed-refresh
+#   version: 1
+#   status: active
+#   layer: 00.chat
+#   domain: main-refresh
+#   disciplines:
+#   - agentic
+#   kind: script
+#   purpose: Apply a rehearsed main-refresh branch to the active chat branch.
+#   portability:
+#     class: required
+#     targets:
+#     - llm-workbench
+#   used_by:
+#   - id: chat.workflows.chat-refresh-from-main
+#     path: .agentic/00.chat/workflows/chat-refresh-from-main.md
+#   - id: chat.standards.main-refresh-conflict-types
+#     path: .agentic/00.chat/standards/main-refresh-conflict-types.md
+#   effects:
+#   - branches
+#   - destructive
+#   - worktrees
+
+usage() {
+  cat <<'EOF'
+Usage:
+  script.sh <preflight-branch>
+
+Fast-forwards the current chat branch to a tested preflight refresh branch,
+then removes the temporary preflight worktree and deletes the preflight branch.
+The current worktree and preflight worktree must both be clean.
+EOF
+}
+
+if [ $# -ne 1 ]; then
+  usage >&2
+  exit 2
+fi
+
+PREFLIGHT_BRANCH="$1"
+
+case "$PREFLIGHT_BRANCH" in
+  agentic/preflight/*/[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9])
+    ;;
+  *)
+    echo "ERROR: refusing non-preflight branch: ${PREFLIGHT_BRANCH}" >&2
+    echo "Expected branch created by rehearse-refresh-from-main." >&2
+    exit 1
+    ;;
+esac
+
+if ! git show-ref --verify --quiet "refs/heads/${PREFLIGHT_BRANCH}"; then
+  echo "ERROR: preflight branch does not exist: ${PREFLIGHT_BRANCH}" >&2
+  exit 1
+fi
+
+preflight_worktrees_for_branch() {
+  local branch="$1"
+
+  git worktree list --porcelain \
+    | awk -v branch="refs/heads/${branch}" '
+      /^worktree / { path = substr($0, 10) }
+      /^branch / && substr($0, 8) == branch { print path }
+    '
+}
+
+worktree_count() {
+  awk 'NF { count += 1 } END { print count + 0 }'
+}
+
+cleanup_stale_preflight_siblings() {
+  local promoted_branch="$1"
+  local prefix="${promoted_branch%/*}/"
+  local sibling sibling_worktrees sibling_worktree_count sibling_worktree
+
+  while IFS= read -r sibling; do
+    if [ -z "$sibling" ] || [ "$sibling" = "$promoted_branch" ]; then
+      continue
+    fi
+
+    case "$sibling" in
+      "$prefix"*)
+        ;;
+      *)
+        continue
+        ;;
+    esac
+
+    if ! git merge-base --is-ancestor "$sibling" HEAD; then
+      echo "stale_preflight_skipped=${sibling} reason=unique-commits-not-in-promoted-head"
+      continue
+    fi
+
+    sibling_worktrees="$(preflight_worktrees_for_branch "$sibling")"
+    sibling_worktree_count="$(printf '%s\n' "$sibling_worktrees" | worktree_count)"
+
+    if [ "$sibling_worktree_count" -gt 1 ]; then
+      echo "stale_preflight_skipped=${sibling} reason=multiple-worktrees"
+      continue
+    fi
+
+    if [ "$sibling_worktree_count" = "1" ]; then
+      sibling_worktree="$(printf '%s\n' "$sibling_worktrees" | awk 'NF { print; exit }')"
+      sibling_worktree="$(cd "$sibling_worktree" && pwd -P)"
+
+      if [ "$sibling_worktree" = "$CURRENT_WORKTREE" ]; then
+        echo "stale_preflight_skipped=${sibling} reason=active-worktree"
+        continue
+      fi
+
+      if [ -n "$(git -C "$sibling_worktree" status --porcelain)" ]; then
+        echo "stale_preflight_skipped=${sibling} reason=dirty-worktree"
+        continue
+      fi
+
+      git worktree remove "$sibling_worktree"
+      echo "stale_preflight_removed=${sibling} worktree=${sibling_worktree}"
+    else
+      echo "stale_preflight_removed=${sibling} worktree="
+    fi
+
+    git branch -d "$sibling" >/dev/null
+  done < <(git branch --format='%(refname:short)')
+}
+
+CURRENT_BRANCH="$(git branch --show-current)"
+
+case "$CURRENT_BRANCH" in
+  chat/*)
+    ;;
+  *)
+    echo "ERROR: current branch is not a chat branch: ${CURRENT_BRANCH}" >&2
+    exit 1
+    ;;
+esac
+
+if [ -n "$(git status --porcelain)" ]; then
+  echo "ERROR: refusing to promote into a dirty chat worktree." >&2
+  git status --short >&2
+  exit 1
+fi
+
+PREFLIGHT_HEAD="$(git rev-parse "$PREFLIGHT_BRANCH")"
+
+if ! git merge-base --is-ancestor HEAD "$PREFLIGHT_BRANCH"; then
+  echo "ERROR: preflight branch does not descend from current HEAD." >&2
+  echo "Current branch may have moved since preflight." >&2
+  exit 1
+fi
+
+PREFLIGHT_WORKTREES="$(preflight_worktrees_for_branch "$PREFLIGHT_BRANCH")"
+
+PREFLIGHT_WORKTREE_COUNT="$(printf '%s\n' "$PREFLIGHT_WORKTREES" | worktree_count)"
+
+if [ "$PREFLIGHT_WORKTREE_COUNT" != "1" ]; then
+  echo "ERROR: expected exactly one preflight worktree for ${PREFLIGHT_BRANCH}; found ${PREFLIGHT_WORKTREE_COUNT}." >&2
+  exit 1
+fi
+
+PREFLIGHT_WORKTREE="$(printf '%s\n' "$PREFLIGHT_WORKTREES" | awk 'NF { print; exit }')"
+CURRENT_WORKTREE="$(pwd -P)"
+PREFLIGHT_WORKTREE="$(cd "$PREFLIGHT_WORKTREE" && pwd -P)"
+
+if [ "$PREFLIGHT_WORKTREE" = "$CURRENT_WORKTREE" ]; then
+  echo "ERROR: refusing to remove the active chat worktree as preflight cleanup." >&2
+  exit 1
+fi
+
+if [ -n "$(git -C "$PREFLIGHT_WORKTREE" status --porcelain)" ]; then
+  echo "ERROR: refusing to clean dirty preflight worktree: ${PREFLIGHT_WORKTREE}" >&2
+  git -C "$PREFLIGHT_WORKTREE" status --short >&2
+  exit 1
+fi
+
+git merge --ff-only "$PREFLIGHT_BRANCH"
+
+PROMOTED_COMMIT="$(git rev-parse HEAD)"
+
+if [ "$PROMOTED_COMMIT" != "$PREFLIGHT_HEAD" ]; then
+  echo "ERROR: apply ended at ${PROMOTED_COMMIT}, expected ${PREFLIGHT_HEAD}." >&2
+  exit 1
+fi
+
+git worktree remove "$PREFLIGHT_WORKTREE"
+git branch -d "$PREFLIGHT_BRANCH" >/dev/null
+cleanup_stale_preflight_siblings "$PREFLIGHT_BRANCH"
+
+echo "Applied rehearsed refresh:"
+echo "current_branch=${CURRENT_BRANCH}"
+echo "preflight_branch=${PREFLIGHT_BRANCH}"
+echo "preflight_worktree=${PREFLIGHT_WORKTREE}"
+echo "applied_commit=${PROMOTED_COMMIT}"
+echo "cleanup_result=removed-worktree-and-deleted-branch"

package/scripts/00.chat/main-refresh/check-chat-is-current-with-main/README.md

@@ -0,0 +1,30 @@
+<!-- agentic-artifact:
+  schema: agentic-artifact/v2
+  id: chat.script.main-refresh.check-chat-is-current-with-main.readme
+  version: 1
+  status: active
+  layer: 00.chat
+  domain: main-refresh
+  disciplines:
+  - agentic
+  kind: guide
+  purpose: Explain the check that decides whether a chat branch includes local main.
+  portability:
+    class: required
+    targets:
+    - llm-workbench
+  used_by:
+  - id: chat.script.main-refresh.check-chat-is-current-with-main
+    path: scripts/00.chat/main-refresh/check-chat-is-current-with-main/script.sh
+-->
+# Check Chat Is Current With Main
+
+This read-only capability answers: does this chat branch already include the
+latest local `main`?
+
+It reports whether the chat branch is even, fresh-ahead, behind, or diverged
+relative to a base branch, defaulting to `main`. With `--require-fresh`, it
+exits non-zero when the chat branch is behind or diverged.
+
+Use this when a workflow needs a simple freshness gate before continuing chat
+work or before local merge/promotion decisions.

package/scripts/00.chat/main-refresh/check-chat-is-current-with-main/script.sh

@@ -0,0 +1,121 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# agentic-artifact:
+#   schema: agentic-artifact/v2
+#   id: chat.script.main-refresh.check-chat-is-current-with-main
+#   version: 1
+#   status: active
+#   layer: 00.chat
+#   domain: main-refresh
+#   disciplines:
+#   - agentic
+#   kind: script
+#   purpose: Check whether a chat branch is current with the local base branch.
+#   portability:
+#     class: required
+#     targets:
+#     - llm-workbench
+#   used_by:
+#   - id: harness.architecture.adr.0011-use-chat-owned-worktrees-for-local-convergence
+#   - id: harness.script.run-governed-script
+#     path: scripts/01.harness/run-governed-script.sh
+#   effects:
+#   - read-only
+
+usage() {
+  cat <<'EOF'
+Usage:
+  script.sh [--base <branch>] [--require-fresh] [<branch>]
+
+Reports whether a chat branch includes the latest local base branch. With
+--require-fresh, exits non-zero when the branch is behind or diverged.
+EOF
+}
+
+BASE_BRANCH="main"
+REQUIRE_FRESH="no"
+TARGET_BRANCH=""
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --base)
+      if [ $# -lt 2 ]; then
+        usage >&2
+        exit 2
+      fi
+      BASE_BRANCH="$2"
+      shift 2
+      ;;
+    --require-fresh)
+      REQUIRE_FRESH="yes"
+      shift
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      if [ -n "$TARGET_BRANCH" ]; then
+        usage >&2
+        exit 2
+      fi
+      TARGET_BRANCH="$1"
+      shift
+      ;;
+  esac
+done
+
+if [ -z "$TARGET_BRANCH" ]; then
+  TARGET_BRANCH="$(git branch --show-current)"
+fi
+
+if [ -z "$TARGET_BRANCH" ]; then
+  echo "ERROR: target branch is empty or HEAD is detached." >&2
+  exit 1
+fi
+
+case "$TARGET_BRANCH" in
+  chat/*) ;;
+  *)
+    echo "ERROR: target branch is not a chat branch: $TARGET_BRANCH" >&2
+    exit 1
+    ;;
+esac
+
+if ! git show-ref --verify --quiet "refs/heads/${BASE_BRANCH}"; then
+  echo "ERROR: base branch does not exist: $BASE_BRANCH" >&2
+  exit 1
+fi
+
+if ! git show-ref --verify --quiet "refs/heads/${TARGET_BRANCH}"; then
+  echo "ERROR: target branch does not exist: $TARGET_BRANCH" >&2
+  exit 1
+fi
+
+ahead="$(git rev-list --count "${BASE_BRANCH}..${TARGET_BRANCH}")"
+behind="$(git rev-list --count "${TARGET_BRANCH}..${BASE_BRANCH}")"
+
+echo "Base branch: $BASE_BRANCH"
+echo "Chat branch: $TARGET_BRANCH"
+echo "Ahead of base: $ahead"
+echo "Behind base: $behind"
+
+if [ "$behind" = "0" ]; then
+  if [ "$ahead" = "0" ]; then
+    echo "Freshness: even"
+  else
+    echo "Freshness: fresh-ahead"
+  fi
+  exit 0
+fi
+
+if [ "$ahead" = "0" ]; then
+  echo "Freshness: behind"
+else
+  echo "Freshness: diverged"
+fi
+
+if [ "$REQUIRE_FRESH" = "yes" ]; then
+  exit 1
+fi