Swain Init

#!/usr/bin/env bash
# swain-init-preflight.sh — read-only environment scanner for swain-init
#
# Runs all pre-onboarding checks and emits a single JSON object to stdout.
# This script NEVER mutates state (no file writes, installs, or symlinks).
# The skill file reads this JSON and makes decisions based on the results.
#
# Usage: bash swain-init-preflight.sh [--repo-root /path/to/repo]
#
# JSON schema (all keys present, some may be null on error):
#
#   marker.exists          bool    — .swain/init.json file found
#   marker.last_version    string  — version from last history entry (null if no marker)
#   marker.current_version string  — version from installed swain-init SKILL.md
#   marker.action          string  — "delegate" | "upgrade" | "onboard"
#
#   migration.state        string  — "fresh" | "migrated" | "standard" | "split"
#   migration.claude_md    string  — "missing" | "empty" | "include_only" | "has_content"
#   migration.agents_md    string  — "missing" | "empty" | "has_content"
#
#   uv.available           bool    — uv binary found in PATH
#   uv.path                string  — path to uv (null if not found)
#
#   tk.path                string  — path to vendored tk (null if not found)
#   tk.healthy             bool    — tk help runs successfully
#
#   beads.exists           bool    — .beads/ directory found
#   beads.has_backup       bool    — .beads/backup/issues.jsonl exists
#
#   bin_manifests          array   — list of {skill, commands[]} for usr/bin/ dirs
#
#   precommit.config_exists bool   — .pre-commit-config.yaml found
#   precommit.framework     bool   — pre-commit binary found in PATH
#
#   superpowers.installed  bool    — brainstorming SKILL.md found
#
#   tmux.installed         bool    — tmux binary found
#
#   launcher.shell         string  — detected shell name (zsh/bash/fish/unknown)
#   launcher.rc_file       string  — path to rc file
#   launcher.already_installed bool — swain function already in rc file
#   launcher.runtimes      array   — list of detected agentic runtimes
#   launcher.template_dir  string  — path to launcher templates (null if not found)
#
#   governance.installed   bool    — swain governance block found in AGENTS.md or CLAUDE.md
#
#   readme.exists          bool    — README.md found
#   readme.has_code        bool    — source code files found in repo
#   readme.has_artifacts   bool    — Active artifacts found in docs/
#   readme.active_count    int     — count of Active VISION/DESIGN/JOURNEY/PERSONA artifacts
#
#   agents_dir.exists      bool    — .agents/ directory exists
#
# Exit: always 0 (partial results on individual check failures)

set -euo pipefail

REPO_ROOT=""

while [ $# -gt 0 ]; do
  case "$1" in
    --repo-root) REPO_ROOT="$2"; shift 2 ;;
    *) shift ;;
  esac
done

if [ -z "$REPO_ROOT" ]; then
  REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
fi

cd "$REPO_ROOT"

# --- Collector variables ---
# Each check function sets variables prefixed with its category.
# We collect everything at the end via python3 JSON serialization.

# --- Marker check ---
check_marker() {
  MARKER_EXISTS=false
  MARKER_LAST_VERSION=""
  MARKER_CURRENT_VERSION=""
  MARKER_ACTION="onboard"

  if [ -f ".swain/init.json" ]; then
    MARKER_EXISTS=true
    # Extract last version — try jq first, fall back to python3, then grep
    MARKER_LAST_VERSION=$(python3 -c "
import json, sys
try:
    d = json.load(open('.swain/init.json'))
    print(d['history'][-1]['version'])
except Exception:
    sys.exit(1)
" 2>/dev/null || echo "")
  fi

  # Find current installed version
  SKILL_FILE=$(find . .claude .agents -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null || true)
  if [ -n "$SKILL_FILE" ] && [ -f "$SKILL_FILE" ]; then
    MARKER_CURRENT_VERSION=$(head -20 "$SKILL_FILE" 2>/dev/null | grep 'version:' | awk '{print $2}' || true)
  fi

  # Determine action
  if [ "$MARKER_EXISTS" = true ] && [ -n "$MARKER_LAST_VERSION" ] && [ -n "$MARKER_CURRENT_VERSION" ]; then
    LAST_MAJOR="${MARKER_LAST_VERSION%%.*}"
    CURRENT_MAJOR="${MARKER_CURRENT_VERSION%%.*}"
    if [ "$LAST_MAJOR" = "$CURRENT_MAJOR" ]; then
      MARKER_ACTION="delegate"
    else
      MARKER_ACTION="upgrade"
    fi
  fi
}

# --- Migration state check ---
check_migration() {
  MIGRATION_STATE="fresh"
  MIGRATION_CLAUDE_MD="missing"
  MIGRATION_AGENTS_MD="missing"

  # Classify CLAUDE.md
  if [ -f "CLAUDE.md" ]; then
    if [ ! -s "CLAUDE.md" ]; then
      MIGRATION_CLAUDE_MD="empty"
    else
      CONTENT=$(cat "CLAUDE.md" 2>/dev/null)
      TRIMMED=$(echo "$CONTENT" | sed '/^[[:space:]]*$/d')
      if [ "$TRIMMED" = "@AGENTS.md" ]; then
        MIGRATION_CLAUDE_MD="include_only"
      else
        MIGRATION_CLAUDE_MD="has_content"
      fi
    fi
  fi

  # Classify AGENTS.md
  if [ -f "AGENTS.md" ]; then
    if [ ! -s "AGENTS.md" ]; then
      MIGRATION_AGENTS_MD="empty"
    else
      MIGRATION_AGENTS_MD="has_content"
    fi
  fi

  # Determine migration state
  if [ "$MIGRATION_CLAUDE_MD" = "include_only" ]; then
    MIGRATION_STATE="migrated"
  elif [ "$MIGRATION_CLAUDE_MD" = "missing" ] || [ "$MIGRATION_CLAUDE_MD" = "empty" ]; then
    if [ "$MIGRATION_AGENTS_MD" = "missing" ] || [ "$MIGRATION_AGENTS_MD" = "empty" ]; then
      MIGRATION_STATE="fresh"
    else
      MIGRATION_STATE="fresh"
    fi
  elif [ "$MIGRATION_CLAUDE_MD" = "has_content" ]; then
    if [ "$MIGRATION_AGENTS_MD" = "has_content" ]; then
      MIGRATION_STATE="split"
    else
      MIGRATION_STATE="standard"
    fi
  fi
}

# --- uv check ---
check_uv() {
  UV_AVAILABLE=false
  UV_PATH=""

  UV_PATH=$(command -v uv 2>/dev/null || true)
  if [ -n "$UV_PATH" ]; then
    UV_AVAILABLE=true
  fi
}

# --- tk check ---
check_tk() {
  TK_PATH=""
  TK_HEALTHY=false

  TK_PATH=$(find . .claude .agents -path '*/swain-do/bin/tk' -print -quit 2>/dev/null || true)
  if [ -n "$TK_PATH" ] && [ -x "$TK_PATH" ]; then
    if "$TK_PATH" help >/dev/null 2>&1; then
      TK_HEALTHY=true
    fi
  fi
}

# --- beads check ---
check_beads() {
  BEADS_EXISTS=false
  BEADS_HAS_BACKUP=false

  if [ -d ".beads" ]; then
    BEADS_EXISTS=true
    if [ -f ".beads/backup/issues.jsonl" ]; then
      BEADS_HAS_BACKUP=true
    fi
  fi
}

# --- bin manifests check ---
check_bin_manifests() {
  # Collect as newline-delimited "skill|command" pairs; python3 will parse
  BIN_MANIFESTS_RAW=""
  SKILLS_ROOT=".agents/skills"
  if [ -d "$SKILLS_ROOT" ]; then
    for manifest_dir in "$SKILLS_ROOT"/*/usr/bin; do
      [ -d "$manifest_dir" ] || continue
      skill_name=$(basename "$(dirname "$(dirname "$manifest_dir")")")
      for entry in "$manifest_dir"/*; do
        [ -e "$entry" ] || [ -L "$entry" ] || continue
        cmd_name=$(basename "$entry")
        BIN_MANIFESTS_RAW="${BIN_MANIFESTS_RAW}${skill_name}|${cmd_name}
"
      done
    done
  fi
}

# --- pre-commit check ---
check_precommit() {
  PRECOMMIT_CONFIG_EXISTS=false
  PRECOMMIT_FRAMEWORK=false

  if [ -f ".pre-commit-config.yaml" ]; then
    PRECOMMIT_CONFIG_EXISTS=true
  fi

  if command -v pre-commit >/dev/null 2>&1; then
    PRECOMMIT_FRAMEWORK=true
  fi
}

# --- superpowers check ---
check_superpowers() {
  SUPERPOWERS_INSTALLED=false

  if ls .agents/skills/brainstorming/SKILL.md .claude/skills/brainstorming/SKILL.md 2>/dev/null | head -1 | grep -q .; then
    SUPERPOWERS_INSTALLED=true
  fi
}

# --- tmux check ---
check_tmux() {
  TMUX_INSTALLED=false

  if command -v tmux >/dev/null 2>&1; then
    TMUX_INSTALLED=true
  fi
}

# --- shell launcher check ---
check_launcher() {
  LAUNCHER_SHELL="unknown"
  LAUNCHER_RC_FILE=""
  LAUNCHER_ALREADY_INSTALLED=false
  LAUNCHER_RUNTIMES_RAW=""
  LAUNCHER_TEMPLATE_DIR=""

  # Detect shell
  LAUNCHER_SHELL=$(basename "${SHELL:-unknown}")

  # Map to rc file
  case "$LAUNCHER_SHELL" in
    zsh)  LAUNCHER_RC_FILE="$HOME/.zshrc" ;;
    bash) LAUNCHER_RC_FILE="$HOME/.bashrc" ;;
    fish) LAUNCHER_RC_FILE="$HOME/.config/fish/config.fish" ;;
    *)    LAUNCHER_RC_FILE="" ;;
  esac

  # Check for existing launcher
  if [ -n "$LAUNCHER_RC_FILE" ] && [ -f "$LAUNCHER_RC_FILE" ]; then
    case "$LAUNCHER_SHELL" in
      zsh|bash)
        if grep -q 'swain\s*()' "$LAUNCHER_RC_FILE" 2>/dev/null; then
          LAUNCHER_ALREADY_INSTALLED=true
        fi
        ;;
      fish)
        if grep -q 'function swain' "$LAUNCHER_RC_FILE" 2>/dev/null; then
          LAUNCHER_ALREADY_INSTALLED=true
        fi
        ;;
    esac
  fi

  # Detect runtimes
  for rt in claude gemini codex copilot crush; do
    if command -v "$rt" >/dev/null 2>&1; then
      LAUNCHER_RUNTIMES_RAW="${LAUNCHER_RUNTIMES_RAW}${rt}
"
    fi
  done

  # Find template directory
  LAUNCHER_TEMPLATE_DIR=$(find . .claude .agents -path '*/swain-init/templates/launchers' -type d -print -quit 2>/dev/null || true)
}

# --- governance check ---
check_governance() {
  GOVERNANCE_INSTALLED=false

  if grep -q "swain governance" AGENTS.md CLAUDE.md 2>/dev/null; then
    GOVERNANCE_INSTALLED=true
  fi
}

# --- readme and artifacts check ---
check_readme() {
  README_EXISTS=false
  README_HAS_CODE=false
  README_HAS_ARTIFACTS=false
  README_ACTIVE_COUNT=0

  if [ -f "README.md" ]; then
    README_EXISTS=true
  fi

  # Check for source code
  if find . -maxdepth 3 \( -name '*.py' -o -name '*.js' -o -name '*.ts' -o -name '*.go' -o -name '*.rs' -o -name '*.sh' \) \
     -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/.agents/*' -not -path '*/.claude/*' \
     -print -quit 2>/dev/null | grep -q .; then
    README_HAS_CODE=true
  fi

  # Check for Active artifacts
  if find docs -name '*.md' -path '*/Active/*' -print -quit 2>/dev/null | grep -q .; then
    README_HAS_ARTIFACTS=true
  fi

  # Count Active VISION/DESIGN/JOURNEY/PERSONA artifacts
  README_ACTIVE_COUNT=$(find docs -path "*/Active/*" -name "*.md" 2>/dev/null | grep -cE "(VISION|DESIGN|JOURNEY|PERSONA)") || README_ACTIVE_COUNT=0
}

# --- .agents/ dir check ---
check_agents_dir() {
  AGENTS_DIR_EXISTS=false

  if [ -d ".agents" ]; then
    AGENTS_DIR_EXISTS=true
  fi
}

# --- Run all checks ---
# Each check is wrapped in a subshell-safe pattern; failures don't abort the script.
check_marker || true
check_migration || true
check_uv || true
check_tk || true
check_beads || true
check_bin_manifests || true
check_precommit || true
check_superpowers || true
check_tmux || true
check_launcher || true
check_governance || true
check_readme || true
check_agents_dir || true

# --- Emit JSON via python3 ---
python3 -c "
import json, sys

def to_bool(v):
    return v.lower() == 'true'

def to_int(v):
    try: return int(v)
    except: return 0

def to_str_or_null(v):
    return v if v else None

def to_list(raw):
    return [x for x in raw.strip().split('\n') if x] if raw.strip() else []

def parse_bin_manifests(raw):
    result = {}
    for line in raw.strip().split('\n'):
        if not line or '|' not in line:
            continue
        skill, cmd = line.split('|', 1)
        result.setdefault(skill, []).append(cmd)
    return [{'skill': k, 'commands': v} for k, v in result.items()]

data = {
    'marker': {
        'exists': to_bool(sys.argv[1]),
        'last_version': to_str_or_null(sys.argv[2]),
        'current_version': to_str_or_null(sys.argv[3]),
        'action': sys.argv[4],
    },
    'migration': {
        'state': sys.argv[5],
        'claude_md': sys.argv[6],
        'agents_md': sys.argv[7],
    },
    'uv': {
        'available': to_bool(sys.argv[8]),
        'path': to_str_or_null(sys.argv[9]),
    },
    'tk': {
        'path': to_str_or_null(sys.argv[10]),
        'healthy': to_bool(sys.argv[11]),
    },
    'beads': {
        'exists': to_bool(sys.argv[12]),
        'has_backup': to_bool(sys.argv[13]),
    },
    'bin_manifests': parse_bin_manifests(sys.argv[14]),
    'precommit': {
        'config_exists': to_bool(sys.argv[15]),
        'framework': to_bool(sys.argv[16]),
    },
    'superpowers': {
        'installed': to_bool(sys.argv[17]),
    },
    'tmux': {
        'installed': to_bool(sys.argv[18]),
    },
    'launcher': {
        'shell': sys.argv[19],
        'rc_file': to_str_or_null(sys.argv[20]),
        'already_installed': to_bool(sys.argv[21]),
        'runtimes': to_list(sys.argv[22]),
        'template_dir': to_str_or_null(sys.argv[23]),
    },
    'governance': {
        'installed': to_bool(sys.argv[24]),
    },
    'readme': {
        'exists': to_bool(sys.argv[25]),
        'has_code': to_bool(sys.argv[26]),
        'has_artifacts': to_bool(sys.argv[27]),
        'active_count': to_int(sys.argv[28]),
    },
    'agents_dir': {
        'exists': to_bool(sys.argv[29]),
    },
}

json.dump(data, sys.stdout, indent=2)
print()
" \
  "$MARKER_EXISTS" "$MARKER_LAST_VERSION" "$MARKER_CURRENT_VERSION" "$MARKER_ACTION" \
  "$MIGRATION_STATE" "$MIGRATION_CLAUDE_MD" "$MIGRATION_AGENTS_MD" \
  "$UV_AVAILABLE" "$UV_PATH" \
  "$TK_PATH" "$TK_HEALTHY" \
  "$BEADS_EXISTS" "$BEADS_HAS_BACKUP" \
  "$BIN_MANIFESTS_RAW" \
  "$PRECOMMIT_CONFIG_EXISTS" "$PRECOMMIT_FRAMEWORK" \
  "$SUPERPOWERS_INSTALLED" \
  "$TMUX_INSTALLED" \
  "$LAUNCHER_SHELL" "$LAUNCHER_RC_FILE" "$LAUNCHER_ALREADY_INSTALLED" "$LAUNCHER_RUNTIMES_RAW" "$LAUNCHER_TEMPLATE_DIR" \
  "$GOVERNANCE_INSTALLED" \
  "$README_EXISTS" "$README_HAS_CODE" "$README_HAS_ARTIFACTS" "$README_ACTIVE_COUNT" \
  "$AGENTS_DIR_EXISTS"

#!/usr/bin/env bash
# test-launcher-marker-check.sh — SPEC-196: Test the .swain/init.json marker check
#
# Tests the _swain_check_marker() function that shell launchers use to
# decide whether to send /swain-init or /swain-session as the initial prompt.
#
# Usage: bash test-launcher-marker-check.sh [--verbose]

set -euo pipefail

VERBOSE=0
[[ "${1:-}" == "--verbose" ]] && VERBOSE=1

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
TEMPLATE_DIR="$SCRIPT_DIR/../templates/launchers/claude"

PASS=0
FAIL=0
TOTAL=0

assert_eq() {
  local test_name="$1" expected="$2" actual="$3"
  TOTAL=$((TOTAL + 1))
  if [[ "$expected" == "$actual" ]]; then
    PASS=$((PASS + 1))
    [[ $VERBOSE -eq 1 ]] && echo "  PASS: $test_name"
  else
    FAIL=$((FAIL + 1))
    echo "  FAIL: $test_name (expected: '$expected', got: '$actual')"
  fi
}

# ─── Setup temp directory ───
TMPDIR_TEST=$(mktemp -d)
trap "rm -rf '$TMPDIR_TEST'" EXIT

# Create a minimal skill file for version detection
mkdir -p "$TMPDIR_TEST/skills/swain-init"
cat > "$TMPDIR_TEST/skills/swain-init/SKILL.md" << 'SKILL'
---
name: swain-init
version: 4.1.0
---
SKILL

# Source the bash launcher to get _swain_check_marker
source "$TEMPLATE_DIR/swain.bash"

echo "=== SPEC-196: Launcher marker check tests ==="

# ─── Test 1: No marker → /swain-init ───
echo "Test 1: No .swain/init.json marker"
cd "$TMPDIR_TEST"
rm -rf .swain
result=$(_swain_check_marker 2>/dev/null)
assert_eq "no marker returns /swain-init" "/swain-init" "$result"

# ─── Test 2: Current marker (same major) → /swain-session ───
echo "Test 2: Current .swain/init.json marker (same major version)"
mkdir -p "$TMPDIR_TEST/.swain"
cat > "$TMPDIR_TEST/.swain/init.json" << 'JSON'
{
  "history": [
    {
      "version": "4.1.0",
      "timestamp": "2026-03-26T18:30:00Z",
      "action": "init"
    }
  ]
}
JSON
result=$(_swain_check_marker 2>/dev/null)
assert_eq "current marker returns /swain-session" "/swain-session" "$result"

# ─── Test 3: Same major, different minor → /swain-session ───
echo "Test 3: Same major, different minor version"
mkdir -p "$TMPDIR_TEST/.swain"
cat > "$TMPDIR_TEST/.swain/init.json" << 'JSON'
{
  "history": [
    {
      "version": "4.0.0",
      "timestamp": "2026-03-20T10:00:00Z",
      "action": "init"
    }
  ]
}
JSON
result=$(_swain_check_marker 2>/dev/null)
assert_eq "same major different minor returns /swain-session" "/swain-session" "$result"

# ─── Test 4: Outdated marker (older major) → /swain-init ───
echo "Test 4: Outdated .swain/init.json marker (older major version)"
mkdir -p "$TMPDIR_TEST/.swain"
cat > "$TMPDIR_TEST/.swain/init.json" << 'JSON'
{
  "history": [
    {
      "version": "3.2.1",
      "timestamp": "2026-03-01T12:00:00Z",
      "action": "init"
    }
  ]
}
JSON
result=$(_swain_check_marker 2>/dev/null)
assert_eq "outdated major returns /swain-init" "/swain-init" "$result"

# ─── Test 5: Malformed marker (not JSON) → /swain-init ───
echo "Test 5: Malformed .swain/init.json marker"
mkdir -p "$TMPDIR_TEST/.swain"
echo "not json" > "$TMPDIR_TEST/.swain/init.json"
result=$(_swain_check_marker 2>/dev/null)
assert_eq "malformed marker returns /swain-init" "/swain-init" "$result"

# ─── Test 6: Marker with upgrade history → /swain-session ───
echo "Test 6: Marker with upgrade history (latest entry is current)"
mkdir -p "$TMPDIR_TEST/.swain"
cat > "$TMPDIR_TEST/.swain/init.json" << 'JSON'
{
  "history": [
    {
      "version": "3.0.0",
      "timestamp": "2026-02-01T12:00:00Z",
      "action": "init"
    },
    {
      "version": "4.0.0",
      "timestamp": "2026-03-15T12:00:00Z",
      "action": "upgrade"
    }
  ]
}
JSON
result=$(_swain_check_marker 2>/dev/null)
assert_eq "upgrade history with current major returns /swain-session" "/swain-session" "$result"

# ─── Test 7: Performance — marker check completes in <100ms ───
echo "Test 7: Performance (<100ms)"
mkdir -p "$TMPDIR_TEST/.swain"
cat > "$TMPDIR_TEST/.swain/init.json" << 'JSON'
{
  "history": [
    {
      "version": "4.1.0",
      "timestamp": "2026-03-26T18:30:00Z",
      "action": "init"
    }
  ]
}
JSON
start_ms=$(python3 -c "import time; print(int(time.time()*1000))")
_swain_check_marker >/dev/null 2>&1
end_ms=$(python3 -c "import time; print(int(time.time()*1000))")
elapsed=$((end_ms - start_ms))
TOTAL=$((TOTAL + 1))
if [[ $elapsed -lt 100 ]]; then
  PASS=$((PASS + 1))
  [[ $VERBOSE -eq 1 ]] && echo "  PASS: performance (${elapsed}ms)"
else
  FAIL=$((FAIL + 1))
  echo "  FAIL: performance (${elapsed}ms, expected <100ms)"
fi

# ─── Test 8: Arguments pass through to /swain-session ───
echo "Test 8: Arguments bypass marker check (go to /swain-session with purpose)"
# When args are provided, the launcher already skips to /swain-session
# This test verifies _swain_check_marker is only for the no-args path

# ─── Summary ───
echo ""
echo "Results: $PASS/$TOTAL passed, $FAIL failed"
[[ $FAIL -eq 0 ]] && exit 0 || exit 1

#!/usr/bin/env bash
# test-swain-init-preflight.sh — test suite for the preflight scanner
#
# Creates temp directories with various project states and verifies
# the preflight script emits correct JSON for each scenario.
#
# Usage: bash test-swain-init-preflight.sh
# Exit: 0 if all tests pass, 1 if any fail

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
PREFLIGHT="$SCRIPT_DIR/swain-init-preflight.sh"
PASS=0
FAIL=0
ERRORS=""

# --- Helpers ---

setup_temp() {
  local dir
  dir=$(mktemp -d)
  # Initialize a git repo so git rev-parse works
  git init -q "$dir"
  echo "$dir"
}

cleanup_temp() {
  rm -rf "$1"
}

assert_json_key() {
  local json="$1" key="$2" expected="$3" label="$4"
  local actual
  actual=$(echo "$json" | python3 -c "
import json, sys
d = json.load(sys.stdin)
keys = '$key'.split('.')
v = d
for k in keys:
    if isinstance(v, dict):
        v = v.get(k)
    else:
        v = None
        break
if isinstance(v, bool):
    print(str(v).lower())
elif v is None:
    print('null')
else:
    print(v)
" 2>/dev/null || echo "PARSE_ERROR")

  if [ "$actual" = "$expected" ]; then
    PASS=$((PASS + 1))
  else
    FAIL=$((FAIL + 1))
    ERRORS="${ERRORS}FAIL: $label — expected '$expected', got '$actual'\n"
  fi
}

assert_json_valid() {
  local json="$1" label="$2"
  if echo "$json" | python3 -c "import json, sys; json.load(sys.stdin)" 2>/dev/null; then
    PASS=$((PASS + 1))
  else
    FAIL=$((FAIL + 1))
    ERRORS="${ERRORS}FAIL: $label — invalid JSON output\n"
  fi
}

# --- Test 1: Fresh project (no marker, no CLAUDE.md, no AGENTS.md) ---

test_fresh_project() {
  local dir
  dir=$(setup_temp)

  local output
  output=$(bash "$PREFLIGHT" --repo-root "$dir" 2>/dev/null)

  assert_json_valid "$output" "fresh: valid JSON"
  assert_json_key "$output" "marker.exists" "false" "fresh: marker.exists"
  assert_json_key "$output" "marker.action" "onboard" "fresh: marker.action"
  assert_json_key "$output" "migration.state" "fresh" "fresh: migration.state"
  assert_json_key "$output" "migration.claude_md" "missing" "fresh: migration.claude_md"
  assert_json_key "$output" "migration.agents_md" "missing" "fresh: migration.agents_md"
  assert_json_key "$output" "beads.exists" "false" "fresh: beads.exists"
  assert_json_key "$output" "governance.installed" "false" "fresh: governance.installed"
  assert_json_key "$output" "readme.exists" "false" "fresh: readme.exists"
  assert_json_key "$output" "agents_dir.exists" "false" "fresh: agents_dir.exists"

  cleanup_temp "$dir"
}

# --- Test 2: Already-initialized project (same major version) ---

test_initialized_same_version() {
  local dir
  dir=$(setup_temp)

  mkdir -p "$dir/.swain"
  cat > "$dir/.swain/init.json" << 'MARKER'
{
  "history": [
    {
      "version": "4.0.0",
      "timestamp": "2026-04-01T00:00:00Z",
      "action": "init"
    }
  ]
}
MARKER

  # Create a fake SKILL.md so version detection works
  mkdir -p "$dir/.claude/skills/swain-init"
  cat > "$dir/.claude/skills/swain-init/SKILL.md" << 'SKILL'
---
name: swain-init
metadata:
  version: 4.1.0
---
SKILL

  local output
  output=$(bash "$PREFLIGHT" --repo-root "$dir" 2>/dev/null)

  assert_json_valid "$output" "init-same: valid JSON"
  assert_json_key "$output" "marker.exists" "true" "init-same: marker.exists"
  assert_json_key "$output" "marker.last_version" "4.0.0" "init-same: marker.last_version"
  assert_json_key "$output" "marker.current_version" "4.1.0" "init-same: marker.current_version"
  assert_json_key "$output" "marker.action" "delegate" "init-same: marker.action"

  cleanup_temp "$dir"
}

# --- Test 3: Initialized with older major version ---

test_initialized_older_version() {
  local dir
  dir=$(setup_temp)

  mkdir -p "$dir/.swain"
  cat > "$dir/.swain/init.json" << 'MARKER'
{
  "history": [
    {
      "version": "3.2.0",
      "timestamp": "2026-01-01T00:00:00Z",
      "action": "init"
    }
  ]
}
MARKER

  mkdir -p "$dir/.claude/skills/swain-init"
  cat > "$dir/.claude/skills/swain-init/SKILL.md" << 'SKILL'
---
name: swain-init
metadata:
  version: 4.0.0
---
SKILL

  local output
  output=$(bash "$PREFLIGHT" --repo-root "$dir" 2>/dev/null)

  assert_json_valid "$output" "init-upgrade: valid JSON"
  assert_json_key "$output" "marker.exists" "true" "init-upgrade: marker.exists"
  assert_json_key "$output" "marker.action" "upgrade" "init-upgrade: marker.action"

  cleanup_temp "$dir"
}

# --- Test 4: Standard migration (CLAUDE.md has content, no AGENTS.md) ---

test_standard_migration() {
  local dir
  dir=$(setup_temp)

  echo "# My Project Instructions" > "$dir/CLAUDE.md"

  local output
  output=$(bash "$PREFLIGHT" --repo-root "$dir" 2>/dev/null)

  assert_json_valid "$output" "standard: valid JSON"
  assert_json_key "$output" "migration.state" "standard" "standard: migration.state"
  assert_json_key "$output" "migration.claude_md" "has_content" "standard: migration.claude_md"
  assert_json_key "$output" "migration.agents_md" "missing" "standard: migration.agents_md"

  cleanup_temp "$dir"
}

# --- Test 5: Split state (both have content) ---

test_split_state() {
  local dir
  dir=$(setup_temp)

  echo "# CLAUDE instructions" > "$dir/CLAUDE.md"
  echo "# AGENTS instructions" > "$dir/AGENTS.md"

  local output
  output=$(bash "$PREFLIGHT" --repo-root "$dir" 2>/dev/null)

  assert_json_valid "$output" "split: valid JSON"
  assert_json_key "$output" "migration.state" "split" "split: migration.state"
  assert_json_key "$output" "migration.claude_md" "has_content" "split: migration.claude_md"
  assert_json_key "$output" "migration.agents_md" "has_content" "split: migration.agents_md"

  cleanup_temp "$dir"
}

# --- Test 6: Already migrated (CLAUDE.md is just @AGENTS.md) ---

test_already_migrated() {
  local dir
  dir=$(setup_temp)

  echo "@AGENTS.md" > "$dir/CLAUDE.md"
  echo "# AGENTS instructions" > "$dir/AGENTS.md"

  local output
  output=$(bash "$PREFLIGHT" --repo-root "$dir" 2>/dev/null)

  assert_json_valid "$output" "migrated: valid JSON"
  assert_json_key "$output" "migration.state" "migrated" "migrated: migration.state"
  assert_json_key "$output" "migration.claude_md" "include_only" "migrated: migration.claude_md"

  cleanup_temp "$dir"
}

# --- Test 7: Beads directory present ---

test_beads_present() {
  local dir
  dir=$(setup_temp)

  mkdir -p "$dir/.beads/backup"
  echo '{}' > "$dir/.beads/backup/issues.jsonl"

  local output
  output=$(bash "$PREFLIGHT" --repo-root "$dir" 2>/dev/null)

  assert_json_valid "$output" "beads: valid JSON"
  assert_json_key "$output" "beads.exists" "true" "beads: beads.exists"
  assert_json_key "$output" "beads.has_backup" "true" "beads: beads.has_backup"

  cleanup_temp "$dir"
}

# --- Test 8: README and artifacts ---

test_readme_with_artifacts() {
  local dir
  dir=$(setup_temp)

  echo "# My Project" > "$dir/README.md"
  mkdir -p "$dir/docs/vision/Active"
  echo "---" > "$dir/docs/vision/Active/VISION-001-test.md"
  mkdir -p "$dir/docs/design/Active"
  echo "---" > "$dir/docs/design/Active/DESIGN-001-test.md"

  local output
  output=$(bash "$PREFLIGHT" --repo-root "$dir" 2>/dev/null)

  assert_json_valid "$output" "readme: valid JSON"
  assert_json_key "$output" "readme.exists" "true" "readme: readme.exists"
  assert_json_key "$output" "readme.has_artifacts" "true" "readme: readme.has_artifacts"
  assert_json_key "$output" "readme.active_count" "2" "readme: readme.active_count"

  cleanup_temp "$dir"
}

# --- Test 9: Governance present ---

test_governance_present() {
  local dir
  dir=$(setup_temp)

  echo "<!-- swain governance -->" > "$dir/AGENTS.md"

  local output
  output=$(bash "$PREFLIGHT" --repo-root "$dir" 2>/dev/null)

  assert_json_valid "$output" "governance: valid JSON"
  assert_json_key "$output" "governance.installed" "true" "governance: governance.installed"

  cleanup_temp "$dir"
}

# --- Run all tests ---

echo "Running swain-init-preflight tests..."
echo ""

test_fresh_project
test_initialized_same_version
test_initialized_older_version
test_standard_migration
test_split_state
test_already_migrated
test_beads_present
test_readme_with_artifacts
test_governance_present

echo ""
echo "Results: $PASS passed, $FAIL failed"

if [ $FAIL -gt 0 ]; then
  echo ""
  printf "%b" "$ERRORS"
  exit 1
fi

exit 0

# swain shell launcher — claude / bash
# Runtime: Claude Code | Shell: bash
# Version: 5.0.0
#
# Launches Claude Code interactively with swain's recommended flags.
# Handles tmux wrapping: outside tmux, starts a new tmux session;
# inside tmux, launches directly in the current pane.
# When arguments are provided, they become the session purpose.
# SPEC-196: Checks .swain/init.json marker to skip the init skill on established projects.

# Check .swain/init.json marker and return the appropriate initial prompt.
# Returns /swain-session if marker is current, /swain-init otherwise.
_swain_check_marker() {
  local marker=".swain/init.json"

  # No marker → need init
  if [ ! -f "$marker" ]; then
    echo "/swain-init"
    return
  fi

  # Extract marker major version (last history entry)
  local marker_version=""
  if command -v jq &>/dev/null; then
    marker_version=$(jq -r '.history[-1].version // empty' "$marker" 2>/dev/null)
  else
    # Fallback: grep for version field in JSON
    marker_version=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$marker" 2>/dev/null | tail -1 | grep -o '"[0-9][^"]*"' | tr -d '"')
  fi

  if [ -z "$marker_version" ]; then
    echo "/swain-init"
    return
  fi

  # Extract installed major version from skill file
  local installed_version=""
  local skill_file
  skill_file=$(find . .claude .agents skills -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null)
  if [ -n "$skill_file" ]; then
    installed_version=$(head -20 "$skill_file" 2>/dev/null | grep '^version:' | awk '{print $2}')
  fi

  if [ -z "$installed_version" ]; then
    # Can't determine installed version — fall through to init
    echo "/swain-init"
    return
  fi

  # Compare major versions
  local marker_major="${marker_version%%.*}"
  local installed_major="${installed_version%%.*}"

  if [ "$marker_major" = "$installed_major" ]; then
    echo "/swain-session"
  else
    echo "/swain-init"
  fi
}

swain() {
  if [ -x "bin/swain" ]; then
    exec bin/swain "$@"
  fi
  local _prompt
  if [ $# -gt 0 ]; then
    export SWAIN_PURPOSE="$*"
    _prompt="/swain-session Session purpose: $*"
  else
    _prompt=$(_swain_check_marker)
  fi
  if [ -z "$TMUX" ]; then
    tmux new-session -s swain "claude --dangerously-skip-permissions '${_prompt}'"
  else
    claude --dangerously-skip-permissions "$_prompt"
  fi
}

# swain shell launcher — claude / fish
# Runtime: Claude Code | Shell: fish
# Version: 5.0.0
#
# Launches Claude Code interactively with swain's recommended flags.
# Handles tmux wrapping: outside tmux, starts a new tmux session;
# inside tmux, launches directly in the current pane.
# When arguments are provided, they become the session purpose.
# SPEC-196: Checks .swain/init.json marker to skip the init skill on established projects.

# Check .swain/init.json marker and return the appropriate initial prompt.
# Returns /swain-session if marker is current, /swain-init otherwise.
function _swain_check_marker
    set -l marker ".swain/init.json"

    # No marker → need init
    if not test -f "$marker"
        echo "/swain-init"
        return
    end

    # Extract marker major version (last history entry)
    set -l marker_version ""
    if command -q jq
        set marker_version (jq -r '.history[-1].version // empty' "$marker" 2>/dev/null)
    else
        # Fallback: grep for version field in JSON
        set marker_version (grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$marker" 2>/dev/null | tail -1 | grep -o '"[0-9][^"]*"' | tr -d '"')
    end

    if test -z "$marker_version"
        echo "/swain-init"
        return
    end

    # Extract installed major version from skill file
    set -l installed_version ""
    set -l skill_file (find . .claude .agents skills -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null)
    if test -n "$skill_file"
        set installed_version (head -20 "$skill_file" 2>/dev/null | grep '^version:' | awk '{print $2}')
    end

    if test -z "$installed_version"
        echo "/swain-init"
        return
    end

    # Compare major versions
    set -l marker_major (string split '.' "$marker_version")[1]
    set -l installed_major (string split '.' "$installed_version")[1]

    if test "$marker_major" = "$installed_major"
        echo "/swain-session"
    else
        echo "/swain-init"
    end
end

function swain
    if test -x bin/swain
        exec bin/swain $argv
    end
    set -l _prompt
    if test (count $argv) -gt 0
        set -gx SWAIN_PURPOSE "$argv"
        set _prompt "/swain-session Session purpose: $argv"
    else
        set _prompt (_swain_check_marker)
    end
    if not set -q TMUX
        tmux new-session -s swain "claude --dangerously-skip-permissions '$_prompt'"
    else
        claude --dangerously-skip-permissions "$_prompt"
    end
end

# swain shell launcher — claude / zsh
# Runtime: Claude Code | Shell: zsh
# Version: 5.0.0
#
# Launches Claude Code interactively with swain's recommended flags.
# Handles tmux wrapping: outside tmux, starts a new tmux session;
# inside tmux, launches directly in the current pane.
# When arguments are provided, they become the session purpose.
# SPEC-196: Checks .swain/init.json marker to skip the init skill on established projects.

# Check .swain/init.json marker and return the appropriate initial prompt.
# Returns /swain-session if marker is current, /swain-init otherwise.
_swain_check_marker() {
  local marker=".swain/init.json"

  # No marker → need init
  if [ ! -f "$marker" ]; then
    echo "/swain-init"
    return
  fi

  # Extract marker major version (last history entry)
  local marker_version=""
  if command -v jq &>/dev/null; then
    marker_version=$(jq -r '.history[-1].version // empty' "$marker" 2>/dev/null)
  else
    # Fallback: grep for version field in JSON
    marker_version=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$marker" 2>/dev/null | tail -1 | grep -o '"[0-9][^"]*"' | tr -d '"')
  fi

  if [ -z "$marker_version" ]; then
    echo "/swain-init"
    return
  fi

  # Extract installed major version from skill file
  local installed_version=""
  local skill_file
  skill_file=$(find . .claude .agents skills -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null)
  if [ -n "$skill_file" ]; then
    installed_version=$(head -20 "$skill_file" 2>/dev/null | grep '^version:' | awk '{print $2}')
  fi

  if [ -z "$installed_version" ]; then
    echo "/swain-init"
    return
  fi

  # Compare major versions
  local marker_major="${marker_version%%.*}"
  local installed_major="${installed_version%%.*}"

  if [ "$marker_major" = "$installed_major" ]; then
    echo "/swain-session"
  else
    echo "/swain-init"
  fi
}

swain() {
  if [ -x "bin/swain" ]; then
    exec bin/swain "$@"
  fi
  local _prompt
  if [ $# -gt 0 ]; then
    export SWAIN_PURPOSE="$*"
    _prompt="/swain-session Session purpose: $*"
  else
    _prompt=$(_swain_check_marker)
  fi
  if [ -z "$TMUX" ]; then
    tmux new-session -s swain "claude --dangerously-skip-permissions '${_prompt}'"
  else
    claude --dangerously-skip-permissions "$_prompt"
  fi
}

# swain shell launcher — codex / bash
# Runtime: Codex CLI (OpenAI) | Shell: bash
# Version: 5.0.0
#
# Launches Codex CLI interactively with swain's recommended flags.
# --yolo: bypass all approvals and sandboxing
# When arguments are provided, they become the session purpose.
# SPEC-196: Checks .swain/init.json marker to skip the init skill on established projects.

# Check .swain/init.json marker and return the appropriate initial prompt.
# Returns /swain-session if marker is current, /swain-init otherwise.
_swain_check_marker() {
  local marker=".swain/init.json"
  if [ ! -f "$marker" ]; then
    echo "/swain-init"
    return
  fi
  local marker_version=""
  if command -v jq &>/dev/null; then
    marker_version=$(jq -r '.history[-1].version // empty' "$marker" 2>/dev/null)
  else
    marker_version=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$marker" 2>/dev/null | tail -1 | grep -o '"[0-9][^"]*"' | tr -d '"')
  fi
  if [ -z "$marker_version" ]; then
    echo "/swain-init"
    return
  fi
  local installed_version=""
  local skill_file
  skill_file=$(find . .claude .agents skills -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null)
  if [ -n "$skill_file" ]; then
    installed_version=$(head -20 "$skill_file" 2>/dev/null | grep '^version:' | awk '{print $2}')
  fi
  if [ -z "$installed_version" ]; then
    echo "/swain-init"
    return
  fi
  local marker_major="${marker_version%%.*}"
  local installed_major="${installed_version%%.*}"
  if [ "$marker_major" = "$installed_major" ]; then
    echo "/swain-session"
  else
    echo "/swain-init"
  fi
}

swain() {
  if [ -x "bin/swain" ]; then
    exec bin/swain "$@"
  fi
  local _prompt
  if [ $# -gt 0 ]; then
    export SWAIN_PURPOSE="$*"
    _prompt="/swain-session Session purpose: $*"
  else
    _prompt=$(_swain_check_marker)
  fi
  if [ -z "$TMUX" ]; then
    tmux new-session -s swain "codex --yolo '${_prompt}'"
  else
    codex --yolo "$_prompt"
  fi
}

# swain shell launcher — codex / fish
# Runtime: Codex CLI (OpenAI) | Shell: fish
# Version: 5.0.0
#
# Launches Codex CLI interactively with swain's recommended flags.
# --yolo: bypass all approvals and sandboxing
# When arguments are provided, they become the session purpose.
# SPEC-196: Checks .swain/init.json marker to skip the init skill on established projects.

# Check .swain/init.json marker and return the appropriate initial prompt.
# Returns /swain-session if marker is current, /swain-init otherwise.
function _swain_check_marker
    set -l marker ".swain/init.json"
    if not test -f "$marker"
        echo "/swain-init"
        return
    end
    set -l marker_version ""
    if command -q jq
        set marker_version (jq -r '.history[-1].version // empty' "$marker" 2>/dev/null)
    else
        set marker_version (grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$marker" 2>/dev/null | tail -1 | grep -o '"[0-9][^"]*"' | tr -d '"')
    end
    if test -z "$marker_version"
        echo "/swain-init"
        return
    end
    set -l installed_version ""
    set -l skill_file (find . .claude .agents skills -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null)
    if test -n "$skill_file"
        set installed_version (head -20 "$skill_file" 2>/dev/null | grep '^version:' | awk '{print $2}')
    end
    if test -z "$installed_version"
        echo "/swain-init"
        return
    end
    set -l marker_major (string split '.' "$marker_version")[1]
    set -l installed_major (string split '.' "$installed_version")[1]
    if test "$marker_major" = "$installed_major"
        echo "/swain-session"
    else
        echo "/swain-init"
    end
end

function swain
    if test -x bin/swain
        exec bin/swain $argv
    end
    set -l _prompt
    if test (count $argv) -gt 0
        set -gx SWAIN_PURPOSE "$argv"
        set _prompt "/swain-session Session purpose: $argv"
    else
        set _prompt (_swain_check_marker)
    end
    if not set -q TMUX
        tmux new-session -s swain "codex --yolo '$_prompt'"
    else
        codex --yolo "$_prompt"
    end
end

# swain shell launcher — codex / zsh
# Runtime: Codex CLI (OpenAI) | Shell: zsh
# Version: 5.0.0
#
# Launches Codex CLI interactively with swain's recommended flags.
# --yolo: bypass all approvals and sandboxing
# When arguments are provided, they become the session purpose.
# SPEC-196: Checks .swain/init.json marker to skip the init skill on established projects.

# Check .swain/init.json marker and return the appropriate initial prompt.
# Returns /swain-session if marker is current, /swain-init otherwise.
_swain_check_marker() {
  local marker=".swain/init.json"
  if [ ! -f "$marker" ]; then
    echo "/swain-init"
    return
  fi
  local marker_version=""
  if command -v jq &>/dev/null; then
    marker_version=$(jq -r '.history[-1].version // empty' "$marker" 2>/dev/null)
  else
    marker_version=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$marker" 2>/dev/null | tail -1 | grep -o '"[0-9][^"]*"' | tr -d '"')
  fi
  if [ -z "$marker_version" ]; then
    echo "/swain-init"
    return
  fi
  local installed_version=""
  local skill_file
  skill_file=$(find . .claude .agents skills -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null)
  if [ -n "$skill_file" ]; then
    installed_version=$(head -20 "$skill_file" 2>/dev/null | grep '^version:' | awk '{print $2}')
  fi
  if [ -z "$installed_version" ]; then
    echo "/swain-init"
    return
  fi
  local marker_major="${marker_version%%.*}"
  local installed_major="${installed_version%%.*}"
  if [ "$marker_major" = "$installed_major" ]; then
    echo "/swain-session"
  else
    echo "/swain-init"
  fi
}

swain() {
  if [ -x "bin/swain" ]; then
    exec bin/swain "$@"
  fi
  local _prompt
  if [ $# -gt 0 ]; then
    export SWAIN_PURPOSE="$*"
    _prompt="/swain-session Session purpose: $*"
  else
    _prompt=$(_swain_check_marker)
  fi
  if [ -z "$TMUX" ]; then
    tmux new-session -s swain "codex --yolo '${_prompt}'"
  else
    codex --yolo "$_prompt"
  fi
}

# swain shell launcher — copilot / bash
# Runtime: GitHub Copilot CLI | Shell: bash
# Version: 5.0.0
#
# Launches GitHub Copilot CLI interactively with swain's recommended flags.
# When arguments are provided, they become the session purpose.
# SPEC-196: Checks .swain/init.json marker to skip the init skill on established projects.

# Check .swain/init.json marker and return the appropriate initial prompt.
# Returns /swain-session if marker is current, /swain-init otherwise.
_swain_check_marker() {
  local marker=".swain/init.json"
  if [ ! -f "$marker" ]; then
    echo "/swain-init"
    return
  fi
  local marker_version=""
  if command -v jq &>/dev/null; then
    marker_version=$(jq -r '.history[-1].version // empty' "$marker" 2>/dev/null)
  else
    marker_version=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$marker" 2>/dev/null | tail -1 | grep -o '"[0-9][^"]*"' | tr -d '"')
  fi
  if [ -z "$marker_version" ]; then
    echo "/swain-init"
    return
  fi
  local installed_version=""
  local skill_file
  skill_file=$(find . .claude .agents skills -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null)
  if [ -n "$skill_file" ]; then
    installed_version=$(head -20 "$skill_file" 2>/dev/null | grep '^version:' | awk '{print $2}')
  fi
  if [ -z "$installed_version" ]; then
    echo "/swain-init"
    return
  fi
  local marker_major="${marker_version%%.*}"
  local installed_major="${installed_version%%.*}"
  if [ "$marker_major" = "$installed_major" ]; then
    echo "/swain-session"
  else
    echo "/swain-init"
  fi
}

swain() {
  if [ -x "bin/swain" ]; then
    exec bin/swain "$@"
  fi
  local _prompt
  if [ $# -gt 0 ]; then
    export SWAIN_PURPOSE="$*"
    _prompt="/swain-session Session purpose: $*"
  else
    _prompt=$(_swain_check_marker)
  fi
  if [ -z "$TMUX" ]; then
    tmux new-session -s swain "gh copilot '${_prompt}'"
  else
    gh copilot "$_prompt"
  fi
}

# swain shell launcher — copilot / fish
# Runtime: GitHub Copilot CLI | Shell: fish
# Version: 5.0.0
#
# Launches GitHub Copilot CLI interactively with swain's recommended flags.
# When arguments are provided, they become the session purpose.
# SPEC-196: Checks .swain/init.json marker to skip the init skill on established projects.

# Check .swain/init.json marker and return the appropriate initial prompt.
# Returns /swain-session if marker is current, /swain-init otherwise.
function _swain_check_marker
    set -l marker ".swain/init.json"
    if not test -f "$marker"
        echo "/swain-init"
        return
    end
    set -l marker_version ""
    if command -q jq
        set marker_version (jq -r '.history[-1].version // empty' "$marker" 2>/dev/null)
    else
        set marker_version (grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$marker" 2>/dev/null | tail -1 | grep -o '"[0-9][^"]*"' | tr -d '"')
    end
    if test -z "$marker_version"
        echo "/swain-init"
        return
    end
    set -l installed_version ""
    set -l skill_file (find . .claude .agents skills -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null)
    if test -n "$skill_file"
        set installed_version (head -20 "$skill_file" 2>/dev/null | grep '^version:' | awk '{print $2}')
    end
    if test -z "$installed_version"
        echo "/swain-init"
        return
    end
    set -l marker_major (string split '.' "$marker_version")[1]
    set -l installed_major (string split '.' "$installed_version")[1]
    if test "$marker_major" = "$installed_major"
        echo "/swain-session"
    else
        echo "/swain-init"
    end
end

function swain
    if test -x bin/swain
        exec bin/swain $argv
    end
    set -l _prompt
    if test (count $argv) -gt 0
        set -gx SWAIN_PURPOSE "$argv"
        set _prompt "/swain-session Session purpose: $argv"
    else
        set _prompt (_swain_check_marker)
    end
    if not set -q TMUX
        tmux new-session -s swain "gh copilot '$_prompt'"
    else
        gh copilot "$_prompt"
    end
end

# swain shell launcher — copilot / zsh
# Runtime: GitHub Copilot CLI | Shell: zsh
# Version: 5.0.0
#
# Launches GitHub Copilot CLI interactively with swain's recommended flags.
# When arguments are provided, they become the session purpose.
# SPEC-196: Checks .swain/init.json marker to skip the init skill on established projects.

# Check .swain/init.json marker and return the appropriate initial prompt.
# Returns /swain-session if marker is current, /swain-init otherwise.
_swain_check_marker() {
  local marker=".swain/init.json"
  if [ ! -f "$marker" ]; then
    echo "/swain-init"
    return
  fi
  local marker_version=""
  if command -v jq &>/dev/null; then
    marker_version=$(jq -r '.history[-1].version // empty' "$marker" 2>/dev/null)
  else
    marker_version=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$marker" 2>/dev/null | tail -1 | grep -o '"[0-9][^"]*"' | tr -d '"')
  fi
  if [ -z "$marker_version" ]; then
    echo "/swain-init"
    return
  fi
  local installed_version=""
  local skill_file
  skill_file=$(find . .claude .agents skills -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null)
  if [ -n "$skill_file" ]; then
    installed_version=$(head -20 "$skill_file" 2>/dev/null | grep '^version:' | awk '{print $2}')
  fi
  if [ -z "$installed_version" ]; then
    echo "/swain-init"
    return
  fi
  local marker_major="${marker_version%%.*}"
  local installed_major="${installed_version%%.*}"
  if [ "$marker_major" = "$installed_major" ]; then
    echo "/swain-session"
  else
    echo "/swain-init"
  fi
}

swain() {
  if [ -x "bin/swain" ]; then
    exec bin/swain "$@"
  fi
  local _prompt
  if [ $# -gt 0 ]; then
    export SWAIN_PURPOSE="$*"
    _prompt="/swain-session Session purpose: $*"
  else
    _prompt=$(_swain_check_marker)
  fi
  if [ -z "$TMUX" ]; then
    tmux new-session -s swain "gh copilot '${_prompt}'"
  else
    gh copilot "$_prompt"
  fi
}

# swain shell launcher — crush / bash
# Runtime: Crush (formerly opencode) | Shell: bash
# Version: 4.1.0
#
# Launches Crush interactively with swain's recommended flags.
# --yolo: auto-approve all permission requests
#
# NOTE: Crush does not support an initial prompt in interactive mode
# (Partial support per ADR-017). Session initialization relies on
# AGENTS.md auto-invoke directives instead. Free-text session purpose
# is passed via the SWAIN_PURPOSE environment variable.

swain() {
  if [ -x "bin/swain" ]; then
    exec bin/swain "$@"
  fi
  if [ $# -gt 0 ]; then
    export SWAIN_PURPOSE="$*"
  fi
  if [ -z "$TMUX" ]; then
    tmux new-session -s swain "crush --yolo"
  else
    crush --yolo
  fi
}

# swain shell launcher — crush / fish
# Runtime: Crush (formerly opencode) | Shell: fish
# Version: 4.1.0
#
# Launches Crush interactively with swain's recommended flags.
# --yolo: auto-approve all permission requests
#
# NOTE: Crush does not support an initial prompt in interactive mode
# (Partial support per ADR-017). Session initialization relies on
# AGENTS.md auto-invoke directives instead. Free-text session purpose
# is passed via the SWAIN_PURPOSE environment variable.

function swain
    if test -x bin/swain
        exec bin/swain $argv
    end
    if test (count $argv) -gt 0
        set -gx SWAIN_PURPOSE "$argv"
    end
    if not set -q TMUX
        tmux new-session -s swain "crush --yolo"
    else
        crush --yolo
    end
end

# swain shell launcher — crush / zsh
# Runtime: Crush (formerly opencode) | Shell: zsh
# Version: 4.1.0
#
# Launches Crush interactively with swain's recommended flags.
# --yolo: auto-approve all permission requests
#
# NOTE: Crush does not support an initial prompt in interactive mode
# (Partial support per ADR-017). Session initialization relies on
# AGENTS.md auto-invoke directives instead. Free-text session purpose
# is passed via the SWAIN_PURPOSE environment variable.

swain() {
  if [ -x "bin/swain" ]; then
    exec bin/swain "$@"
  fi
  if [ $# -gt 0 ]; then
    export SWAIN_PURPOSE="$*"
  fi
  if [ -z "$TMUX" ]; then
    tmux new-session -s swain "crush --yolo"
  else
    crush --yolo
  fi
}

# swain shell launcher — gemini / bash
# Runtime: Gemini CLI | Shell: bash
# Version: 5.0.0
#
# Launches Gemini CLI interactively with swain's recommended flags.
# -y: auto-approve all tool actions (yolo mode)
# -i: interactive mode with initial prompt
# When arguments are provided, they become the session purpose.
# SPEC-196: Checks .swain/init.json marker to skip the init skill on established projects.

# Check .swain/init.json marker and return the appropriate initial prompt.
# Returns /swain-session if marker is current, /swain-init otherwise.
_swain_check_marker() {
  local marker=".swain/init.json"
  if [ ! -f "$marker" ]; then
    echo "/swain-init"
    return
  fi
  local marker_version=""
  if command -v jq &>/dev/null; then
    marker_version=$(jq -r '.history[-1].version // empty' "$marker" 2>/dev/null)
  else
    marker_version=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$marker" 2>/dev/null | tail -1 | grep -o '"[0-9][^"]*"' | tr -d '"')
  fi
  if [ -z "$marker_version" ]; then
    echo "/swain-init"
    return
  fi
  local installed_version=""
  local skill_file
  skill_file=$(find . .claude .agents skills -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null)
  if [ -n "$skill_file" ]; then
    installed_version=$(head -20 "$skill_file" 2>/dev/null | grep '^version:' | awk '{print $2}')
  fi
  if [ -z "$installed_version" ]; then
    echo "/swain-init"
    return
  fi
  local marker_major="${marker_version%%.*}"
  local installed_major="${installed_version%%.*}"
  if [ "$marker_major" = "$installed_major" ]; then
    echo "/swain-session"
  else
    echo "/swain-init"
  fi
}

swain() {
  if [ -x "bin/swain" ]; then
    exec bin/swain "$@"
  fi
  local _prompt
  if [ $# -gt 0 ]; then
    export SWAIN_PURPOSE="$*"
    _prompt="/swain-session Session purpose: $*"
  else
    _prompt=$(_swain_check_marker)
  fi
  if [ -z "$TMUX" ]; then
    tmux new-session -s swain "gemini -y -i '${_prompt}'"
  else
    gemini -y -i "$_prompt"
  fi
}

# swain shell launcher — gemini / fish
# Runtime: Gemini CLI | Shell: fish
# Version: 5.0.0
#
# Launches Gemini CLI interactively with swain's recommended flags.
# -y: auto-approve all tool actions (yolo mode)
# -i: interactive mode with initial prompt
# When arguments are provided, they become the session purpose.
# SPEC-196: Checks .swain/init.json marker to skip the init skill on established projects.

# Check .swain/init.json marker and return the appropriate initial prompt.
# Returns /swain-session if marker is current, /swain-init otherwise.
function _swain_check_marker
    set -l marker ".swain/init.json"
    if not test -f "$marker"
        echo "/swain-init"
        return
    end
    set -l marker_version ""
    if command -q jq
        set marker_version (jq -r '.history[-1].version // empty' "$marker" 2>/dev/null)
    else
        set marker_version (grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$marker" 2>/dev/null | tail -1 | grep -o '"[0-9][^"]*"' | tr -d '"')
    end
    if test -z "$marker_version"
        echo "/swain-init"
        return
    end
    set -l installed_version ""
    set -l skill_file (find . .claude .agents skills -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null)
    if test -n "$skill_file"
        set installed_version (head -20 "$skill_file" 2>/dev/null | grep '^version:' | awk '{print $2}')
    end
    if test -z "$installed_version"
        echo "/swain-init"
        return
    end
    set -l marker_major (string split '.' "$marker_version")[1]
    set -l installed_major (string split '.' "$installed_version")[1]
    if test "$marker_major" = "$installed_major"
        echo "/swain-session"
    else
        echo "/swain-init"
    end
end

function swain
    if test -x bin/swain
        exec bin/swain $argv
    end
    set -l _prompt
    if test (count $argv) -gt 0
        set -gx SWAIN_PURPOSE "$argv"
        set _prompt "/swain-session Session purpose: $argv"
    else
        set _prompt (_swain_check_marker)
    end
    if not set -q TMUX
        tmux new-session -s swain "gemini -y -i '$_prompt'"
    else
        gemini -y -i "$_prompt"
    end
end

# swain shell launcher — gemini / zsh
# Runtime: Gemini CLI | Shell: zsh
# Version: 5.0.0
#
# Launches Gemini CLI interactively with swain's recommended flags.
# -y: auto-approve all tool actions (yolo mode)
# -i: interactive mode with initial prompt
# When arguments are provided, they become the session purpose.
# SPEC-196: Checks .swain/init.json marker to skip the init skill on established projects.

# Check .swain/init.json marker and return the appropriate initial prompt.
# Returns /swain-session if marker is current, /swain-init otherwise.
_swain_check_marker() {
  local marker=".swain/init.json"
  if [ ! -f "$marker" ]; then
    echo "/swain-init"
    return
  fi
  local marker_version=""
  if command -v jq &>/dev/null; then
    marker_version=$(jq -r '.history[-1].version // empty' "$marker" 2>/dev/null)
  else
    marker_version=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$marker" 2>/dev/null | tail -1 | grep -o '"[0-9][^"]*"' | tr -d '"')
  fi
  if [ -z "$marker_version" ]; then
    echo "/swain-init"
    return
  fi
  local installed_version=""
  local skill_file
  skill_file=$(find . .claude .agents skills -path '*/swain-init/SKILL.md' -print -quit 2>/dev/null)
  if [ -n "$skill_file" ]; then
    installed_version=$(head -20 "$skill_file" 2>/dev/null | grep '^version:' | awk '{print $2}')
  fi
  if [ -z "$installed_version" ]; then
    echo "/swain-init"
    return
  fi
  local marker_major="${marker_version%%.*}"
  local installed_major="${installed_version%%.*}"
  if [ "$marker_major" = "$installed_major" ]; then
    echo "/swain-session"
  else
    echo "/swain-init"
  fi
}

swain() {
  if [ -x "bin/swain" ]; then
    exec bin/swain "$@"
  fi
  local _prompt
  if [ $# -gt 0 ]; then
    export SWAIN_PURPOSE="$*"
    _prompt="/swain-session Session purpose: $*"
  else
    _prompt=$(_swain_check_marker)
  fi
  if [ -z "$TMUX" ]; then
    tmux new-session -s swain "gemini -y -i '${_prompt}'"
  else
    gemini -y -i "$_prompt"
  fi
}

# swain shell launcher — thin wrapper
# Version: 5.0.0
#
# Delegates to the project-root swain script (SPEC-180) when available.
# Falls back to direct runtime invocation for projects without it.
# See: SPEC-181 (Shell Function Refactor)

swain() {
  if [ -x "bin/swain" ]; then
    exec bin/swain "$@"
  elif command -v claude >/dev/null 2>&1; then
    local _prompt='/swain-init'
    [ $# -gt 0 ] && _prompt="/swain-session Session purpose: $*"
    if [ -z "$TMUX" ]; then
      tmux new-session -s swain "claude --dangerously-skip-permissions '${_prompt}'"
    else
      claude --dangerously-skip-permissions "$_prompt"
    fi
  else
    echo "swain: no bin/swain script and no supported runtime found" >&2
    return 1
  fi
}

# swain shell launcher — thin wrapper
# Version: 5.0.0
#
# Delegates to the project-root swain script (SPEC-180) when available.
# Falls back to direct runtime invocation for projects without it.
# See: SPEC-181 (Shell Function Refactor)

swain() {
  if [ -x "bin/swain" ]; then
    exec bin/swain "$@"
  elif command -v claude >/dev/null 2>&1; then
    local _prompt='/swain-init'
    [ $# -gt 0 ] && _prompt="/swain-session Session purpose: $*"
    if [ -z "$TMUX" ]; then
      tmux new-session -s swain "claude --dangerously-skip-permissions '${_prompt}'"
    else
      claude --dangerously-skip-permissions "$_prompt"
    fi
  else
    echo "swain: no bin/swain script and no supported runtime found" >&2
    return 1
  fi
}