agent-bios 0.9.8 → 0.10.0

package/scripts/install.sh

@@ -1,819 +0,0 @@
-#!/usr/bin/env bash
-# agent-bios installer.
-#
-# Deploys the single-source-of-truth (globals, scoped guides, Codex agent
-# templates, Codex wrappers, the launch profile/shell/bin, a managed Textual
-# venv, and the zsh hook) into $HOME by COPY — idempotent, backed up before
-# overwrite, and reversible. Distributed as an npm bin; the actual $HOME
-# deployment is this explicit command (never a postinstall side effect).
-#
-# Usage:
-#   agent-bios install     deploy into this environment (backs up + verifies)
-#   agent-bios verify      check the deployed state matches the source
-#   agent-bios status      show what is installed and where
-#   agent-bios update      git pull + reinstall (clone), or print the npm update line
-#   agent-bios uninstall   remove deployed files and the zsh hook
-#   agent-bios help
-#
-# Flags: --dry-run (print actions, change nothing).
-# Env overrides: CLAUDE_CONFIG_DIR, CODEX_HOME, AGENT_LAUNCH_VENV, ZDOTDIR.
-set -euo pipefail
-
-# This installer is non-interactive: every input arrives as a subcommand, flag,
-# or env var. Detach stdin so no child (the codex-helm dry-run, pip, git) can
-# block forever on an inherited idle stdin — that is what hangs an install under
-# CI, pipes, and background runs, where stdin stays open but never delivers.
-# `learn` is the one subcommand whose payload IS stdin, so keep the caller's on
-# fd 3 first and hand it back only there; every other path still sees /dev/null.
-exec 3<&0 2>/dev/null || exec 3</dev/null   # tolerate a caller that closed fd 0
-exec </dev/null
-
-# Resolve this script through symlinks before locating the package: npm links the
-# bin into node_modules/.bin and the global bin dir, so $0 is a link and its
-# dirname is the link's directory, not the package. Without this the source tree
-# resolves to the bin dir's parent (e.g. /opt/homebrew) and every deploy fails.
-SOURCE="${BASH_SOURCE[0]}"
-while [ -L "$SOURCE" ]; do
-  LINKDIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
-  SOURCE="$(readlink "$SOURCE")"
-  case "$SOURCE" in
-    /*) ;;
-    *) SOURCE="$LINKDIR/$SOURCE" ;;
-  esac
-done
-SELF="$(cd -P "$(dirname "$SOURCE")" && pwd)"
-REPO="$(cd "$SELF/.." && pwd)"
-
-CLAUDE_DIR="${CLAUDE_CONFIG_DIR:-$HOME/.claude}"
-CODEX_DIR="${CODEX_HOME:-$HOME/.codex}"
-LAUNCH_DIR="$HOME/.config/agent-launch"
-USER_PRESETS_NAME="presets.local.toml"  # user-owned; never deployed or verified
-BIN_DIR="$HOME/.local/bin"
-STATE_DIR="$HOME/.local/share/agent-bios"
-LEGACY_STATE_DIR="$HOME/.local/share/agent-dotfiles"  # pre-rename state; migrated on first run
-MANIFEST="$STATE_DIR/manifest.txt"
-ZSHRC="${ZDOTDIR:-$HOME}/.zshrc"
-ZSH_HOOK='[ -r "$HOME/.config/agent-launch/shell.zsh" ] && source "$HOME/.config/agent-launch/shell.zsh"'
-HOOK_MARK='agent-launch/shell.zsh'
-
-DRY_RUN=0
-BACKUP_DIR=""
-
-log()  { printf '%s\n' "$*"; }
-info() { printf '  %s\n' "$*"; }
-run()  { if [ "$DRY_RUN" = 1 ]; then printf '  [dry-run] %s\n' "$*"; else "$@"; fi; }
-
-# ---- prerequisites -------------------------------------------------------
-check_prereqs() {
-  local ok=0
-  command -v git >/dev/null 2>&1 || { log "missing prerequisite: git"; ok=1; }
-  command -v python3 >/dev/null 2>&1 || { log "missing prerequisite: python3"; ok=1; }
-  if command -v python3 >/dev/null 2>&1; then
-    python3 -c 'import sys; sys.exit(0 if sys.version_info>=(3,11) else 1)' 2>/dev/null \
-      || { log "python3 >= 3.11 required (tomllib)"; ok=1; }
-  fi
-  command -v zsh >/dev/null 2>&1 || log "note: zsh not found; the shell hook targets zsh"
-  command -v codex >/dev/null 2>&1 || log "note: codex CLI not found; Codex-side steps will be skipped"
-  command -v claude >/dev/null 2>&1 || log "note: claude CLI not found"
-  return $ok
-}
-
-# ---- copy with backup + manifest ----------------------------------------
-deploy_file() {
-  local src="$1" dst="$2" mode="${3:-}"
-  [ -f "$src" ] || { log "source missing: $src"; return 1; }
-  if [ -f "$dst" ] && cmp -s "$src" "$dst"; then
-    info "unchanged  $dst"
-  else
-    if [ -f "$dst" ] && [ -n "$BACKUP_DIR" ]; then
-      run mkdir -p "$(dirname "$BACKUP_DIR$dst")"
-      run cp "$dst" "$BACKUP_DIR$dst"
-    fi
-    run mkdir -p "$(dirname "$dst")"
-    run cp "$src" "$dst"
-    if [ -n "$mode" ]; then run chmod "$mode" "$dst"; fi
-    [ "$DRY_RUN" = 1 ] || info "installed  $dst"
-  fi
-  [ "$DRY_RUN" = 1 ] || printf '%s\n' "$dst" >> "$MANIFEST"
-}
-
-deploy_glob() {
-  local srcdir="$1" pat="$2" dstdir="$3" mode="${4:-}" f
-  for f in "$srcdir"/$pat; do
-    [ -f "$f" ] || continue
-    deploy_file "$f" "$dstdir/$(basename "$f")" "$mode"
-  done
-}
-
-# ---- packaged (domain-selected) corpus deploy ----------------------------
-# Active when --domains is passed or a prior selection exists in STATE_DIR.
-# assemble.py owns the corpus surfaces (central tree, entry seeding, codex
-# marker region, settings merge); the entry CLAUDE.md and AGENTS.md are NOT
-# manifested — the entry is user-owned after seeding, AGENTS.md holds a
-# personal region — so uninstall never deletes them.
-# Full mode never runs the assembler, so nothing registered the hooks it
-# deployed — the files landed and never fired. Reuse the assembler's own merge
-# so both install paths register identically, under one ownership rule.
-register_hooks_full() {
-  [ "$DRY_RUN" = 1 ] && { info "[dry-run] register central hooks"; return 0; }
-  python3 "$REPO/scripts/register-hooks.py" "$REPO" "$CLAUDE_DIR" \
-    || log "note: hook registration failed; the deployed hooks will not fire"
-}
-
-packaged_mode() { [ "${DOMAINS_SET:-0}" = 1 ] || [ -f "$STATE_DIR/selection.json" ]; }
-
-assemble_packaged() {
-  local args=(--claude-dir "$CLAUDE_DIR" --codex-dir "$CODEX_DIR" --state-dir "$STATE_DIR") rc=0
-  [ "${DOMAINS_SET:-0}" = 1 ] && args+=(--domains "$DOMAINS_ARG")
-  [ "$DRY_RUN" = 1 ] && args+=(--dry-run)
-  python3 "$REPO/scripts/assemble.py" "${args[@]}" || rc=$?
-  if [ "$rc" = 2 ]; then
-    log "packaged: entry file needs user action (import line missing); central content will not load until it is added"
-  elif [ "$rc" != 0 ]; then
-    return 1
-  fi
-  if [ "$DRY_RUN" != 1 ]; then
-    find "$CLAUDE_DIR/central" "$CODEX_DIR/guides" -type f 2>/dev/null >> "$MANIFEST"
-  fi
-}
-
-add_zsh_hook() {
-  if [ -f "$ZSHRC" ] && grep -qF "$HOOK_MARK" "$ZSHRC"; then
-    info "zsh hook present  $ZSHRC"
-    return
-  fi
-  if [ "$DRY_RUN" = 1 ]; then info "[dry-run] append zsh hook to $ZSHRC"; return; fi
-  printf '%s\n' "$ZSH_HOOK" >> "$ZSHRC"
-  info "added zsh hook  $ZSHRC"
-}
-
-# Carry state written under the pre-rename directory so an existing install keeps
-# its manifest and backups instead of stranding them.
-migrate_state() {
-  if [ -d "$STATE_DIR" ] || [ ! -d "$LEGACY_STATE_DIR" ]; then
-    return
-  fi
-  if [ "$DRY_RUN" = 1 ]; then
-    info "[dry-run] migrate state $LEGACY_STATE_DIR -> $STATE_DIR"
-    return
-  fi
-  mkdir -p "$(dirname "$STATE_DIR")"
-  mv "$LEGACY_STATE_DIR" "$STATE_DIR" && info "migrated state  $LEGACY_STATE_DIR -> $STATE_DIR"
-}
-
-# ---- codex live-config additions -----------------------------------------
-# The live ~/.codex/config.toml is user/runtime-owned; agent-bios never
-# deploys or overwrites it. codex/config-additions.toml declares the only
-# content agent-bios manages there — one marked [agents.*] block plus a tagged
-# features.multi_agent line — and this helper merges (install), checks
-# (verify), or removes (uninstall) exactly that content, backed up and
-# tomllib-validated before any write. Modes: merge | check | remove.
-codex_config_additions() {
-  AB_MODE="$1" AB_CODEX_DIR="$CODEX_DIR" AB_FRAGMENT="$REPO/codex/config-additions.toml" \
-  AB_BACKUP="${BACKUP_DIR:-}" AB_DRY="$DRY_RUN" python3 - <<'PY'
-import os, pathlib, sys, tomllib
-
-mode = os.environ["AB_MODE"]
-codex_dir = pathlib.Path(os.environ["AB_CODEX_DIR"])
-fragment_path = pathlib.Path(os.environ["AB_FRAGMENT"])
-backup_root = os.environ.get("AB_BACKUP", "")
-dry = os.environ.get("AB_DRY") == "1"
-target = codex_dir / "config.toml"
-BEGIN = "# >>> agent-bios additions >>>"
-END = "# <<< agent-bios additions <<<"
-TAG = "# agent-bios"
-
-def info(msg): print(f"  {msg}")
-def fail(msg): print(msg); sys.exit(1)
-
-frag_text = fragment_path.read_text().replace("${CODEX_HOME}", str(codex_dir))
-want_agents = tomllib.loads(frag_text)["agents"]
-live_text = target.read_text() if target.is_file() else ""
-try:
-    live = tomllib.loads(live_text) if live_text else {}
-except Exception as exc:
-    fail(f"live codex config does not parse; not touching it: {target} ({exc})")
-
-def state_ok():
-    if live.get("features", {}).get("multi_agent") is not True:
-        return False
-    return all(
-        live.get("agents", {}).get(name, {}).get(key) == spec[key]
-        for name, spec in want_agents.items()
-        for key in ("description", "config_file")
-    )
-
-if mode == "check":
-    problems = []
-    if live.get("features", {}).get("multi_agent") is not True:
-        problems.append("features.multi_agent is not true")
-    for name, spec in want_agents.items():
-        if live.get("agents", {}).get(name, {}).get("config_file") != spec["config_file"]:
-            problems.append(f"agents.{name}.config_file drifted or missing")
-        elif not pathlib.Path(spec["config_file"]).is_file():
-            problems.append(f"agents.{name} template missing: {spec['config_file']}")
-    if problems:
-        fail(f"codex config additions: {'; '.join(problems)} ({target})")
-    info("codex config additions OK")
-    sys.exit(0)
-
-def strip_managed(text):
-    out, skipping = [], False
-    for line in text.splitlines(keepends=True):
-        s = line.strip()
-        if s == BEGIN: skipping = True; continue
-        if s == END: skipping = False; continue
-        if skipping or s.endswith(TAG): continue
-        out.append(line)
-    return "".join(out)
-
-if mode == "remove":
-    if not target.is_file():
-        sys.exit(0)
-    stripped = strip_managed(live_text)
-    if stripped == live_text:
-        info(f"no agent-bios additions in {target}")
-        sys.exit(0)
-    try:
-        tomllib.loads(stripped)
-    except Exception as exc:
-        fail(f"refusing removal; result would not parse: {exc}")
-    if dry:
-        info(f"[dry-run] remove agent-bios additions from {target}")
-        sys.exit(0)
-    backup = target.with_name(target.name + ".bak-agent-bios-uninstall")
-    backup.write_text(live_text)
-    target.write_text(stripped)
-    info(f"removed additions  {target} (backup: {backup.name})")
-    sys.exit(0)
-
-# mode == merge
-if state_ok():
-    info(f"unchanged  {target} (additions present)")
-    sys.exit(0)
-
-# A drifted [agents.<tier>] outside our markers would become a duplicate
-# table if we appended ours; that conflict needs the user, not a clobber.
-base = strip_managed(live_text)
-base_data = tomllib.loads(base) if base.strip() else {}
-clash = [name for name in want_agents if name in base_data.get("agents", {})]
-if clash:
-    fail(
-        f"unmanaged [agents.{'/'.join(clash)}] with drifted content in {target}; "
-        "align or remove them, then rerun install"
-    )
-
-block_lines = [BEGIN]
-if "features" not in base_data:
-    block_lines += ["[features]", f"multi_agent = true  {TAG}"]
-for name, spec in want_agents.items():
-    block_lines += [
-        f"[agents.{name}]",
-        f'description = "{spec["description"]}"',
-        f'config_file = "{spec["config_file"]}"',
-    ]
-block_lines.append(END)
-block = "\n".join(block_lines) + "\n"
-
-new_text = base
-if "features" in base_data:
-    if base_data["features"].get("multi_agent") is None:
-        lines = new_text.splitlines(keepends=True)
-        for i, line in enumerate(lines):
-            if line.strip() == "[features]":
-                lines.insert(i + 1, f"multi_agent = true  {TAG}\n")
-                break
-        new_text = "".join(lines)
-    elif base_data["features"].get("multi_agent") is not True:
-        info(f"note: features.multi_agent explicitly set in {target}; leaving it")
-if new_text and not new_text.endswith("\n"):
-    new_text += "\n"
-new_text += ("\n" if new_text else "") + block
-
-try:
-    tomllib.loads(new_text)
-except Exception as exc:
-    fail(f"merge result would not parse; live config untouched ({exc})")
-if dry:
-    info(f"[dry-run] merge agent-bios additions into {target}")
-    sys.exit(0)
-if live_text and backup_root:
-    bpath = pathlib.Path(backup_root + str(target))
-    bpath.parent.mkdir(parents=True, exist_ok=True)
-    bpath.write_text(live_text)
-target.parent.mkdir(parents=True, exist_ok=True)
-target.write_text(new_text)
-info(f"merged additions  {target}")
-PY
-}
-
-# ---- optional dependencies -----------------------------------------------
-# Capabilities are optional: a missing one only degrades the review routes that
-# need it. config/agent-launch.toml is the single source for both the command
-# that gates a route and the install line offered here.
-capability_table() {
-  python3 - "$REPO/config/agent-launch.toml" <<'PY'
-import sys, tomllib
-for name, cap in tomllib.load(open(sys.argv[1], "rb")).get("capabilities", {}).items():
-    print("\t".join((name, cap.get("command", ""), cap.get("install", ""))))
-PY
-}
-
-install_capability() {
-  local name="$1" line="$2"
-  log "Installing optional dependency $name: $line"
-  if [ "$DRY_RUN" = 1 ]; then info "[dry-run] $line"; return 0; fi
-  if sh -c "$line"; then info "installed  $name"; else log "warning: installing $name failed; routes needing it stay degraded"; fi
-}
-
-handle_capabilities() {
-  local requested="$1" name command line
-  # Fail on a typo rather than silently installing nothing.
-  local known; known=$(capability_table | cut -f1)
-  local want
-  for want in ${requested//,/ }; do
-    printf '%s\n' "$known" | grep -qx "$want" || {
-      log "unknown --with capability: $want (known: $(printf '%s' "$known" | tr '\n' ' '))"; return 1; }
-  done
-  while IFS=$'\t' read -r name command line; do
-    [ -n "$name" ] || continue
-    if command -v "$command" >/dev/null 2>&1; then
-      info "capability present  $name ($command)"
-      continue
-    fi
-    if printf '%s\n' "${requested//,/ }" | tr ' ' '\n' | grep -qx "$name"; then
-      [ -n "$line" ] && install_capability "$name" "$line" \
-        || log "note: $name has no configured install line"
-    elif [ -n "$line" ] && [ -t 0 ] && [ "$DRY_RUN" != 1 ]; then
-      printf '  Install optional dependency %s? (%s) [y/N] ' "$name" "$line"
-      local answer=""; read -r answer </dev/tty || answer=""
-      case "$answer" in
-        [yY]*) install_capability "$name" "$line" ;;
-        *) info "skipped  $name — install later: $line" ;;
-      esac
-    else
-      info "optional  $name unavailable; routes needing it degrade${line:+ — install: $line}"
-    fi
-  done <<EOF
-$(capability_table)
-EOF
-}
-
-# Presets the launcher saved into the deployed profiles.toml (pre-split, or by hand)
-# would be lost to the cp below; move them into the user-owned presets file first.
-migrate_user_presets() {
-  local src="$REPO/config/agent-launch.toml"
-  local dst="$LAUNCH_DIR/profiles.toml"
-  local user="$LAUNCH_DIR/$USER_PRESETS_NAME"
-  [ -f "$dst" ] || return 0
-  python3 - "$src" "$dst" "$user" "$DRY_RUN" <<'PY' || { log "user preset migration failed; not overwriting $LAUNCH_DIR/profiles.toml"; return 1; }
-import os, pathlib, re, sys, tomllib
-
-src, dst, user, dry_run = pathlib.Path(sys.argv[1]), pathlib.Path(sys.argv[2]), pathlib.Path(sys.argv[3]), sys.argv[4] == "1"
-dst_text = dst.read_text()
-shipped = set(tomllib.loads(src.read_text()).get("presets", {}))
-extra = set(tomllib.loads(dst_text).get("presets", {})) - shipped
-if not extra:
-    sys.exit(0)
-existing_text = user.read_text() if user.is_file() else ""
-already = set(tomllib.loads(existing_text).get("presets", {})) if existing_text else set()
-move = sorted(extra - already)
-for name in sorted(extra & already):
-    print(f"  kept in {user.name}  {name} (already saved there)")
-if not move:
-    sys.exit(0)
-
-header = re.compile(r'^\[presets\.(?:"([^"]+)"|([A-Za-z0-9][A-Za-z0-9_-]*))(?:[.\]])')
-blocks, current = {}, None
-for line in dst_text.splitlines(keepends=True):
-    stripped = line.strip()
-    if stripped.startswith("["):
-        found = header.match(stripped)
-        current = (found.group(1) or found.group(2)) if found else None
-    if current in move:
-        blocks.setdefault(current, []).append(line)
-# Refuse to deploy over a preset we could not carry across, rather than drop it.
-missing = [name for name in move if name not in blocks]
-if missing:
-    sys.exit(f"cannot extract preset block(s) from {dst}: {', '.join(missing)}")
-
-out = existing_text.rstrip("\n") or (
-    "# agent-launch user presets, moved out of profiles.toml by agent-bios install.\n"
-    "# The installer never deploys or verifies this file, so presets here survive upgrades."
-)
-for name in move:
-    out += "\n\n" + "".join(blocks[name]).strip("\n")
-for name in move:
-    print(f"  {'[dry-run] ' if dry_run else ''}moved preset  {name} -> {user}")
-if dry_run:
-    sys.exit(0)
-user.parent.mkdir(parents=True, exist_ok=True)
-temporary = user.with_name(f".{user.name}.{os.getpid()}.tmp")
-temporary.write_text(out + "\n")
-os.replace(temporary, user)
-PY
-}
-
-remove_zsh_hook() {
-  if [ ! -f "$ZSHRC" ] || ! grep -qF "$HOOK_MARK" "$ZSHRC"; then
-    info "no zsh hook to remove"
-    return
-  fi
-  if [ "$DRY_RUN" = 1 ]; then info "[dry-run] remove zsh hook from $ZSHRC"; return; fi
-  grep -vF "$HOOK_MARK" "$ZSHRC" > "$ZSHRC.agent-tmp" && mv "$ZSHRC.agent-tmp" "$ZSHRC"
-  info "removed zsh hook  $ZSHRC"
-}
-
-# Promote -> migrate (collection loop, Phase 4): after the corpus is deployed,
-# clear personal copies of learnings that have been promoted into the shared
-# corpus AND are in this user's assembled bundle. Best-effort: a prune failure
-# (or an absent manifest/script) never fails the install. Runs per host.
-migrate_learnings() {
-  local script="$REPO/scripts/migrate-learnings.py"
-  { [ -f "$script" ] && [ -f "$REPO/config/promotions.json" ]; } || return 0
-  local -a sel dry
-  if packaged_mode; then sel=(--selection-file "$STATE_DIR/selection.json"); else sel=(--full); fi
-  [ "$DRY_RUN" = 1 ] && dry=(--dry-run) || dry=()
-  # ${dry[@]+...}: expanding an empty array as "${dry[@]}" is an unbound-variable
-  # error under `set -u` on bash 3.2 (macOS default) and would abort the install.
-  python3 "$script" --host claude --config-dir "$CLAUDE_DIR" "${sel[@]}" ${dry[@]+"${dry[@]}"} \
-    || info "learnings migrate (claude) skipped"
-  python3 "$script" --host codex --config-dir "$CODEX_DIR" "${sel[@]}" ${dry[@]+"${dry[@]}"} \
-    || info "learnings migrate (codex) skipped"
-}
-
-# ---- subcommands ---------------------------------------------------------
-cmd_install() {
-  check_prereqs || { log "resolve the prerequisites above and retry"; exit 1; }
-  migrate_state
-  if [ "$DRY_RUN" != 1 ]; then
-    mkdir -p "$STATE_DIR"
-    BACKUP_DIR="$STATE_DIR/backups/$(date +%Y%m%d-%H%M%S)"
-    : > "$MANIFEST"
-  fi
-  log "Deploying agent-bios from $REPO"
-  if packaged_mode; then
-    log "packaged mode: assembling selected domains (state: $STATE_DIR/selection.json)"
-    assemble_packaged || exit 1
-  else
-    deploy_file "$REPO/claude/CLAUDE.md" "$CLAUDE_DIR/CLAUDE.md"
-    deploy_glob "$REPO/claude/guides" "*.md" "$CLAUDE_DIR/guides"
-    deploy_glob "$REPO/claude/agents" "*.md" "$CLAUDE_DIR/agents"
-    # Our hooks go under central/: <claude>/hooks is shared with other tools
-    # files, caches, and state, and we must not own a directory we share.
-    deploy_glob "$REPO/claude/hooks" "*.py" "$CLAUDE_DIR/central/hooks" "+x"
-    register_hooks_full
-    deploy_file "$REPO/codex/AGENTS.md" "$CODEX_DIR/AGENTS.md"
-    deploy_glob "$REPO/codex/guides" "*.md" "$CODEX_DIR/guides"
-  fi
-  migrate_learnings   # Phase 4: clear personal copies now absorbed by the corpus
-  deploy_glob "$REPO/codex/agents" "*.toml" "$CODEX_DIR/agents"
-  codex_config_additions merge || exit 1
-  deploy_file "$REPO/scripts/codex-run.sh"  "$CODEX_DIR/bin/codex-run"  "+x"
-  deploy_file "$REPO/scripts/codex-helm.sh" "$CODEX_DIR/bin/codex-helm" "+x"
-  migrate_user_presets || exit 1   # must precede the deploy below, which overwrites profiles.toml
-  deploy_file "$REPO/config/agent-launch.toml" "$LAUNCH_DIR/profiles.toml"
-  deploy_file "$REPO/shell/agent-launch.zsh"   "$LAUNCH_DIR/shell.zsh"
-  deploy_file "$REPO/scripts/agent-launch.py"  "$BIN_DIR/agent-launch" "+x"
-  log ""
-  log "Optional dependencies (missing ones only degrade the routes that need them)..."
-  handle_capabilities "$WITH" || exit 1
-  log ""
-  if [ "$DRY_RUN" = 1 ]; then
-    info "[dry-run] provision managed Textual venv"
-  else
-    bash "$REPO/scripts/provision-venv.sh" && info "managed venv OK" \
-      || log "warning: venv provisioning failed (numbered-prompt fallback applies)"
-  fi
-  add_zsh_hook
-  if python3 "$REPO/scripts/session-distill/corpus-state.py" project --repo "$REPO" >/dev/null 2>&1; then
-    info "corpus-status projected"
-  else
-    log "note: corpus-status projection unavailable (versions.json/ledger missing?)"
-  fi
-  # Deploy/system version marker for the launcher's TUI version line, read from
-  # package.json (version + releaseDate) — distinct from the corpus content
-  # version. Best-effort: a failure here never fails the install.
-  if [ "$DRY_RUN" != 1 ]; then
-    if python3 - "$REPO/package.json" "$STATE_DIR/version.json" <<'PY' 2>/dev/null
-import json, sys
-pkg = json.load(open(sys.argv[1]))
-with open(sys.argv[2], "w") as f:
-    json.dump({"version": pkg.get("version"), "releaseDate": pkg.get("releaseDate")}, f)
-    f.write("\n")
-PY
-    then
-      printf '%s\n' "$STATE_DIR/version.json" >> "$MANIFEST"
-      info "version marker written ($STATE_DIR/version.json)"
-    else
-      log "note: version marker not written (package.json unreadable)"
-    fi
-  fi
-  log ""
-  log "Verifying deployment..."
-  if cmd_verify; then
-    log ""
-    log "Done. Open a new shell (or: source \"$ZSHRC\") to activate the zero-arg launcher."
-    # An untouched backup dir means nothing was replaced; that healthy state
-    # must not become a nonzero exit under set -e.
-    { [ -n "$BACKUP_DIR" ] && [ -d "$BACKUP_DIR" ] && log "Replaced files were backed up under $BACKUP_DIR"; } || true
-  else
-    log "VERIFY FAILED after install — see messages above"
-    exit 1
-  fi
-}
-
-verify_match()   { if cmp -s "$1" "$2"; then info "match    $2"; else log "MISMATCH/absent  $2"; return 1; fi; }
-verify_present() { if [ -f "$1" ]; then return 0; else log "missing  $1"; return 1; fi; }
-
-cmd_verify() {
-  local fail=0 gp
-  if [ ! -d "$REPO/.git" ] && [ "$(drift_state)" = "drift" ]; then
-    log "deploy drift: deployed $(deployed_version), package $(source_version) — run: agent-bios install"
-    fail=1
-  fi
-  if packaged_mode; then
-    # Packaged: corpus surfaces are selection-derived, not repo-identical.
-    # The entry file is user-owned — READ-check the import line, never rewrite.
-    python3 "$REPO/scripts/check-domains.py" >/dev/null 2>&1 && info "domains gate OK" || { log "domains gate FAILED"; fail=1; }
-    verify_present "$CLAUDE_DIR/central/bundle.md" || fail=1
-    if grep -qF '@central/bundle.md' "$CLAUDE_DIR/CLAUDE.md" 2>/dev/null; then
-      info "entry import line present"
-    else
-      log "entry $CLAUDE_DIR/CLAUDE.md lacks '@central/bundle.md' — central corpus is NOT loading"; fail=1
-    fi
-    if grep -qF 'agent-bios:central:start' "$CODEX_DIR/AGENTS.md" 2>/dev/null; then
-      info "codex central region present"
-    else
-      log "codex AGENTS.md central region missing"; fail=1
-    fi
-  else
-    verify_match "$REPO/claude/CLAUDE.md"        "$CLAUDE_DIR/CLAUDE.md"        || fail=1
-    verify_match "$REPO/codex/AGENTS.md"         "$CODEX_DIR/AGENTS.md"         || fail=1
-    for gp in "$REPO"/claude/guides/*.md; do verify_present "$CLAUDE_DIR/guides/$(basename "$gp")" || fail=1; done
-    for gp in "$REPO"/claude/agents/*.md; do verify_present "$CLAUDE_DIR/agents/$(basename "$gp")" || fail=1; done
-    for gp in "$REPO"/claude/hooks/*.py;  do verify_present "$CLAUDE_DIR/central/hooks/$(basename "$gp")"  || fail=1; done
-    for gp in "$REPO"/codex/guides/*.md;  do verify_present "$CODEX_DIR/guides/$(basename "$gp")"  || fail=1; done
-  fi
-  verify_match "$REPO/scripts/agent-launch.py" "$BIN_DIR/agent-launch"        || fail=1
-  verify_match "$REPO/config/agent-launch.toml" "$LAUNCH_DIR/profiles.toml"   || fail=1
-  verify_match "$REPO/shell/agent-launch.zsh"  "$LAUNCH_DIR/shell.zsh"        || fail=1
-  python3 - "$CODEX_DIR/agents" <<'PY' && info "agent TOMLs OK" || fail=1
-import sys, pathlib, tomllib
-root = pathlib.Path(sys.argv[1])
-required = {"frontier.toml", "workhorse.toml", "sweep.toml", "reviewer.toml"}
-missing = required - {p.name for p in root.glob("*.toml")}
-assert not missing, f"missing agent TOMLs in {root}: {sorted(missing)}"
-for p in sorted(root.glob("*.toml")):
-    tomllib.loads(p.read_text())
-PY
-  codex_config_additions check || fail=1
-  if command -v codex >/dev/null 2>&1 && [ -x "$CODEX_DIR/bin/codex-helm" ]; then
-    if "$CODEX_DIR/bin/codex-helm" --dry-run --mode review "probe" >/dev/null 2>&1; then
-      info "codex-helm dry-run OK"
-    else
-      log "codex-helm dry-run FAILED"; fail=1
-    fi
-  fi
-  local vpy="${AGENT_LAUNCH_VENV:-$HOME/.local/share/agent-launch/venv}/bin/python"
-  if [ -x "$vpy" ] && "$vpy" -c 'import textual' 2>/dev/null; then
-    info "managed venv (textual) OK"
-  else
-    log "note: managed venv/textual unavailable (numbered-prompt fallback applies)"
-  fi
-  # A file this installer executes but never ships is invisible from a clone and
-  # fatal on npm, so the payload gate runs wherever it exists (maintainer-side).
-  if [ -x "$REPO/scripts/check-package.sh" ]; then
-    if "$REPO/scripts/check-package.sh" >/dev/null 2>&1; then
-      info "npm payload OK"
-    else
-      log "npm payload incomplete; run scripts/check-package.sh"
-      fail=1
-    fi
-  fi
-  # Repo-internal mirror parity is a maintainer gate; only meaningful from a clone.
-  if [ -d "$REPO/ko" ] && [ -x "$REPO/scripts/check-parity.sh" ]; then
-    if "$REPO/scripts/check-parity.sh" >/dev/null 2>&1; then info "repo mirror parity OK"; else log "repo mirror parity FAILED"; fail=1; fi
-  fi
-  # Prompting guides name concrete models, so they go stale on a model change
-  # rather than degrading quietly; this checks them against the launch config.
-  if [ -x "$REPO/scripts/check-prompting-targets.sh" ]; then
-    if "$REPO/scripts/check-prompting-targets.sh" >/dev/null 2>&1; then
-      info "prompting targets OK"
-    else
-      log "prompting guides do not cover a configured model; run scripts/check-prompting-targets.sh"
-      fail=1
-    fi
-  fi
-  return $fail
-}
-
-cmd_uninstall() {
-  migrate_state
-  codex_config_additions remove || log "warning: could not remove codex config additions"
-  if [ -f "$MANIFEST" ]; then
-    local f
-    while IFS= read -r f; do
-      [ -n "$f" ] || continue
-      [ -f "$f" ] && { run rm -f "$f"; [ "$DRY_RUN" = 1 ] || info "removed  $f"; }
-    done < "$MANIFEST"
-    [ "$DRY_RUN" = 1 ] || rm -f "$MANIFEST"
-  else
-    log "no manifest at $MANIFEST; removing known deploy targets"
-    local p
-    for p in "$CLAUDE_DIR/CLAUDE.md" "$CODEX_DIR/AGENTS.md" \
-             "$CODEX_DIR/bin/codex-run" "$CODEX_DIR/bin/codex-helm" \
-             "$LAUNCH_DIR/profiles.toml" "$LAUNCH_DIR/shell.zsh" "$BIN_DIR/agent-launch"; do
-      [ -f "$p" ] && { run rm -f "$p"; [ "$DRY_RUN" = 1 ] || info "removed  $p"; }
-    done
-  fi
-  local d
-  for d in "$CLAUDE_DIR/guides" "$CLAUDE_DIR/agents" "$CODEX_DIR/guides" "$CODEX_DIR/agents" "$CODEX_DIR/bin" "$LAUNCH_DIR"; do
-    [ -d "$d" ] && rmdir "$d" 2>/dev/null && info "removed empty  $d" || true
-  done
-  remove_zsh_hook
-  log ""
-  log "Uninstalled deployed files and the zsh hook."
-  log "Kept: managed venv + backups under $STATE_DIR (rm -rf \"$STATE_DIR\" to purge)."
-}
-
-cmd_onboard() {
-  log "agent-bios onboarding — pick your domain packages (core + infra always install)"
-  local names=() line i=1 choice sel="" n picks
-  while IFS= read -r line; do names+=("$line"); done \
-    < <(python3 -c "import json;print('\n'.join(sorted(json.load(open('$REPO/config/domains.json'))['domains'])))")
-  [ "${#names[@]}" -ge 1 ] || { log "no domains found in config/domains.json"; exit 1; }
-  if [ "$DOMAINS_SET" = 1 ]; then
-    # Non-interactive path, per this installer's input contract (stdin is
-    # detached at the top of the script): selection arrives as domain names.
-    [ "$DOMAINS_ARG" = none ] && DOMAINS_ARG=""
-    sel="$DOMAINS_ARG"
-  elif ( : </dev/tty ) 2>/dev/null; then
-    for line in "${names[@]}"; do info "$i) $line"; i=$((i+1)); done
-    printf 'Select by number, comma-separated (empty = core+infra only): '
-    read -r choice </dev/tty || choice=""
-    if [ -n "$choice" ]; then
-      # bash 3.2 + set -u: expanding an EMPTY array errors, so split only
-      # when there is input; empty input means core+infra only.
-      IFS=',' read -ra picks <<<"$choice"
-      for n in "${picks[@]}"; do
-        n="${n// /}"; [ -n "$n" ] || continue
-        case "$n" in (*[!0-9]*) log "invalid selection: $n"; exit 2 ;; esac
-        [ "$n" -ge 1 ] && [ "$n" -le "${#names[@]}" ] || { log "selection out of range: $n"; exit 2; }
-        sel="$sel${sel:+,}${names[$((n-1))]}"
-      done
-    fi
-  else
-    log "onboard needs a terminal or an explicit selection — run:"
-    log "  agent-bios onboard --domains a,b   (or --domains none for core+infra only)"
-    exit 2
-  fi
-  DOMAINS_ARG="$sel"; DOMAINS_SET=1
-  log "selection: ${sel:-<core+infra only>}"
-  cmd_install
-  log ""
-  log "Activation canary (proves the bundle loads in a live session)..."
-  if [ "$DRY_RUN" = 1 ]; then info "[dry-run] skip canary probe"; return; fi
-  bash "$REPO/scripts/canary.sh" || {
-    log "ONBOARDING INCOMPLETE: the bundle is installed but not loading — fix the cause above and re-run: agent-bios verify"
-    exit 1
-  }
-}
-
-# ---- deploy-chain drift ---------------------------------------------------
-# A repo edit is inert until it is published AND globally installed AND
-# deployed. The middle two are checkable: the installer stamps the package
-# version it deployed into the state dir, so a stamp older than the package now
-# running means someone updated the package and never re-deployed. Reading the
-# registry cannot see this, which is why it went unnoticed three times.
-json_field() {  # $1=file $2=key
-  [ -f "$1" ] || return 1
-  python3 -c 'import json,sys
-try:
-    v=json.load(open(sys.argv[1])).get(sys.argv[2])
-except Exception:
-    sys.exit(1)
-sys.exit(0) if v is None else print(v)' "$1" "$2" 2>/dev/null
-}
-
-deployed_version() { json_field "$STATE_DIR/version.json" version; }
-source_version()   { json_field "$REPO/package.json" version; }
-
-drift_state() {  # prints: match | drift | unknown
-  local d s
-  d="$(deployed_version)" || { echo unknown; return; }
-  s="$(source_version)"   || { echo unknown; return; }
-  [ -n "$d" ] && [ -n "$s" ] || { echo unknown; return; }
-  [ "$d" = "$s" ] && echo match || echo drift
-}
-
-cmd_status() {
-  local version p
-  if [ -d "$REPO/.git" ]; then
-    version="$(git -C "$REPO" describe --tags --always --dirty 2>/dev/null || git -C "$REPO" rev-parse --short HEAD 2>/dev/null || echo '?')"
-    log "agent-bios  (git clone: $version)"
-  elif [ -f "$REPO/package.json" ]; then
-    version="$(node -e "try{process.stdout.write(require('$REPO/package.json').version)}catch(e){process.stdout.write('?')}" 2>/dev/null || echo '?')"
-    log "agent-bios  (npm package: $version)"
-  else
-    log "agent-bios"
-  fi
-  log "  source:  $REPO"
-  case "$(drift_state)" in
-    match)   info "deployed version $(deployed_version) (matches this package)" ;;
-    drift)   log  "DRIFT    deployed $(deployed_version) but this package is $(source_version) — run: agent-bios install" ;;
-    unknown) info "deployed version unknown (no state marker yet)" ;;
-  esac
-  for p in "$CLAUDE_DIR/CLAUDE.md" "$CODEX_DIR/AGENTS.md" "$BIN_DIR/agent-launch" \
-           "$LAUNCH_DIR/profiles.toml" "$LAUNCH_DIR/shell.zsh"; do
-    if [ -e "$p" ]; then info "present  $p"; else info "MISSING  $p"; fi
-  done
-  if [ -f "$ZSHRC" ] && grep -qF "$HOOK_MARK" "$ZSHRC"; then info "zsh hook present"; else info "zsh hook absent"; fi
-}
-
-cmd_update() {
-  if [ -d "$REPO/.git" ]; then
-    log "Updating from git..."
-    run git -C "$REPO" pull --ff-only
-    cmd_install
-  else
-    log "Installed as an npm package. Update with:"
-    log "  npm install -g agent-bios@latest && agent-bios install"
-    log "Then confirm what actually landed — right after a publish the cached"
-    log "packument can serve the PREVIOUS version at exit 0:"
-    log "  agent-bios status   # must show the version you expected, and no DRIFT"
-  fi
-}
-
-usage() {
-  cat <<'EOF'
-agent-bios — deploy the Claude/Codex instruction SSOT into $HOME (by copy).
-
-  agent-bios install     deploy into this environment (backs up + verifies)
-  agent-bios onboard     interactive domain selection + packaged install + activation canary
-  agent-bios verify      check the deployed state matches the source
-  agent-bios learn       submit a session learning (reads the JSON record on
-                         stdin; this is what the learn! flow calls, and it
-                         works from any directory, unlike a repo-relative path)
-  agent-bios status      show what is installed and where
-  agent-bios update      git pull + reinstall (clone), or print the npm update line
-  agent-bios uninstall   remove deployed files and the zsh hook
-  agent-bios help
-
-Flags: --dry-run       print actions without changing anything
-       --domains a,b  packaged mode (install/onboard): assemble ONLY the named
-                      domain packages (plus core+infra) instead of the full
-                      corpus; with onboard, 'none' means core+infra only. The
-                      selection persists in the state dir, so later
-                      installs/updates stay packaged until the selection file
-                      is removed. Default (no flag, no saved selection) keeps
-                      today's full-corpus deploy.
-       --with a,b     also install the named optional dependencies (install only).
-                      Without it, install offers each missing one when the terminal
-                      is interactive, and otherwise just prints its install line.
-                      Known: onto, ultracode. Missing ones are not fatal — they only
-                      degrade the review routes that need them.
-Env:   CLAUDE_CONFIG_DIR, CODEX_HOME, AGENT_LAUNCH_VENV, ZDOTDIR
-EOF
-}
-
-# ---- dispatch ------------------------------------------------------------
-CMD="${1:-help}"
-if [ $# -gt 0 ]; then shift; fi
-
-# `learn` forwards its arguments and stdin straight to the collector, so it must
-# bypass the flag parser below (which rejects anything it does not know). This
-# subcommand is the only PATH-reachable entry to capture: the corpus guide used
-# to invoke scripts/collect-learning.py relative to the cwd, which works from a
-# clone and silently fails for every other install.
-if [ "$CMD" = "learn" ]; then
-  collector="$REPO/scripts/collect-learning.py"
-  [ -f "$collector" ] || { log "learn: collector missing at $collector"; exit 1; }
-  exec python3 "$collector" "$@" <&3
-fi
-
-WITH=""
-DOMAINS_ARG=""
-DOMAINS_SET=0
-while [ $# -gt 0 ]; do
-  case "$1" in
-    --dry-run) DRY_RUN=1 ;;
-    --with) shift; WITH="${1:-}"; [ -n "$WITH" ] || { log "--with needs a comma-separated capability list"; exit 2; } ;;
-    --with=*) WITH="${1#--with=}"; [ -n "$WITH" ] || { log "--with needs a comma-separated capability list"; exit 2; } ;;
-    --domains) shift; DOMAINS_ARG="${1:-}"; DOMAINS_SET=1; [ -n "$DOMAINS_ARG" ] || { log "--domains needs a comma-separated domain list (use onboard for core-only)"; exit 2; } ;;
-    --domains=*) DOMAINS_ARG="${1#--domains=}"; DOMAINS_SET=1; [ -n "$DOMAINS_ARG" ] || { log "--domains needs a comma-separated domain list (use onboard for core-only)"; exit 2; } ;;
-    *) log "unknown flag: $1"; exit 2 ;;
-  esac
-  shift
-done
-
-case "$CMD" in
-  install)   cmd_install ;;
-  onboard)   cmd_onboard ;;
-  update)    cmd_update ;;
-  uninstall) cmd_uninstall ;;
-  verify)    if cmd_verify; then log "VERIFY OK"; else log "VERIFY FAILED"; exit 1; fi ;;
-  status)    cmd_status ;;
-  help|-h|--help) usage ;;
-  *) log "unknown command: $CMD"; usage; exit 2 ;;
-esac