agent-bios 0.1.0

package/scripts/install.sh

@@ -0,0 +1,310 @@
+#!/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.
+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"
+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
+}
+
+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"
+}
+
+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"
+}
+
+# ---- 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"
+  deploy_file "$REPO/claude/CLAUDE.md" "$CLAUDE_DIR/CLAUDE.md"
+  deploy_glob "$REPO/claude/guides" "*.md" "$CLAUDE_DIR/guides"
+  deploy_file "$REPO/codex/AGENTS.md" "$CODEX_DIR/AGENTS.md"
+  deploy_glob "$REPO/codex/guides" "*.md" "$CODEX_DIR/guides"
+  deploy_glob "$REPO/codex/agents" "*.toml" "$CODEX_DIR/agents"
+  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"
+  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"
+  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
+  log ""
+  log "Verifying deployment..."
+  if cmd_verify; then
+    log ""
+    log "Done. Open a new shell (or: source \"$ZSHRC\") to activate the zero-arg launcher."
+    [ -n "$BACKUP_DIR" ] && [ -d "$BACKUP_DIR" ] && log "Replaced files were backed up under $BACKUP_DIR"
+  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
+  verify_match "$REPO/claude/CLAUDE.md"        "$CLAUDE_DIR/CLAUDE.md"        || fail=1
+  verify_match "$REPO/codex/AGENTS.md"         "$CODEX_DIR/AGENTS.md"         || fail=1
+  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
+  for gp in "$REPO"/claude/guides/*.md; do verify_present "$CLAUDE_DIR/guides/$(basename "$gp")" || fail=1; done
+  for gp in "$REPO"/codex/guides/*.md;  do verify_present "$CODEX_DIR/guides/$(basename "$gp")"  || fail=1; done
+  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
+  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
+  # 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
+  return $fail
+}
+
+cmd_uninstall() {
+  migrate_state
+  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" "$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_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"
+  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"
+  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 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 without changing anything
+Env:   CLAUDE_CONFIG_DIR, CODEX_HOME, AGENT_LAUNCH_VENV, ZDOTDIR
+EOF
+}
+
+# ---- dispatch ------------------------------------------------------------
+CMD="${1:-help}"
+if [ $# -gt 0 ]; then shift; fi
+for a in "$@"; do
+  case "$a" in
+    --dry-run) DRY_RUN=1 ;;
+    *) log "unknown flag: $a"; exit 2 ;;
+  esac
+done
+
+case "$CMD" in
+  install)   cmd_install ;;
+  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

package/scripts/provision-venv.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Provision the managed virtualenv that backs the agent-launch Textual preflight.
+#
+# The interactive launcher re-execs into this venv (scripts/agent-launch.py ->
+# maybe_reexec_into_venv). It is an enhancement, not a hard dependency: when the
+# venv is missing or broken, the launcher falls back to numbered prompts, and
+# every direct / non-TTY / --no-tui path keeps running under the system
+# interpreter untouched. Re-run this after upgrading Python or the pin below.
+#
+#   AGENT_LAUNCH_VENV   override the venv location (default below)
+#   AGENT_LAUNCH_PYTHON python used to create the venv (default: python3)
+set -eu
+
+TEXTUAL_PIN="textual==8.2.8"
+VENV="${AGENT_LAUNCH_VENV:-$HOME/.local/share/agent-launch/venv}"
+PYTHON="${AGENT_LAUNCH_PYTHON:-python3}"
+
+if [ -x "$VENV/bin/python" ] && "$VENV/bin/python" -c 'import textual' 2>/dev/null; then
+  printf 'agent-launch venv already provisioned: %s\n' "$VENV"
+  "$VENV/bin/python" -c 'import textual, sys; print("  textual", textual.__version__, "| python", sys.version.split()[0])'
+  exit 0
+fi
+
+printf 'Provisioning agent-launch venv at %s ...\n' "$VENV"
+"$PYTHON" -m venv "$VENV"
+"$VENV/bin/python" -m pip install --quiet --upgrade pip
+"$VENV/bin/python" -m pip install --quiet "$TEXTUAL_PIN"
+"$VENV/bin/python" -c 'import textual, sys; print("Ready: textual", textual.__version__, "| python", sys.version.split()[0])'

package/scripts/session-cost.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""Aggregate token usage & cost for a Claude Code session (main + subagents).
+
+Usage: session-cost.py <session>.jsonl [...]
+Reads the session transcript and, if present, <session-dir>/subagents/agent-*.jsonl.
+Prints per-source, per-model token sums, modeled cost, and wall-clock span.
+"""
+import json, sys, glob, os
+from datetime import datetime
+
+# $/MTok: input, output, cache_read, cache_write_5m, cache_write_1h
+PRICES = {
+    "claude-fable-5":  (10.0, 50.0, 1.00, 12.50, 20.0),
+    "claude-mythos-5": (10.0, 50.0, 1.00, 12.50, 20.0),
+    "claude-opus-4-8": (5.0, 25.0, 0.50, 6.25, 10.0),
+    "claude-opus-4-7": (5.0, 25.0, 0.50, 6.25, 10.0),
+    "claude-opus-4-6": (5.0, 25.0, 0.50, 6.25, 10.0),
+    "claude-sonnet-5": (3.0, 15.0, 0.30, 3.75, 6.0),
+    "claude-sonnet-4-6": (3.0, 15.0, 0.30, 3.75, 6.0),
+    "claude-haiku-4-5": (1.0, 5.0, 0.10, 1.25, 2.0),
+}
+
+def price_for(model):
+    for k, v in PRICES.items():
+        if model.startswith(k):
+            return v
+    return None
+
+def scan(path):
+    """-> {model: {in,out,cr,cw5,cw1,turns}}, (t_min, t_max)"""
+    agg, tmin, tmax, seen = {}, None, None, set()
+    for line in open(path):
+        try:
+            d = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        ts = d.get("timestamp")
+        if ts:
+            tmin = min(tmin or ts, ts); tmax = max(tmax or ts, ts)
+        m = d.get("message") or {}
+        u, model = m.get("usage"), m.get("model")
+        if not u or not model or model == "<synthetic>":
+            continue
+        rid = m.get("id") or d.get("requestId")
+        if rid in seen:
+            continue  # one usage record per API request
+        seen.add(rid)
+        a = agg.setdefault(model, dict(inp=0, out=0, cr=0, cw5=0, cw1=0, turns=0))
+        a["inp"] += u.get("input_tokens", 0)
+        a["out"] += u.get("output_tokens", 0)
+        a["cr"]  += u.get("cache_read_input_tokens", 0)
+        cc = u.get("cache_creation") or {}
+        if cc:
+            a["cw5"] += cc.get("ephemeral_5m_input_tokens", 0)
+            a["cw1"] += cc.get("ephemeral_1h_input_tokens", 0)
+        else:
+            a["cw5"] += u.get("cache_creation_input_tokens", 0)
+        a["turns"] += 1
+    return agg, (tmin, tmax)
+
+def cost(model, a):
+    p = price_for(model)
+    if not p:
+        return None
+    i, o, cr, cw5, cw1 = p
+    return (a["inp"]*i + a["out"]*o + a["cr"]*cr + a["cw5"]*cw5 + a["cw1"]*cw1) / 1e6
+
+def fmt(n):
+    return f"{n/1000:,.0f}k" if n >= 1000 else str(n)
+
+def report(session_path):
+    base = session_path[:-6]  # strip .jsonl
+    sources = [("main", session_path)]
+    sources += [(os.path.basename(f)[:-6], f)
+                for f in sorted(glob.glob(os.path.join(base, "subagents", "*.jsonl")))]
+    print(f"\n=== {os.path.basename(session_path)} ===")
+    grand, unpriced = 0.0, []
+    hdr = f"{'source':<38}{'model':<22}{'turns':>6}{'input':>9}{'output':>9}{'cache_rd':>10}{'cache_wr':>10}{'cost$':>9}"
+    print(hdr); print("-" * len(hdr))
+    span_min = span_max = None
+    for name, path in sources:
+        agg, (tmin, tmax) = scan(path)
+        if tmin:
+            span_min = min(span_min or tmin, tmin); span_max = max(span_max or tmax, tmax)
+        for model, a in agg.items():
+            c = cost(model, a)
+            cs = f"{c:9.2f}" if c is not None else "        ?"
+            if c is None:
+                unpriced.append(model)
+            else:
+                grand += c
+            print(f"{name:<38}{model:<22}{a['turns']:>6}{fmt(a['inp']):>9}{fmt(a['out']):>9}"
+                  f"{fmt(a['cr']):>10}{fmt(a['cw5']+a['cw1']):>10}{cs}")
+    if span_min:
+        t0 = datetime.fromisoformat(span_min.replace("Z", "+00:00"))
+        t1 = datetime.fromisoformat(span_max.replace("Z", "+00:00"))
+        mins = (t1 - t0).total_seconds() / 60
+        print(f"\nwall clock: {mins:,.1f} min   |   modeled total cost: ${grand:,.2f}")
+    if unpriced:
+        print(f"WARN unpriced models: {set(unpriced)}")
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        sys.exit(__doc__)
+    for p in sys.argv[1:]:
+        report(p)

package/shell/agent-launch.zsh

@@ -0,0 +1,38 @@
+# Interactive zero-argument entrypoints use agent-launch. Every argument-bearing
+# or non-TTY call skips profile projection; Claude retains its direct-path
+# permission-bypass default.
+_agent_launch_direct() {
+  local host="$1"
+  shift
+  if [[ "$host" == "claude" ]]; then
+    command claude --dangerously-skip-permissions "$@"
+  else
+    command codex "$@"
+  fi
+}
+
+_agent_launch_dispatch() {
+  local host="$1"
+  shift
+  local launcher="${AGENT_LAUNCH_BIN:-$HOME/.local/bin/agent-launch}"
+
+  if [[ $# -gt 0 && "$1" == "--no-tui" ]]; then
+    shift
+    _agent_launch_direct "$host" "$@"
+  elif [[ $# -eq 0 && -t 0 && -t 1 && "${AGENT_LAUNCH_TUI:-1}" != "0" ]]; then
+    "$launcher" "$host"
+  else
+    _agent_launch_direct "$host" "$@"
+  fi
+}
+
+unalias codex 2>/dev/null
+unalias claude 2>/dev/null
+
+codex() {
+  _agent_launch_dispatch codex "$@"
+}
+
+claude() {
+  _agent_launch_dispatch claude "$@"
+}