openlanes 3.0.0 → 3.1.0

data/bin/factory-e2e

@@ -1,157 +0,0 @@
-#!/usr/bin/env bash
-# vim: ft=bash
-#
-# The factory integration test: a throwaway git repository, `openlanes start`
-# serving it, and Cypress building a tic-tac-toe page through the control
-# room with real agents. It spends real tokens, so it refuses to run unless
-# OPENLANES_FACTORY_E2E=1 says so, and nothing in `just test`, `just web-e2e`
-# or CircleCI calls it.
-#
-#   OPENLANES_FACTORY_E2E=1 just factory-e2e
-#
-# Settings, each with a default:
-#
-#   FACTORY_PORT       control room port                    (4777)
-#   FACTORY_REDIS_URL  Redis for the board and its commands (redis://localhost:6379/11)
-#   FACTORY_MODEL      model every agent runs on            (haiku)
-#   FACTORY_TIMEOUT    seconds before one agent is abandoned (600)
-#   FACTORY_MINUTES    minutes Cypress waits for the build  (15)
-#
-# What it leaves behind is log/factory-e2e/: the progress log, the last
-# board, every plan's state.json and spec.md, the built index.html, and the
-# tail of each agent's trace. The temp repository and the `openlanes start` it
-# launched are always torn down, pass or fail; nothing it did not start is
-# touched.
-
-set -euo pipefail
-
-repo="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-
-if [[ "${OPENLANES_FACTORY_E2E:-}" != "1" ]]; then
-  echo "factory-e2e runs real agents and spends real tokens." >&2
-  echo "Set OPENLANES_FACTORY_E2E=1 to run it: OPENLANES_FACTORY_E2E=1 just factory-e2e" >&2
-  exit 64
-fi
-
-port="${FACTORY_PORT:-4777}"
-redis_url="${FACTORY_REDIS_URL:-redis://localhost:6379/11}"
-model="${FACTORY_MODEL:-haiku}"
-timeout="${FACTORY_TIMEOUT:-600}"
-minutes="${FACTORY_MINUTES:-15}"
-artifacts="${repo}/log/factory-e2e"
-
-command -v claude >/dev/null || { echo "claude is not on PATH; the factory has no agents to run." >&2; exit 69; }
-if command -v redis-cli >/dev/null && ! redis-cli -u "${redis_url}" ping >/dev/null 2>&1; then
-  echo "Redis does not answer on ${redis_url}." >&2
-  exit 69
-fi
-# Another server on the port (the user's own `openlanes web` on 11000, say) is
-# left alone: the run refuses rather than share or kill it.
-if lsof -nP -iTCP:"${port}" -sTCP:LISTEN >/dev/null 2>&1; then
-  echo "Port ${port} is taken; set FACTORY_PORT to a free one." >&2
-  exit 69
-fi
-[[ -f "${repo}/web/dist/index.html" ]] || { echo "web/dist is missing; run just web-build first." >&2; exit 66; }
-
-tmp="$(mktemp -d "${TMPDIR:-/tmp}/openlanes-factory.XXXXXX")"
-project="${tmp}/tictactoe"
-started_at="${tmp}/.started"
-pid=""
-
-openlanes() { "${repo}/exe/openlanes" "$@"; }
-
-collect() {
-  rm -rf "${artifacts}"
-  mkdir -p "${artifacts}/plans" "${artifacts}/traces"
-  curl -sf "http://127.0.0.1:${port}/api/board" -o "${artifacts}/board.json" 2>/dev/null || true
-  cp "${tmp}/progress.log" "${artifacts}/" 2>/dev/null || true
-  cp "${tmp}/start.log" "${artifacts}/" 2>/dev/null || true
-  if [[ -d "${project}/.plans" ]]; then
-    for plan in "${project}"/.plans/*/; do
-      name="$(basename "${plan}")"
-      mkdir -p "${artifacts}/plans/${name}"
-      cp "${plan}"*.md "${plan}"state.json "${artifacts}/plans/${name}/" 2>/dev/null || true
-    done
-  fi
-  find "${project}" -name index.html -not -path '*/.git/*' -not -path '*/node_modules/*' \
-    -exec cp {} "${artifacts}/" \; 2>/dev/null || true
-  (cd "${project}" 2>/dev/null && git status --short >"${artifacts}/git-status.txt") || true
-  # The traces live outside every repository (Executor::TRACE_DIR); keep the
-  # tail of the ones this run wrote.
-  traces="${TMPDIR:-/tmp}"
-  traces="${traces%/}/openlanes-traces"
-  if [[ -d "${traces}" ]]; then
-    find "${traces}" -type f -newer "${started_at}" | while read -r trace; do
-      tail -n 40 "${trace}" >"${artifacts}/traces/$(basename "${trace}")"
-    done
-  fi
-}
-
-teardown() {
-  status=$?
-  trap - EXIT INT TERM
-  collect || true
-  if [[ -n "${pid}" ]] && kill -0 "${pid}" 2>/dev/null; then
-    # TERM is `openlanes start`'s graceful stop: its agents are told to stop and
-    # its control room goes down with it. KILL only if it outlives that.
-    kill -TERM "${pid}" 2>/dev/null || true
-    for _ in $(seq 1 30); do kill -0 "${pid}" 2>/dev/null || break; sleep 1; done
-    kill -KILL "${pid}" 2>/dev/null || true
-  fi
-  rm -rf "${tmp}"
-  echo "factory-e2e: artifacts in ${artifacts}" >&2
-  exit "${status}"
-}
-trap teardown EXIT
-trap 'exit 130' INT
-trap 'exit 143' TERM
-
-touch "${started_at}"
-
-# A repository with one commit and `openlanes init`, and no remote: nothing this
-# run does can reach GitHub.
-mkdir -p "${project}"
-(
-  cd "${project}"
-  git init -q -b main
-  git config user.name "Factory Test"
-  git config user.email "factory-test@example.invalid"
-  cat >README.md <<'MARKDOWN'
-# Tic Tac Toe
-
-A static web page: plain HTML, CSS and JavaScript in the repository root,
-opened straight from disk. There is no package manager, no build step and no
-test runner; check a change by reading it and opening the page.
-MARKDOWN
-  git add README.md
-  git commit -q -m "Initial commit"
-  openlanes init -y -q --project "Tic Tac Toe" -j 1
-  git add -A
-  git commit -q -m "Initialize openlanes"
-)
-
-# `--isolation shared` is the existing local-only mode: one tree, no branch
-# per plan, and no publisher, so nothing is pushed and no pull request is
-# opened. The finished build stays at 🟡 Building, done for this run: 🟢
-# Ready for Review needs an open pull request.
-(
-  cd "${project}"
-  exec "${repo}/exe/openlanes" start --no-open \
-    --port "${port}" --redis-url "${redis_url}" \
-    --isolation shared -j 1 \
-    --model "${model}" --timeout "${timeout}" \
-    --log "${tmp}/progress.log"
-) >"${tmp}/start.log" 2>&1 &
-pid=$!
-
-for _ in $(seq 1 120); do
-  curl -sf "http://127.0.0.1:${port}/healthz" >/dev/null 2>&1 && break
-  kill -0 "${pid}" 2>/dev/null || { echo "openlanes start exited:" >&2; cat "${tmp}/start.log" >&2; exit 1; }
-  sleep 0.5
-done
-curl -sf "http://127.0.0.1:${port}/healthz" >/dev/null || { echo "The control room never answered on ${port}." >&2; exit 1; }
-
-cd "${repo}/web"
-npx cypress run --config-file cypress.factory.config.ts \
-  --config "baseUrl=http://127.0.0.1:${port}" \
-  --env "projectDir=${project},minutes=${minutes}"

data/bin/plan-number

@@ -1,164 +0,0 @@
-#!/usr/bin/env bash
-#
-# plan-number - resolve the .plans folder a branch belongs to, or fail.
-#
-#   plan-number                 # resolve for the current branch
-#   plan-number -b <branch>     # ...for another branch
-#   plan-number -D <dir>        # .plans lives elsewhere (default: ./.plans)
-#   plan-number --title "Foo"   # print "[003] Foo" instead of "003"
-#                               # (or "[018.01] Foo" for a retroactive plan)
-#   plan-number --none          # print "XXX": this PR implements no plan
-#
-# Exit 0 and print the number on stdout when exactly one plan can be resolved.
-# Exit non-zero and explain on stderr otherwise. It never picks a winner from
-# several candidates and never invents one.
-#
-# == Why it refuses rather than guesses
-#
-# The number ends up in a PR title, and pull-requests.md is generated pfrom those
-# titles. A wrong number does not announce itself: it files the work under a
-# plan that did not do it, and the plan that did looks untouched. That is worse
-# than an unprefixed title, which at least reads as "unknown" rather than as a
-# confident lie. Every failure below is therefore loud.
-#
-# == The two shapes of number
-#
-#   NNN      an ordinary plan, specified before it was built.
-#   NNN.MM   a RETROACTIVE plan: the work shipped first and the specification
-#            was written afterwards to describe what exists. It sits in the
-#            sequence where the work landed - 018.01 merged after 018 and
-#            before 019.
-#
-# NNN.MM does NOT mean "part of NNN". The dot reads as containment in most
-# numbering schemes and here it does not: 018.01 is a sibling of 018 that
-# arrived later, with no relationship to its subject. See .plans/README.md.
-#
-# The decimal is ALWAYS two digits. One digit would sort into the middle of the
-# two-digit range - 018.09 < 018.1 < 018.10 - so a single mixed-width folder
-# silently reorders the index. Two digits also give 99 slots per gap, which
-# retires the question of running out: a gap closes the moment the next plan is
-# created, since nothing merging today can land between 018 and 019.
-#
-# == The resolution order, strongest signal first
-#
-# 1. The BRANCH NAME. `kig/021-add-tune-appender` says 021 and says it before a
-#    single line is written, which is the only moment the author certainly knows
-#    the answer. Set once, carried on the PR record forever, survives squash.
-#
-# 2. The DIFF against the base, but ONLY when it touches exactly one plan
-#    folder. Measured across this repository's 24 merged pull requests, this
-#    alone resolves 6 and is ambiguous or silent on 18, so it is a fallback and
-#    never a primary. Files directly under .plans/ (BACKLOG.md, README.md,
-#    INDEX.md) are ignored: they belong to no single plan.
-#
-# 3. Nothing else. There is no "closest match by topic", because a heuristic
-#    that is right most of the time produces an index nobody can trust and
-#    nobody can audit.
-#
-# XXX is deliberately NOT step 4. A PR that implements no plan is a legitimate
-# and common thing - dependency bumps, CI work, hotfixes - and it is marked
-# [XXX] so that "no plan" is visibly asserted rather than merely absent. But the
-# author asserts it; this script will not, because emitting XXX on a failed
-# lookup would launder "I could not tell" into "there is definitely none", which
-# is the same lie as guessing a number, told in the other direction.
-#
-# © 2026 Konstantin Gredeskoul
-
-set -euo pipefail
-
-PLANS_DIR=".plans"
-BRANCH=""
-TITLE=""
-NONE=0
-BASE="${PLAN_NUMBER_BASE:-origin/main}"
-
-die() { printf '%s\n' "$*" >&2; exit 1; }
-
-usage() {
-  cat >&2 <<'USAGE'
-Usage: plan-number [-D <plans-dir>] [-b <branch>] [--base <ref>] [--title <text>] [--none]
-
-Prints the plan number for the branch (NNN, or NNN.MM when the plan was written
-retroactively), or fails loudly.
-
-With --title, prints "[NNN] <text>" ready to hand to `gh pr create -t`.
-With --none, prints XXX: an assertion that this PR implements no plan.
-USAGE
-  exit 2
-}
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    -D|--dir)    PLANS_DIR="${2:?}"; shift 2 ;;
-    -b|--branch) BRANCH="${2:?}";    shift 2 ;;
-    --base)      BASE="${2:?}";      shift 2 ;;
-    -t|--title)  TITLE="${2:?}";     shift 2 ;;
-    -n|--none)   NONE=1;             shift   ;;
-    -h|--help)   usage ;;
-    *)           die "plan-number: unknown argument: $1" ;;
-  esac
-done
-
-# The three-digit number, optionally followed by one retroactive digit.
-NUM_RE='[0-9]{3}(\.[0-9]{2})?'
-
-if [[ "$NONE" == "1" ]]; then
-  if [[ -n "$TITLE" ]]; then printf '[XXX] %s\n' "$TITLE"; else printf 'XXX\n'; fi
-  exit 0
-fi
-
-[[ -d "$PLANS_DIR" ]] || die "plan-number: no $PLANS_DIR here. Run this from the repository root, or pass -D."
-
-# Every plan number that actually exists on disk. A resolved number is checked
-# against this, so a typo in a branch name fails here rather than in the index
-# six weeks later.
-existing="$(find "$PLANS_DIR" -mindepth 1 -maxdepth 1 -type d -exec basename {} \; \
-            | grep -oE "^${NUM_RE}" | sort -u)"
-[[ -n "$existing" ]] || die "plan-number: $PLANS_DIR holds no NNN[.MM]-<status>-<slug> folders."
-
-exists() { printf '%s\n' "$existing" | grep -qx "$1"; }
-
-emit() {
-  local n="$1"
-  exists "$n" || die "plan-number: resolved $n, but $PLANS_DIR has no folder $n-*.
-Existing plans: $(printf '%s' "$existing" | tr '\n' ' ')"
-  if [[ -n "$TITLE" ]]; then printf '[%s] %s\n' "$n" "$TITLE"; else printf '%s\n' "$n"; fi
-  exit 0
-}
-
-[[ -n "$BRANCH" ]] || BRANCH="$(git rev-parse --abbrev-ref HEAD 2>/dev/null || true)"
-
-# 1. The branch name. Matches 021 in kig/021-slug, 021-slug and feature/021_slug,
-#    and 018.01 in kig/018.01-slug. Longest match wins, so a retroactive branch
-#    does not silently resolve to its whole-number neighbour.
-if [[ "$BRANCH" =~ (^|/|-|_)([0-9]{3}(\.[0-9]{2})?)($|[-_]) ]]; then
-  emit "${BASH_REMATCH[2]}"
-fi
-
-# 2. The diff, and only when it is unambiguous.
-if git rev-parse --verify --quiet "$BASE" >/dev/null 2>&1; then
-  touched="$(git diff --name-only "$(git merge-base "$BASE" HEAD)"..HEAD -- "$PLANS_DIR" 2>/dev/null \
-             | awk -F/ 'NF>2 {print $2}' | grep -oE "^${NUM_RE}" | sort -u || true)"
-  count="$(printf '%s' "$touched" | grep -c . || true)"
-
-  if [[ "$count" == "1" ]]; then
-    emit "$touched"
-  elif [[ "${count:-0}" -gt 1 ]]; then
-    die "plan-number: this branch touches several plans and none is obviously primary:
-  $(printf '%s' "$touched" | tr '\n' ' ')
-Name the branch after the one it implements (kig/NNN-slug), or pass the title yourself."
-  fi
-fi
-
-die "plan-number: cannot resolve a plan for branch '${BRANCH:-<detached>}'.
-
-It carries no NNN in its name and its diff touches no single plan folder.
-
-  - If it implements a plan, rename the branch: git branch -m ${USER}/NNN-slug
-  - If it implements no plan, say so explicitly: plan-number --none --title '...'
-    gives you [XXX]. Infrastructure, dependency bumps and hotfixes are not
-    features, and [XXX] is the right answer for them - but it is your assertion
-    to make, not this script's guess.
-
-Refusing rather than guessing: pull-requests.md is generated from these titles,
-and a wrong number files the work under a plan that did not do it."

data/bin/setup

@@ -1,26 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-IFS=$'\n\t'
-# set -v
-
-command -v just>/dev/null  || brew install just
-command -v rbenv>/dev/null || brew install rbenv
-
-ruby_version="$(cat .ruby-version | tr -d '\n')"
-current_ruby_version="$(ruby -e 'puts RbConfig::CONFIG["RUBY_PROGRAM_VERSION"]')"
-
-if [[ ${ruby_version} != ${current_ruby_version} ]]; then
-  bash -c "$(curl -fsSL https://bit.ly/ruby-install-0-2-1)" -- ${ruby_version}
-else
-  echo -e "\e[0;33m[OK]\e[0m Ruby version ${ruby_version} is installed and current."
-fi
-
-rbenv versions | grep -q ${ruby_version} || {
-  echo -e "\e[1;31mCan't find ruby version ${ruby_version} after an attempted install.\e[0m"
-  exit 1
-}
-
-bundle check>/dev/null && {
-  echo -e "\e[0;33m[OK]\e[0m Gemfile dependencies are already satisfied."
-} || bundle install -j 12

data/evals/cases/palpatine-planner/plan-deep/fail/plan/plan.md

@@ -1,8 +0,0 @@
-# Plan
-
-Implement duplicate detection.
-
-> [!NOTE]
->
-> [2026-09-04 01:10:00 PM PDT] [ agent: palpatine-planner   status: Started, round 1 ]
-> [2026-09-04 01:14:30 PM PDT] [ agent: palpatine-planner   status: Completed, round 1 ]

data/evals/cases/palpatine-planner/plan-fast/fail/plan/plan.md

@@ -1,12 +0,0 @@
-# Plan
-
-Six units, U6 is the integration check.
-
-## Order
-
-U1, then U2 to U5 in parallel, then U6.
-
-> [!NOTE]
->
-> [2026-09-04 01:10:00 PM PDT] [ agent: palpatine-planner   status: Started, round 1 ]
-> [2026-09-04 01:14:30 PM PDT] [ agent: palpatine-planner   status: Completed, round 1 ]