biotonomy 0.1.0

package/commands/status.sh

@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bt__count_statuses() {
+  local spec="$1"
+  awk '
+    BEGIN { pending=0; in_progress=0; done=0; failed=0; blocked=0; total=0 }
+    /^\- \*\*status:\*\*/ {
+      s=$0
+      sub(/.*\*\*status:\*\* /,"",s)
+      gsub(/[[:space:]]+/,"",s)
+      total++
+      if (s=="pending") pending++
+      else if (s=="in_progress") in_progress++
+      else if (s=="done") done++
+      else if (s=="failed") failed++
+      else if (s=="blocked") blocked++
+    }
+    END {
+      printf("stories=%d pending=%d in_progress=%d done=%d failed=%d blocked=%d\n",
+        total,pending,in_progress,done,failed,blocked)
+    }
+  ' "$spec" 2>/dev/null || true
+}
+
+# New bt__show_gates for the new JSON format:
+# {"ts": "2026-02-15T17:38:00Z", "results": {"lint": {"cmd": "...", "status": 0}, ...}}
+bt__show_gates() {
+  local json_file="$1"
+  [[ -f "$json_file" ]] || return 0
+  
+  local json
+  json="$(cat "$json_file")"
+  
+  local ts
+  ts=$(printf '%s' "$json" | grep -oE '"ts": "[^"]+"' | cut -d'"' -f4 || echo "unknown")
+  
+  # A simple heuristic to check if any status is non-zero
+  # We look for "status": N where N > 0
+  local fails
+  fails=$(printf '%s' "$json" | grep -oE '"status": [1-9][0-9]*' | wc -l | xargs)
+  
+  local status="pass"
+  [[ "$fails" -gt 0 ]] && status="fail"
+
+  # Also list which ones failed if any
+  local detail=""
+  if [[ "$fails" -gt 0 ]]; then
+    # Extremely primitive extraction of keys with non-zero status
+    # Assumes format "key": {"cmd": "...", "status": N}
+    detail=" ("
+    local k
+    # This regex is a bit fragile but works for the predictable format we write
+    for k in "lint" "typecheck" "test"; do
+        if echo "$json" | grep -qE "\"$k\": \{[^\}]*\"status\": [1-9][0-9]*"; then
+            detail="${detail}${k} "
+        fi
+    done
+    detail="${detail% })"
+  fi
+  
+  printf " [gates:%s %s%s]" "$status" "$ts" "$detail"
+}
+
+bt_cmd_status() {
+  if [[ "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
+    cat <<'EOF'
+Usage:
+  bt status
+
+Shows basic Biotonomy configuration and SPEC.md progress summary.
+EOF
+    return 0
+  fi
+
+  bt_env_load || true
+
+  echo "bt v0.1.0"
+  echo "project_root: $BT_PROJECT_ROOT"
+  echo "env_file: ${BT_ENV_FILE:-<none>}"
+  echo "specs_dir: $BT_SPECS_DIR"
+  echo "state_dir: $BT_STATE_DIR"
+  echo "notify_hook: ${BT_NOTIFY_HOOK:-<none>}"
+
+  local state_dir="$BT_PROJECT_ROOT/$BT_STATE_DIR/state"
+  [[ -f "$state_dir/gates.json" ]] && echo "global:$(bt__show_gates "$state_dir/gates.json")"
+
+  local specs_path="$BT_PROJECT_ROOT/$BT_SPECS_DIR"
+  if [[ ! -d "$specs_path" ]]; then
+    echo "specs: <missing> ($specs_path)"
+    return 0
+  fi
+
+  local any=0
+  local d
+  for d in "$specs_path"/*; do
+    [[ -d "$d" ]] || continue
+    any=1
+    local feat
+    feat="$(basename "$d")"
+    local spec="$d/SPEC.md"
+    local summary
+    if [[ -f "$spec" ]]; then
+      summary="$(bt__count_statuses "$spec")"
+    else
+      summary="SPEC.md=<missing>"
+    fi
+    local gates_sum
+    gates_sum="$(bt__show_gates "$d/gates.json")"
+    echo "feature: $feat $summary$gates_sum"
+  done
+
+  [[ "$any" == "1" ]] || echo "features: <none>"
+}

package/hooks/telegram.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Minimal Telegram notification hook.
+#
+# Required env:
+#   TELEGRAM_BOT_TOKEN
+#   TELEGRAM_CHAT_ID
+#
+# Usage:
+#   BT_NOTIFY_HOOK=./hooks/telegram.sh bt status
+
+msg="$*"
+[[ -n "${msg:-}" ]] || exit 0
+
+if [[ -z "${TELEGRAM_BOT_TOKEN:-}" || -z "${TELEGRAM_CHAT_ID:-}" ]]; then
+  echo "telegram hook: missing TELEGRAM_BOT_TOKEN or TELEGRAM_CHAT_ID" >&2
+  exit 0
+fi
+
+if ! command -v curl >/dev/null 2>&1; then
+  echo "telegram hook: curl not found" >&2
+  exit 0
+fi
+
+curl -fsS \
+  -X POST \
+  -d "chat_id=${TELEGRAM_CHAT_ID}" \
+  --data-urlencode "text=${msg}" \
+  "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" >/dev/null
+

package/lib/codex.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bt_codex_bin() {
+  printf '%s\n' "${BT_CODEX_BIN:-codex}"
+}
+
+bt_codex_available() {
+  command -v "$(bt_codex_bin)" >/dev/null 2>&1
+}
+
+bt_codex_exec_full_auto() {
+  local prompt_file="$1"
+  if ! bt_codex_available; then
+    bt_warn "codex not found; skipping (set BT_CODEX_BIN or install codex)"
+    return 0
+  fi
+  local bin
+  bin="$(bt_codex_bin)"
+  local log_file
+  log_file="${BT_CODEX_LOG_FILE:-/dev/null}"
+  "$bin" exec --full-auto -C "$BT_PROJECT_ROOT" "$(cat "$prompt_file")" > >(tee -a "$log_file") 2>&1
+}
+
+bt_codex_exec_read_only() {
+  local prompt_file="$1"
+  local out_file="$2"
+  if ! bt_codex_available; then
+    bt_warn "codex not found; writing stub output to $out_file"
+    printf '%s\n' "Codex unavailable; v0.1.0 stub." >"$out_file"
+    return 0
+  fi
+  local bin
+  bin="$(bt_codex_bin)"
+  local log_file
+  log_file="${BT_CODEX_LOG_FILE:-/dev/null}"
+  "$bin" exec -s read-only -C "$BT_PROJECT_ROOT" -o "$out_file" "$(cat "$prompt_file")" > >(tee -a "$log_file") 2>&1
+}
+

package/lib/env.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bt__export_kv() {
+  local key="$1"
+  local val="$2"
+
+  [[ "$key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || return 0
+  # Export without eval; keep value literal even if it contains spaces/symbols.
+  export "$key=$val"
+}
+
+bt_env_load_file() {
+  local f="$1"
+  [[ -f "$f" ]] || return 1
+
+  bt_debug "loading env: $f"
+
+  # Parse KEY=VALUE lines (no eval), ignore comments/blank lines.
+  # Supports single/double quoted values, strips surrounding quotes.
+  while IFS= read -r line || [[ -n "$line" ]]; do
+    [[ "$line" =~ ^[[:space:]]*$ ]] && continue
+    [[ "$line" =~ ^[[:space:]]*# ]] && continue
+    line="${line#"${line%%[![:space:]]*}"}"
+
+    # Allow common `.env` style: `export KEY=VALUE`
+    if [[ "$line" =~ ^export[[:space:]]+ ]]; then
+      line="${line#export}"
+      line="${line#"${line%%[![:space:]]*}"}"
+    fi
+
+    [[ "$line" == *"="* ]] || continue
+    local key="${line%%=*}"
+    local val="${line#*=}"
+    key="${key%"${key##*[![:space:]]}"}"
+    val="${val#"${val%%[![:space:]]*}"}"
+    val="${val%"${val##*[![:space:]]}"}"
+
+    if [[ "$val" =~ ^\".*\"$ ]]; then
+      val="${val:1:${#val}-2}"
+    elif [[ "$val" =~ ^\'.*\'$ ]]; then
+      val="${val:1:${#val}-2}"
+    else
+      # Strip trailing inline comments for unquoted values: `KEY=VAL # comment`
+      val="${val%%[[:space:]]#*}"
+      val="${val%"${val##*[![:space:]]}"}"
+    fi
+
+    bt__export_kv "$key" "$val"
+  done <"$f"
+
+  export BT_ENV_FILE="$f"
+}
+
+bt_env_load() {
+  # Optional: run bt from anywhere, but operate on a specific target repo.
+  # When set, BT_TARGET_DIR becomes the effective BT_PROJECT_ROOT for all commands.
+  if [[ -n "${BT_TARGET_DIR:-}" ]]; then
+    local td
+    td="$(bt_realpath "$BT_TARGET_DIR")"
+    [[ -e "$td" ]] || bt_die "BT_TARGET_DIR does not exist: $BT_TARGET_DIR"
+    [[ -d "$td" ]] || bt_die "BT_TARGET_DIR is not a directory: $BT_TARGET_DIR"
+    export BT_TARGET_DIR="$td"
+  fi
+
+  local env_file="${BT_ENV_FILE:-}"
+  if [[ -n "$env_file" ]]; then
+    env_file="$(bt_realpath "$env_file")"
+    bt_env_load_file "$env_file" || bt_die "failed to load BT_ENV_FILE=$env_file"
+  else
+    # Prefer project config from the caller's current working directory.
+    if [[ -f "$PWD/.bt.env" ]]; then
+      bt_env_load_file "$PWD/.bt.env" || bt_die "failed to load env: $PWD/.bt.env"
+    # If running with a target repo, fall back to that repo's .bt.env.
+    elif [[ -n "${BT_TARGET_DIR:-}" && -f "$BT_TARGET_DIR/.bt.env" ]]; then
+      bt_env_load_file "$BT_TARGET_DIR/.bt.env" || bt_die "failed to load env: $BT_TARGET_DIR/.bt.env"
+    fi
+  fi
+
+  # Defaults
+  export BT_PROJECT_ROOT
+  if [[ -n "${BT_TARGET_DIR:-}" ]]; then
+    BT_PROJECT_ROOT="$BT_TARGET_DIR"
+  elif [[ -n "${BT_ENV_FILE:-}" ]]; then
+    BT_PROJECT_ROOT="$(cd "$(dirname "$BT_ENV_FILE")" && pwd)"
+  else
+    BT_PROJECT_ROOT="$PWD"
+  fi
+
+  export BT_SPECS_DIR="${BT_SPECS_DIR:-specs}"
+  export BT_STATE_DIR="${BT_STATE_DIR:-.bt}"
+  export BT_NOTIFY_HOOK="${BT_NOTIFY_HOOK:-}"
+  export BT_GATE_LINT="${BT_GATE_LINT:-}"
+  export BT_GATE_TYPECHECK="${BT_GATE_TYPECHECK:-}"
+  export BT_GATE_TEST="${BT_GATE_TEST:-}"
+}

package/lib/gates.sh

@@ -0,0 +1,109 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bt__gate_detect() {
+  # Output: lint|typecheck|test command strings (one per line) for the detected ecosystem.
+  # Empty output => no auto-detection.
+  if [[ -f "$BT_PROJECT_ROOT/pnpm-lock.yaml" ]]; then
+    printf '%s\n' "lint=pnpm lint" "typecheck=pnpm typecheck" "test=pnpm test"
+    return 0
+  fi
+  if [[ -f "$BT_PROJECT_ROOT/yarn.lock" ]]; then
+    printf '%s\n' "lint=yarn lint" "typecheck=yarn typecheck" "test=yarn test"
+    return 0
+  fi
+  if [[ -f "$BT_PROJECT_ROOT/package-lock.json" ]]; then
+    printf '%s\n' "lint=npm run lint" "typecheck=npm run typecheck" "test=npm test"
+    return 0
+  fi
+  if [[ -f "$BT_PROJECT_ROOT/Makefile" ]]; then
+    printf '%s\n' "lint=make lint" "typecheck=make typecheck" "test=make test"
+    return 0
+  fi
+  return 1
+}
+
+bt__gate_cmd() {
+  local gate="$1"
+  case "$gate" in
+    lint) printf '%s\n' "${BT_GATE_LINT:-}" ;;
+    typecheck) printf '%s\n' "${BT_GATE_TYPECHECK:-}" ;;
+    test) printf '%s\n' "${BT_GATE_TEST:-}" ;;
+    *) return 1 ;;
+  esac
+}
+
+# Returns gate config (key=cmd) for those available.
+bt_get_gate_config() {
+  local detected
+  detected="$(bt__gate_detect 2>/dev/null || true)"
+
+  local lint typecheck test
+  lint="$(bt__gate_cmd lint)"
+  typecheck="$(bt__gate_cmd typecheck)"
+  test="$(bt__gate_cmd test)"
+
+  if [[ -z "$lint" || -z "$typecheck" || -z "$test" ]]; then
+    local line k v
+    while IFS= read -r line; do
+      [[ "$line" == *"="* ]] || continue
+      k="${line%%=*}"
+      v="${line#*=}"
+      case "$k" in
+        lint) [[ -n "$lint" ]] || lint="$v" ;;
+        typecheck) [[ -n "$typecheck" ]] || typecheck="$v" ;;
+        test) [[ -n "$test" ]] || test="$v" ;;
+      esac
+    done <<<"$detected"
+  fi
+
+  [[ -n "$lint" ]] && printf 'lint=%s\n' "$lint"
+  [[ -n "$typecheck" ]] && printf 'typecheck=%s\n' "$typecheck"
+  [[ -n "$test" ]] && printf 'test=%s\n' "$test"
+}
+
+# Runs gates and returns a JSON string fragment with results.
+# Writes logs to stderr. Returns 0 if all gates passed, 1 otherwise.
+bt_run_gates() {
+  local config
+  config="$(bt_get_gate_config)"
+
+  local line k v
+  local results_json=""
+  local overall_ok=0
+  local any=0
+
+  while IFS= read -r line; do
+    [[ -n "$line" ]] || continue
+    any=1
+    k="${line%%=*}"
+    v="${line#*=}"
+
+    bt_info "gate: $k ($v)"
+    local status=0
+    # Use bash -lc for interactivity if needed, but we typically want it non-interactive.
+    # The original used bash -lc "$v". We'll stick to that but capture status.
+    if ! (cd "$BT_PROJECT_ROOT" && bash -lc "$v"); then
+      bt_err "gate failed: $k"
+      status=1
+      overall_ok=1
+    fi
+
+    local entry
+    printf -v entry '"%s": {"cmd": "%s", "status": %d}' "$k" "$v" "$status"
+    if [[ -z "$results_json" ]]; then
+      results_json="$entry"
+    else
+      results_json="$results_json, $entry"
+    fi
+  done <<<"$config"
+
+  if [[ "$any" == "0" ]]; then
+    bt_warn "no gates ran"
+    printf '{"ts": "%s", "results": {}}\n' "$(date -u +'%Y-%m-%dT%H:%M:%SZ')"
+    return 0
+  fi
+
+  printf '{"ts": "%s", "results": {%s}}\n' "$(date -u +'%Y-%m-%dT%H:%M:%SZ')" "$results_json"
+  return "$overall_ok"
+}

package/lib/log.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bt__is_tty() { [[ -t 2 ]]; }
+
+bt__color() {
+  local code="$1"
+  if [[ "${BT_NO_COLOR:-0}" == "1" ]] || ! bt__is_tty; then
+    printf ''
+  else
+    printf '\033[%sm' "$code"
+  fi
+}
+
+bt__reset() {
+  if [[ "${BT_NO_COLOR:-0}" == "1" ]] || ! bt__is_tty; then
+    printf ''
+  else
+    printf '\033[0m'
+  fi
+}
+
+bt__ts() {
+  date +"%Y-%m-%d %H:%M:%S"
+}
+
+bt_info() {
+  printf '%s %sinfo%s %s\n' "$(bt__ts)" "$(bt__color 32)" "$(bt__reset)" "$*" >&2
+}
+
+bt_warn() {
+  printf '%s %swarn%s %s\n' "$(bt__ts)" "$(bt__color 33)" "$(bt__reset)" "$*" >&2
+}
+
+bt_err() {
+  printf '%s %serr%s  %s\n' "$(bt__ts)" "$(bt__color 31)" "$(bt__reset)" "$*" >&2
+}
+
+bt_debug() {
+  [[ "${BT_DEBUG:-0}" == "1" ]] || return 0
+  printf '%s %sdbg%s  %s\n' "$(bt__ts)" "$(bt__color 90)" "$(bt__reset)" "$*" >&2
+}
+
+bt_die() {
+  bt_err "$*"
+  exit 1
+}
+

package/lib/notify.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bt_notify() {
+  local msg="$*"
+  [[ -n "${BT_NOTIFY_HOOK:-}" ]] || return 0
+  [[ -x "${BT_NOTIFY_HOOK:-}" ]] || {
+    bt_warn "BT_NOTIFY_HOOK is set but not executable: $BT_NOTIFY_HOOK"
+    return 0
+  }
+  "$BT_NOTIFY_HOOK" "$msg" || bt_warn "notify hook failed: $BT_NOTIFY_HOOK"
+}
+

package/lib/path.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bt_realpath() {
+  local p="$1"
+  if command -v realpath >/dev/null 2>&1; then
+    realpath "$p"
+    return 0
+  fi
+  if command -v python3 >/dev/null 2>&1; then
+    python3 -c 'import os,sys; print(os.path.realpath(sys.argv[1]))' "$p" 2>/dev/null && return 0
+  fi
+
+  # Best-effort fallback: not fully resolving .. or symlinks.
+  case "$p" in
+    /*) printf '%s\n' "$p" ;;
+    *) printf '%s/%s\n' "$(pwd)" "$p" ;;
+  esac
+}
+
+bt_find_up() {
+  local name="$1"
+  local start="${2:-$PWD}"
+
+  local d
+  d="$(cd "$start" && pwd)"
+
+  while :; do
+    if [[ -e "$d/$name" ]]; then
+      printf '%s\n' "$d/$name"
+      return 0
+    fi
+    [[ "$d" == "/" ]] && return 1
+    d="$(dirname "$d")"
+  done
+}

package/lib/repo.sh

@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bt_is_valid_repo_slug() {
+  local slug="${1:-}"
+  # Keep this strict and predictable: owner/repo with common GitHub-safe chars.
+  [[ -n "$slug" ]] || return 1
+  [[ "$slug" =~ ^[A-Za-z0-9][A-Za-z0-9_.-]*/[A-Za-z0-9][A-Za-z0-9_.-]*$ ]] || return 1
+  return 0
+}
+
+bt_parse_repo_from_remote_url() {
+  local url="${1:-}"
+  [[ -n "$url" ]] || return 1
+
+  local slug=""
+  case "$url" in
+    git@github.com:*)
+      slug="${url#git@github.com:}"
+      ;;
+    ssh://git@github.com/*)
+      slug="${url#ssh://git@github.com/}"
+      ;;
+    https://github.com/*)
+      slug="${url#https://github.com/}"
+      ;;
+    http://github.com/*)
+      slug="${url#http://github.com/}"
+      ;;
+    *)
+      return 1
+      ;;
+  esac
+
+  slug="${slug%.git}"
+  bt_is_valid_repo_slug "$slug" || return 1
+  printf '%s\n' "$slug"
+}
+
+bt_repo_from_git_origin() {
+  # Best-effort: only rely on origin if we're in a git worktree and origin is set.
+  local root="${1:-$PWD}"
+  command -v git >/dev/null 2>&1 || return 1
+
+  git -C "$root" rev-parse --is-inside-work-tree >/dev/null 2>&1 || return 1
+  local url
+  url="$(git -C "$root" config --get remote.origin.url 2>/dev/null || true)"
+  [[ -n "$url" ]] || return 1
+  bt_parse_repo_from_remote_url "$url"
+}
+
+bt_repo_resolve() {
+  local root="${1:-${BT_PROJECT_ROOT:-$PWD}}"
+
+  local slug=""
+  slug="$(bt_repo_from_git_origin "$root" 2>/dev/null || true)"
+  if [[ -n "$slug" ]]; then
+    printf '%s\n' "$slug"
+    return 0
+  fi
+
+  if [[ -n "${BT_REPO:-}" ]]; then
+    bt_is_valid_repo_slug "$BT_REPO" || bt_die "invalid BT_REPO (expected owner/repo): $BT_REPO"
+    printf '%s\n' "$BT_REPO"
+    return 0
+  fi
+
+  bt_die "repo resolution failed: set BT_REPO=owner/repo in .bt.env (no usable git remote origin found)"
+}
+

package/lib/state.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bt_specs_path() {
+  printf '%s/%s' "$BT_PROJECT_ROOT" "$BT_SPECS_DIR"
+}
+
+bt_feature_dir() {
+  local feature="$1"
+  printf '%s/%s' "$(bt_specs_path)" "$feature"
+}
+
+bt_ensure_dirs() {
+  mkdir -p "$(bt_specs_path)" "$BT_PROJECT_ROOT/$BT_STATE_DIR"
+}
+
+bt_require_feature() {
+  local feature="${1:-${BT_FEATURE:-}}"
+  [[ -n "$feature" ]] || bt_die "feature required (pass as first arg or set BT_FEATURE)"
+
+  # Prevent path traversal and keep on-disk state predictable.
+  [[ "$feature" != *"/"* ]] || bt_die "invalid feature (must not contain '/'): $feature"
+  [[ "$feature" != *".."* ]] || bt_die "invalid feature (must not contain '..'): $feature"
+  [[ "$feature" =~ ^[A-Za-z0-9][A-Za-z0-9._-]*$ ]] || bt_die "invalid feature (allowed: A-Z a-z 0-9 . _ -): $feature"
+  printf '%s\n' "$feature"
+}
+
+bt_progress_append() {
+  local feature="$1"
+  local msg="$2"
+  local dir
+  dir="$(bt_feature_dir "$feature")"
+  mkdir -p "$dir/history"
+  printf '%s %s\n' "$(date +'%Y-%m-%d %H:%M:%S')" "$msg" >>"$dir/progress.txt"
+}
+
+bt_history_write() {
+  local feature="$1"
+  local stage="$2"
+  local content="$3"
+  local dir
+  dir="$(bt_feature_dir "$feature")"
+  mkdir -p "$dir/history"
+
+  local max=0 f base n
+  shopt -s nullglob
+  for f in "$dir/history/"[0-9][0-9][0-9]-*.md; do
+    base="$(basename "$f")"
+    n="${base%%-*}"
+    [[ "$n" =~ ^[0-9]{3}$ ]] || continue
+    ((10#$n > max)) && max=$((10#$n))
+  done
+  shopt -u nullglob
+  n="$((max + 1))"
+  printf -v n '%03d' "$n"
+
+  local out="$dir/history/${n}-${stage}.md"
+  printf '%s\n' "$content" >"$out"
+  printf '%s\n' "$out"
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "biotonomy",
+  "version": "0.1.0",
+  "description": "Codex-native autonomous development loop CLI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/archive-dot-com/biotonomy.git"
+  },
+  "bugs": {
+    "url": "https://github.com/archive-dot-com/biotonomy/issues"
+  },
+  "homepage": "https://github.com/archive-dot-com/biotonomy#readme",
+  "bin": {
+    "bt": "bt"
+  },
+  "files": [
+    "bt",
+    "bt.sh",
+    "commands/",
+    "lib/",
+    "prompts/",
+    "hooks/",
+    "scripts/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node tests/run.mjs",
+    "lint": "bash scripts/lint-shell.sh",
+    "demo": "bash scripts/demo-issue-3-real-loop.sh",
+    "pr:open": "bash scripts/gh-pr.sh",
+    "verify:pack": "node scripts/verify-pack.mjs",
+    "prepublishOnly": "npm test && npm run lint && npm run verify:pack"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/prompts/fix.md

@@ -0,0 +1,17 @@
+# Fix (Biotonomy v0.1.0)
+
+You are the fix agent. Apply targeted patches to address `REVIEW.md` findings only.
+
+Rules:
+- No rewrites. Keep changes minimal and localized.
+- Update/add tests to prevent regressions.
+- Re-run quality gates after changes.
+
+Inputs:
+- `specs/<feature>/REVIEW.md`
+- `specs/<feature>/SPEC.md`
+
+Outputs:
+- Surgical code changes + tests
+- Updated `SPEC.md` if story status changes
+