Swain Session

#!/usr/bin/env bash
set -euo pipefail

# swain-bookmark.sh — Unified bookmark management for swain
#
# Manages two kinds of bookmarks in session.json:
#   - Context bookmarks: free-text notes about what the operator is working on
#   - Worktree bookmarks: structured records of worktrees created during sessions
#
# Usage (context):
#   swain-bookmark.sh "note text"
#   swain-bookmark.sh "note text" --files file1.md file2.md
#   swain-bookmark.sh --clear
#
# Usage (worktree):
#   swain-bookmark.sh worktree add <path> <branch>
#   swain-bookmark.sh worktree remove <path>
#   swain-bookmark.sh worktree list
#   swain-bookmark.sh worktree prune
#
# Requires: jq (for worktree subcommands)

REPO_ROOT="${SWAIN_REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
SESSION_FILE="${SWAIN_SESSION_FILE:-$REPO_ROOT/.agents/session.json}"

# --- Locate / migrate session.json ---
if [[ ! -f "$SESSION_FILE" ]]; then
  _OLD_SLUG=$(echo "$REPO_ROOT" | tr '/' '-')
  _OLD_FILE="$HOME/.claude/projects/${_OLD_SLUG}/memory/session.json"
  if [[ -f "$_OLD_FILE" ]]; then
    mkdir -p "$(dirname "$SESSION_FILE")"
    cp "$_OLD_FILE" "$SESSION_FILE"
  fi
fi

if [[ ! -f "$SESSION_FILE" ]]; then
  mkdir -p "$(dirname "$SESSION_FILE")"
  echo '{}' > "$SESSION_FILE"
fi

# ============================================================
# Worktree subcommands
# ============================================================

worktree_cmd() {
  local subcmd="${1:-}"
  case "$subcmd" in
    add)    worktree_add "$2" "$3" ;;
    remove) worktree_remove "$2" ;;
    list)   worktree_list ;;
    prune)  worktree_prune ;;
    *)      echo "Usage: swain-bookmark.sh worktree <add|remove|list|prune>" >&2; exit 1 ;;
  esac
}

worktree_add() {
  local wt_path="${1:-}"
  local wt_branch="${2:-}"

  if [[ -z "$wt_path" ]] || [[ -z "$wt_branch" ]]; then
    echo "Error: worktree add requires <path> and <branch>" >&2
    exit 1
  fi

  if ! command -v jq &>/dev/null; then
    echo "Error: jq is required for worktree operations" >&2
    exit 1
  fi

  # Skip trunk
  if [[ "$wt_path" == "$REPO_ROOT" ]]; then
    echo "Skipping trunk — trunk is never bookmarked."
    return 0
  fi

  # Get session_id
  local session_id
  session_id=$(jq -r '.session_id // empty' "$REPO_ROOT/.agents/session-state.json" 2>/dev/null || echo "")
  if [[ -z "$session_id" ]]; then
    session_id="no-session"
  fi

  local timestamp
  timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)

  # Build new worktree entry as JSON
  local new_entry
  new_entry=$(jq -n \
    --arg path "$wt_path" \
    --arg branch "$wt_branch" \
    --arg session_id "$session_id" \
    --arg last_active "$timestamp" \
    '{
      path: $path,
      branch: $branch,
      session_id: $session_id,
      last_active: $last_active
    }')

  # Remove any existing entry for this path, then append new one
  # Worktrees is an array; we filter out the matching path and append
  local tmp
  tmp="$(mktemp)"

  jq --argjson new_entry "$new_entry" \
    '.worktrees = (
       [ (.worktrees // [])[] | select(.path != $new_entry.path) ] +
       [$new_entry]
     )' \
    "$SESSION_FILE" > "$tmp" && mv "$tmp" "$SESSION_FILE"

  echo "Worktree bookmark added: $wt_path ($wt_branch)"
}

worktree_remove() {
  local wt_path="${1:-}"

  if [[ -z "$wt_path" ]]; then
    echo "Error: worktree remove requires <path>" >&2
    exit 1
  fi

  if ! command -v jq &>/dev/null; then
    echo "Error: jq is required for worktree operations" >&2
    exit 1
  fi

  local tmp
  tmp="$(mktemp)"

  jq --arg path "$wt_path" \
    '.worktrees = [ (.worktrees // [])[] | select(.path != $path) ]' \
    "$SESSION_FILE" > "$tmp" && mv "$tmp" "$SESSION_FILE"

  echo "Worktree bookmark removed: $wt_path"
}

worktree_list() {
  if ! command -v jq &>/dev/null; then
    echo "Error: jq is required for worktree operations" >&2
    exit 1
  fi

  local worktrees
  worktrees=$(jq -r '.worktrees | if type == "array" then . else [] end | .[] | "\(.path)|\(.branch)|\(.session_id)|\(.last_active)"' "$SESSION_FILE" 2>/dev/null || echo "")

  if [[ -z "$worktrees" ]]; then
    echo "No worktree bookmarks found."
  else
    while IFS='|' read -r path branch session_id last_active; do
      echo "$path|$branch|$session_id|$last_active"
    done <<< "$worktrees"
  fi
}

worktree_prune() {
  if ! command -v jq &>/dev/null; then
    echo "Error: jq is required for worktree operations" >&2
    exit 1
  fi

  local tmp
  tmp="$(mktemp)"
  local removed=0

  # Read all paths and check which directories still exist
  local paths
  IFS=$'\n' read -r -d '' -a paths < <(jq -r '.worktrees | if type == "array" then .[].path else [] end | select(. != "")' "$SESSION_FILE" 2>/dev/null | sort -u) || true

  if [[ ${#paths[@]} -eq 0 ]]; then
    echo "No worktree bookmarks to prune."
    return 0
  fi

  for wt_path in "${paths[@]}"; do
    if [[ ! -d "$wt_path" ]]; then
      jq --arg path "$wt_path" \
        '.worktrees = [ (.worktrees // [])[] | select(.path != $path) ]' \
        "$SESSION_FILE" > "$tmp" && mv "$tmp" "$SESSION_FILE"
      echo "Pruned stale worktree bookmark: $wt_path"
      ((removed++)) || true
    fi
  done

  echo "Pruned $removed stale worktree bookmark(s)."
}

# ============================================================
# Context bookmark (existing behavior)
# ============================================================

if [[ "${1:-}" == "worktree" ]]; then
  shift
  worktree_cmd "${1:-}" "${2:-}" "${3:-}"
  exit $?
fi

# --- Context bookmark: requires jq for note operations ---
if ! command -v jq &>/dev/null; then
  exit 0
fi

CLEAR=0
NOTE=""
FILES=()
PARSING_FILES=0

for arg in "$@"; do
  if [[ "$arg" == "--clear" ]]; then
    CLEAR=1
  elif [[ "$arg" == "--files" ]]; then
    PARSING_FILES=1
  elif [[ "$PARSING_FILES" -eq 1 ]]; then
    FILES+=("$arg")
  elif [[ -z "$NOTE" ]]; then
    NOTE="$arg"
  fi
done

if [[ "$CLEAR" -eq 1 ]]; then
  jq 'del(.bookmark)' "$SESSION_FILE" > "$SESSION_FILE.tmp" \
    && mv "$SESSION_FILE.tmp" "$SESSION_FILE"
elif [[ -n "$NOTE" ]]; then
  TIMESTAMP="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
  if [[ "${#FILES[@]}" -gt 0 ]]; then
    FILES_JSON=$(printf '%s\n' "${FILES[@]}" | jq -R . | jq -s . 2>/dev/null || echo '[]')
    jq --arg note "$NOTE" --arg ts "$TIMESTAMP" --argjson files "$FILES_JSON" \
      '.bookmark = {note: $note, files: $files, timestamp: $ts}' \
      "$SESSION_FILE" > "$SESSION_FILE.tmp" \
      && mv "$SESSION_FILE.tmp" "$SESSION_FILE"
  else
    jq --arg note "$NOTE" --arg ts "$TIMESTAMP" \
      '.bookmark = {note: $note, timestamp: $ts}' \
      "$SESSION_FILE" > "$SESSION_FILE.tmp" \
      && mv "$SESSION_FILE.tmp" "$SESSION_FILE"
  fi
else
  echo "Usage: swain-bookmark.sh \"note text\" [--files file1 file2 ...]" >&2
  echo "       swain-bookmark.sh --clear" >&2
  echo "       swain-bookmark.sh worktree <add|remove|list|prune> [args]" >&2
  exit 1
fi

#!/usr/bin/env bash
set -euo pipefail

# Set or clear the focus lane in session.json
# Usage: swain-focus.sh set VISION-001
#        swain-focus.sh clear
#        swain-focus.sh (show current)

REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null)" || {
  echo "Error: not inside a git repository" >&2
  exit 1
}
SESSION_FILE="$REPO_ROOT/.agents/session.json"

ACTION="${1:-}"
FOCUS_ID="${2:-}"

if [[ ! -f "$SESSION_FILE" ]]; then
  echo '{}' > "$SESSION_FILE"
fi

case "$ACTION" in
  set)
    if [[ -z "$FOCUS_ID" ]]; then
      echo "Usage: swain-focus.sh set <VISION-ID or INITIATIVE-ID>" >&2
      exit 1
    fi
    jq --arg focus "$FOCUS_ID" '.focus_lane = $focus' "$SESSION_FILE" > "${SESSION_FILE}.tmp" \
      && mv "${SESSION_FILE}.tmp" "$SESSION_FILE"
    echo "Focus lane set to: $FOCUS_ID"
    ;;
  clear)
    jq 'del(.focus_lane)' "$SESSION_FILE" > "${SESSION_FILE}.tmp" \
      && mv "${SESSION_FILE}.tmp" "$SESSION_FILE"
    echo "Focus lane cleared"
    ;;
  *)
    # Show current focus
    CURRENT=$(jq -r '.focus_lane // "none"' "$SESSION_FILE" 2>/dev/null || echo "none")
    echo "Current focus: $CURRENT"
    ;;
esac

#!/usr/bin/env bash
# swain-preflight-timing.sh — SPIKE-001: Detailed preflight timing breakdown
set +e

REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
cd "$REPO_ROOT"

# Portable path resolution — works whether installed at skills/ or .agents/skills/
_src="${BASH_SOURCE[0]}"
while [[ -L "$_src" ]]; do
  _dir="$(cd "$(dirname "$_src")" && pwd)"
  _src="$(readlink "$_src")"
  [[ "$_src" != /* ]] && _src="$_dir/$_src"
done
_TIMING_SCRIPT_DIR="$(cd "$(dirname "$_src")" && pwd)"
_TIMING_SKILLS_ROOT="$(dirname "$(dirname "$_TIMING_SCRIPT_DIR")")"

if command -v gdate &>/dev/null; then
  _ts() { gdate +%s%3N; }
else
  _ts() { python3 -c "import time; print(int(time.time()*1000))"; }
fi

time_check() {
  local name="$1"
  shift
  local start=$(_ts)
  eval "$@" >/dev/null 2>&1
  local end=$(_ts)
  printf "  %-45s %6d ms\n" "$name" "$((end - start))"
}

echo "=== Preflight Timing Breakdown ==="

time_check "governance_files_exist" '[[ -f AGENTS.md ]] || [[ -f CLAUDE.md ]]'
time_check "governance_markers" 'grep -q "swain governance" AGENTS.md CLAUDE.md 2>/dev/null'

time_check "governance_freshness_hash" '
  GOV_FILE=$(grep -l "swain governance" AGENTS.md CLAUDE.md 2>/dev/null | head -1)
  awk "/<!-- swain governance/{f=1;next}/<!-- end swain governance/{f=0}f" "$GOV_FILE" | shasum -a 256
  awk "/<!-- swain governance/{f=1;next}/<!-- end swain governance/{f=0}f" "'"$_TIMING_SKILLS_ROOT"'/swain-doctor/references/AGENTS.content.md" | shasum -a 256
'

time_check "agents_dir_check" '[[ -d .agents ]]'
time_check "tickets_dir_check" 'for f in .tickets/*.md; do [[ -f "$f" ]] && head -1 "$f" | grep -q "^---$"; break; done'
time_check "beads_dir_check" '[[ -d .beads ]]'
time_check "evidence_pool_check" '[[ -d docs/evidence-pools ]]'
time_check "stale_locks" 'find .tickets/.locks -type d -mmin +60 2>/dev/null | wc -l'
time_check "old_phase_dirs" 'find docs/*/Draft docs/*/Planned docs/*/Review 2>/dev/null | head -1'
time_check "commit_signing_check" 'git config --local commit.gpgsign'

time_check "script_permissions" "find '$_TIMING_SKILLS_ROOT' -type f \( -path '*/scripts/*.sh' -o -path '*/scripts/*.py' \) ! -perm -u+x 2>/dev/null"

time_check "ssh_readiness" "bash '$_TIMING_SKILLS_ROOT/swain-doctor/scripts/ssh-readiness.sh' --check 2>/dev/null"
time_check "skill_gitignore_hygiene" '
  _origin_url="$(git remote get-url origin 2>/dev/null || true)"
  for _base in .claude/skills .agents/skills; do
    [ -d "$_base" ] || continue
    for _skill_path in "$_base"/swain "$_base"/swain-*/; do
      [[ -d "$_skill_path" ]] && git check-ignore -q "$_skill_path" 2>/dev/null
    done
  done
'

time_check "superpowers_detection" '
  for skill in brainstorming writing-plans test-driven-development verification-before-completion subagent-driven-development executing-plans; do
    ls .agents/skills/$skill/SKILL.md .claude/skills/$skill/SKILL.md 2>/dev/null | head -1
  done
'

time_check "scanner_availability" "python3 '$_TIMING_SKILLS_ROOT/swain-security-check/scripts/scanner_availability.py' 2>/dev/null"
time_check "mmdc_check" 'command -v mmdc'
time_check "doctor_security_check" "python3 '$_TIMING_SKILLS_ROOT/swain-security-check/scripts/doctor_security_check.py' 2>/dev/null"
time_check "skill_change_discipline" "bash '$_TIMING_SKILLS_ROOT/swain-doctor/scripts/check-skill-changes.sh' 2>/dev/null"

time_check "agents_bin_symlink_repair" "
  for skill_scripts_dir in '$_TIMING_SKILLS_ROOT'/*/scripts; do
    [[ -d \"\$skill_scripts_dir\" ]] || continue
    for script in \"\$skill_scripts_dir\"/*; do
      [[ -f \"\$script\" && -x \"\$script\" ]] || continue
    done
  done
"

time_check "trunk_release_detection" 'bash .agents/bin/swain-trunk.sh 2>/dev/null && git ls-remote --heads origin trunk 2>/dev/null'

time_check "initiative_migration_check" 'find docs/epic -name "*.md" -not -name "README.md" -not -name "list-*.md" 2>/dev/null | while read f; do grep -q "parent-initiative:" "$f" 2>/dev/null; done'

#!/usr/bin/env bash
# swain-progress-log.sh — Append progress entries and synthesize progress sections
#
# Modes:
#   --artifact-id <ID> --entry <text>       Append a dated entry to progress.md
#   --artifact-id <ID> --synthesize         Regenerate ## Progress section from progress.md
#   --digest <path-to-jsonl-entry>          Process a session digest line
#
# SPEC-200: Progress Log and Synthesis

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null)"

# ─── Argument parsing ───

ARTIFACT_ID=""
ENTRY=""
SYNTHESIZE=false
DIGEST_PATH=""

while [[ $# -gt 0 ]]; do
  case "$1" in
    --artifact-id) ARTIFACT_ID="$2"; shift 2 ;;
    --entry) ENTRY="$2"; shift 2 ;;
    --synthesize) SYNTHESIZE=true; shift ;;
    --digest) DIGEST_PATH="$2"; shift 2 ;;
    *) echo "Unknown option: $1" >&2; exit 1 ;;
  esac
done

# ─── Helpers ───

resolve_artifact_dir() {
  local id="$1"
  # Find the directory containing this artifact under docs/
  local dir
  dir=$(find "$REPO_ROOT/docs" -type d -name "*${id}*" 2>/dev/null | head -1)
  if [[ -z "$dir" ]]; then
    echo "ERROR: Could not find artifact directory for $id" >&2
    return 1
  fi
  echo "$dir"
}

resolve_artifact_file() {
  local dir="$1"
  local id="$2"
  # Find the .md file matching the artifact ID in the directory
  local file
  file=$(find "$dir" -maxdepth 1 -name "*${id}*.md" ! -name "progress.md" 2>/dev/null | head -1)
  if [[ -z "$file" ]]; then
    echo "ERROR: Could not find artifact file for $id in $dir" >&2
    return 1
  fi
  echo "$file"
}

append_entry() {
  local artifact_dir="$1"
  local entry_text="$2"
  local progress_file="$artifact_dir/progress.md"
  local today
  today=$(date +%Y-%m-%d)

  if [[ ! -f "$progress_file" ]]; then
    echo "# Progress Log" > "$progress_file"
    echo "" >> "$progress_file"
  fi

  {
    echo "## $today"
    echo ""
    echo "$entry_text"
    echo ""
  } >> "$progress_file"

  echo "Appended entry to $progress_file"
}

synthesize_progress() {
  local artifact_dir="$1"
  local artifact_id="$2"
  local progress_file="$artifact_dir/progress.md"
  local artifact_file

  artifact_file=$(resolve_artifact_file "$artifact_dir" "$artifact_id")

  if [[ ! -f "$progress_file" ]]; then
    echo "No progress.md found in $artifact_dir — nothing to synthesize" >&2
    return 0
  fi

  # Use Python for reliable text manipulation
  uv run python3 -c "
import sys, re

progress_path = sys.argv[1]
artifact_path = sys.argv[2]

# Read progress.md and extract recent entries (last 2-3)
with open(progress_path) as f:
    content = f.read()

# Split into dated sections
sections = re.split(r'^## (\d{4}-\d{2}-\d{2})', content, flags=re.MULTILINE)
# sections[0] is header, then pairs of (date, body)
entries = []
for i in range(1, len(sections) - 1, 2):
    date = sections[i]
    body = sections[i + 1].strip()
    entries.append((date, body))

# Take last 2-3 entries for synthesis
recent = entries[-3:] if len(entries) > 3 else entries
synthesis_lines = []
for date, body in recent:
    # Take first line of each entry as the synthesis line
    first_line = body.split('\n')[0].strip()
    if first_line:
        synthesis_lines.append(f'**{date}:** {first_line}')

synthesis = '\n\n'.join(synthesis_lines) if synthesis_lines else '_No progress entries yet._'

# Read artifact file
with open(artifact_path) as f:
    artifact_content = f.read()

# Find ## Progress section and replace its content
# Section runs from '## Progress' to the next '## ' heading or end of file
progress_pattern = re.compile(
    r'(## Progress\n).*?(?=\n## [^\n]|\Z)',
    re.DOTALL
)

progress_section = f'## Progress\n\n{synthesis}\n'

if progress_pattern.search(artifact_content):
    new_content = progress_pattern.sub(progress_section, artifact_content)
else:
    # Insert after ## Desired Outcomes or ## Goal / Objective
    insert_patterns = [
        r'(## Desired Outcomes\n.*?)(?=\n## )',
        r'(## Goal / Objective\n.*?)(?=\n## )',
    ]
    inserted = False
    for pat in insert_patterns:
        match = re.search(pat, artifact_content, re.DOTALL)
        if match:
            insert_pos = match.end()
            new_content = artifact_content[:insert_pos] + '\n\n' + progress_section + '\n' + artifact_content[insert_pos:]
            inserted = True
            break
    if not inserted:
        # Fallback: append before ## Lifecycle or at end
        lifecycle_match = re.search(r'\n## Lifecycle', artifact_content)
        if lifecycle_match:
            pos = lifecycle_match.start()
            new_content = artifact_content[:pos] + '\n' + progress_section + '\n' + artifact_content[pos:]
        else:
            new_content = artifact_content + '\n\n' + progress_section

with open(artifact_path, 'w') as f:
    f.write(new_content)

print(f'Synthesized progress into {artifact_path}')
" "$progress_file" "$artifact_file"
}

# ─── Digest mode ───

process_digest() {
  local digest_path="$1"

  if [[ ! -f "$digest_path" ]]; then
    echo "ERROR: Digest file not found: $digest_path" >&2
    exit 1
  fi

  uv run python3 -c "
import json, sys, subprocess, os

digest_path = sys.argv[1]
script = sys.argv[2]

with open(digest_path) as f:
    entry = json.loads(f.read().strip())

artifacts = entry.get('artifacts_touched', [])
session_summary = entry.get('session_summary', 'Session work recorded.')

for artifact in artifacts:
    artifact_id = artifact.get('id', '') if isinstance(artifact, dict) else str(artifact)
    summary = artifact.get('summary', session_summary) if isinstance(artifact, dict) else session_summary
    if not artifact_id:
        continue

    # Only update EPICs and Initiatives (container artifacts that track progress)
    if not any(artifact_id.startswith(p) for p in ['EPIC-', 'INITIATIVE-']):
        continue

    result = subprocess.run(
        ['bash', script, '--artifact-id', artifact_id, '--entry', summary],
        capture_output=True, text=True
    )
    if result.returncode != 0:
        print(f'Warning: failed to append entry for {artifact_id}: {result.stderr}', file=sys.stderr)
    else:
        print(result.stdout, end='')

    # Synthesize
    result = subprocess.run(
        ['bash', script, '--artifact-id', artifact_id, '--synthesize'],
        capture_output=True, text=True
    )
    if result.returncode != 0:
        print(f'Warning: failed to synthesize for {artifact_id}: {result.stderr}', file=sys.stderr)
    else:
        print(result.stdout, end='')
" "$digest_path" "${BASH_SOURCE[0]}"
}

# ─── Main dispatch ───

if [[ -n "$DIGEST_PATH" ]]; then
  process_digest "$DIGEST_PATH"
elif [[ -n "$ARTIFACT_ID" ]]; then
  ARTIFACT_DIR=$(resolve_artifact_dir "$ARTIFACT_ID")

  if [[ -n "$ENTRY" ]]; then
    append_entry "$ARTIFACT_DIR" "$ENTRY"
  fi

  if [[ "$SYNTHESIZE" == true ]]; then
    synthesize_progress "$ARTIFACT_DIR" "$ARTIFACT_ID"
  fi

  if [[ -z "$ENTRY" && "$SYNTHESIZE" == false ]]; then
    echo "ERROR: --artifact-id requires --entry and/or --synthesize" >&2
    exit 1
  fi
else
  echo "ERROR: Must provide --artifact-id or --digest" >&2
  exit 1
fi

#!/usr/bin/env bash
# swain-session-archive.sh — Archive session.json for retro reconstruction
# SPEC-248 | EPIC-056
set -uo pipefail

REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
ARCHIVE_DIR="${SWAIN_ARCHIVE_DIR:-$REPO_ROOT/.agents/session-archive}"

_ensure_dir() {
  mkdir -p "$ARCHIVE_DIR"
}

cmd_save() {
  local worktree_path="$1"
  local session_file="$worktree_path/.agents/session.json"

  if [ ! -f "$session_file" ]; then
    echo "No session.json in $worktree_path" >&2
    return 0  # graceful, not an error
  fi

  _ensure_dir

  # Generate session ID from branch name + timestamp
  local branch
  branch="$(git -C "$worktree_path" branch --show-current 2>/dev/null || echo "unknown")"
  local timestamp
  timestamp="$(date +%Y%m%dT%H%M%S)"
  local session_id="${branch//\//-}-${timestamp}"

  cp "$session_file" "$ARCHIVE_DIR/${session_id}.json"
  echo "Archived: $session_id"
}

cmd_get() {
  local session_id="$1"
  local archive_file="$ARCHIVE_DIR/${session_id}.json"
  local archive_gz="$ARCHIVE_DIR/${session_id}.json.gz"

  if [ -f "$archive_file" ]; then
    cat "$archive_file"
    return 0
  elif [ -f "$archive_gz" ]; then
    gzip -dc "$archive_gz"
    return 0
  fi

  echo "Not found: $session_id" >&2
  return 1
}

cmd_find() {
  local artifact_id="$1"
  _ensure_dir

  local found=false
  for f in "$ARCHIVE_DIR"/*.json "$ARCHIVE_DIR"/*.json.gz; do
    [ -f "$f" ] || continue

    local content
    if [[ "$f" == *.gz ]]; then
      content="$(gzip -dc "$f")"
    else
      content="$(cat "$f")"
    fi

    if echo "$content" | grep -q "$artifact_id"; then
      local name
      name="$(basename "$f")"
      echo "$name: $(echo "$content" | grep -o "\"note\":[^,}]*" | head -1)"
      found=true
    fi
  done

  if [ "$found" = false ]; then
    return 0  # empty output, no matches
  fi
}

cmd_compress() {
  _ensure_dir

  local now_epoch
  now_epoch="$(date +%s)"
  local seven_days=$((7 * 86400))

  for f in "$ARCHIVE_DIR"/*.json; do
    [ -f "$f" ] || continue
    # Skip if already has a .gz companion
    [ -f "${f}.gz" ] && continue

    local file_epoch
    file_epoch="$(stat -f %m "$f" 2>/dev/null || stat -c %Y "$f" 2>/dev/null || echo "$now_epoch")"
    local age=$((now_epoch - file_epoch))

    if [ "$age" -gt "$seven_days" ]; then
      gzip "$f"
      echo "Compressed: $(basename "$f")"
    fi
  done
}

# --- Main dispatch ---

cmd="${1:-help}"
shift || true

case "$cmd" in
  save)     cmd_save "$@" ;;
  get)      cmd_get "$@" ;;
  find)     cmd_find "$@" ;;
  compress) cmd_compress ;;
  help)
    echo "Usage: swain-session-archive.sh <command> [args]"
    echo ""
    echo "Commands:"
    echo "  save <worktree-path>     Archive session.json from worktree"
    echo "  get <session-id>         Retrieve archived session"
    echo "  find <artifact-id>       Find sessions touching an artifact"
    echo "  compress                 Gzip archives older than 7 days"
    ;;
  *)
    echo "Unknown command: $cmd" >&2
    exit 1
    ;;
esac

#!/usr/bin/env bash
set +e  # Never fail hard — session bootstrap is a convenience, not a gate

# swain-session-bootstrap.sh — Consolidated session startup
#
# Replaces multi-step agent orchestration (tab naming + worktree detection +
# session.json loading) with a single script call that emits structured JSON.
#
# Usage:
#   swain-session-bootstrap.sh --auto                    # full bootstrap
#   swain-session-bootstrap.sh --path DIR --auto         # resolve from DIR
#   swain-session-bootstrap.sh --skip-worktree --auto    # omit worktree check
#
# Output: JSON to stdout with keys: tab, worktree, session, warnings
# See SPEC-172 for the full contract.

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
TAB_NAME_SCRIPT="$SCRIPT_DIR/swain-tab-name.sh"
BOOKMARK_SCRIPT="$SCRIPT_DIR/swain-bookmark.sh"

# ─── Argument parsing ───
SWAIN_BOOTSTRAP_PATH=""
SKIP_WORKTREE=0
AUTO=0
WARNINGS=()

while [[ $# -gt 0 ]]; do
  case "$1" in
    --path)
      SWAIN_BOOTSTRAP_PATH="$2"
      shift 2
      ;;
    --skip-worktree)
      SKIP_WORKTREE=1
      shift
      ;;
    --auto)
      AUTO=1
      shift
      ;;
    --help|-h)
      echo "Usage: swain-session-bootstrap.sh [--path DIR] [--skip-worktree] --auto"
      echo ""
      echo "  --path DIR         Resolve git context from DIR (default: auto-detect)"
      echo "  --skip-worktree    Omit worktree isolation detection"
      echo "  --auto             Run in non-interactive mode"
      exit 0
      ;;
    *)
      shift
      ;;
  esac
done

# ─── Resolve repo root ───
if [[ -n "$SWAIN_BOOTSTRAP_PATH" ]]; then
  REPO_ROOT="$(git -C "$SWAIN_BOOTSTRAP_PATH" rev-parse --show-toplevel 2>/dev/null || echo "$SWAIN_BOOTSTRAP_PATH")"
else
  REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
fi

# ─── Step 1: Tab naming (tmux only) ───
TAB_RESULT=""
if [[ -n "${TMUX:-}" ]]; then
  if [[ -f "$TAB_NAME_SCRIPT" ]]; then
    TAB_ARGS=()
    [[ -n "$SWAIN_BOOTSTRAP_PATH" ]] && TAB_ARGS+=(--path "$SWAIN_BOOTSTRAP_PATH")
    TAB_ARGS+=(--auto)
    TAB_RESULT=$(bash "$TAB_NAME_SCRIPT" "${TAB_ARGS[@]}" 2>/dev/null)
  else
    WARNINGS+=("tab-name script not found at $TAB_NAME_SCRIPT")
  fi
fi

# ─── Step 2: Worktree detection ───
WT_ISOLATED="false"
WT_PATH=""
WT_BRANCH=""

DETECT_PATH="${SWAIN_BOOTSTRAP_PATH:-$REPO_ROOT}"

if [[ "$SKIP_WORKTREE" -eq 0 ]]; then
  GIT_COMMON=$(git -C "$DETECT_PATH" rev-parse --git-common-dir 2>/dev/null)
  GIT_DIR=$(git -C "$DETECT_PATH" rev-parse --git-dir 2>/dev/null)

  if [[ -n "$GIT_COMMON" && -n "$GIT_DIR" && "$GIT_COMMON" != "$GIT_DIR" ]]; then
    WT_ISOLATED="true"
    WT_PATH="$DETECT_PATH"
    WT_BRANCH=$(git -C "$DETECT_PATH" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
  else
    WT_ISOLATED="false"
    WT_BRANCH=$(git -C "$DETECT_PATH" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
  fi
fi

# ─── Step 3: Session.json loading ───
SESSION_FILE="$REPO_ROOT/.agents/session.json"
SESSION_FOCUS=""
SESSION_BOOKMARK=""
SESSION_LAST_BRANCH=""

if [[ -f "$SESSION_FILE" ]] && command -v jq &>/dev/null; then
  SESSION_FOCUS=$(jq -r '.focus_lane // empty' "$SESSION_FILE" 2>/dev/null)
  SESSION_BOOKMARK=$(jq -r '.bookmark.note // empty' "$SESSION_FILE" 2>/dev/null)
  SESSION_LAST_BRANCH=$(jq -r '.lastBranch // empty' "$SESSION_FILE" 2>/dev/null)

  # Update lastBranch to current
  CURRENT_BRANCH=$(git -C "$DETECT_PATH" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
  if [[ -n "$CURRENT_BRANCH" ]]; then
    jq --arg branch "$CURRENT_BRANCH" '.lastBranch = $branch' \
      "$SESSION_FILE" > "${SESSION_FILE}.tmp" 2>/dev/null \
      && mv "${SESSION_FILE}.tmp" "$SESSION_FILE" 2>/dev/null
  fi
elif [[ ! -f "$SESSION_FILE" ]]; then
  # Check for old global location and migrate
  _OLD_SLUG=$(echo "$REPO_ROOT" | tr '/' '-')
  _OLD_FILE="$HOME/.claude/projects/${_OLD_SLUG}/memory/session.json"
  if [[ -f "$_OLD_FILE" ]]; then
    mkdir -p "$(dirname "$SESSION_FILE")" 2>/dev/null
    cp "$_OLD_FILE" "$SESSION_FILE" 2>/dev/null
    WARNINGS+=("migrated session.json from old global location")
    # Re-read after migration
    if command -v jq &>/dev/null; then
      SESSION_FOCUS=$(jq -r '.focus_lane // empty' "$SESSION_FILE" 2>/dev/null)
      SESSION_BOOKMARK=$(jq -r '.bookmark.note // empty' "$SESSION_FILE" 2>/dev/null)
      SESSION_LAST_BRANCH=$(jq -r '.lastBranch // empty' "$SESSION_FILE" 2>/dev/null)
    fi
  fi
fi

# ─── Build JSON output ───
build_fallback_json() {
  # Minimal JSON construction without jq
  local out='{"worktree":{"isolated":'
  out+="$WT_ISOLATED"
  out+='},"session":{},"warnings":['
  local first=1
  for w in "${WARNINGS[@]}"; do
    [[ $first -eq 0 ]] && out+=","
    # Escape quotes in warning text
    out+="\"${w//\"/\\\"}\""
    first=0
  done
  out+=']}'
  echo "$out"
}

# Use jq if available and functional, fall back to manual construction
OUTPUT=""
if command -v jq &>/dev/null && jq -n '{}' &>/dev/null; then
  # Build warnings array
  WARNINGS_JSON="[]"
  for w in "${WARNINGS[@]}"; do
    WARNINGS_JSON=$(echo "$WARNINGS_JSON" | jq --arg w "$w" '. + [$w]')
  done

  OUTPUT=$(jq -n \
    --arg tab "$TAB_RESULT" \
    --arg wt_isolated "$WT_ISOLATED" \
    --arg wt_path "$WT_PATH" \
    --arg wt_branch "$WT_BRANCH" \
    --arg s_focus "$SESSION_FOCUS" \
    --arg s_bookmark "$SESSION_BOOKMARK" \
    --arg s_last_branch "$SESSION_LAST_BRANCH" \
    --argjson warnings "$WARNINGS_JSON" \
    '{
      worktree: {
        isolated: ($wt_isolated == "true"),
        path: (if $wt_path == "" then null else $wt_path end),
        branch: (if $wt_branch == "" then null else $wt_branch end)
      },
      session: {
        focus: (if $s_focus == "" then null else $s_focus end),
        bookmark: (if $s_bookmark == "" then null else $s_bookmark end),
        lastBranch: (if $s_last_branch == "" then null else $s_last_branch end)
      },
      warnings: $warnings
    }
    | if $tab != "" then .tab = $tab else . end' 2>/dev/null)
fi

# If jq failed or wasn't available, use the fallback
if [[ -z "$OUTPUT" ]]; then
  WARNINGS+=("jq not available — session fields may be incomplete")
  OUTPUT=$(build_fallback_json)
fi

echo "$OUTPUT"

#!/usr/bin/env bash
# swain-session-check.sh — Lightweight session detection for skill preambles
# SPEC-121: Session Detection Hooks Across All Skills
#
# Reads .agents/session-state.json and emits a JSON result:
#   {"status": "active|stale|closed|none", "focus_lane": "...", "session_id": "..."}
#
# Exit codes:
#   0 — session is active
#   1 — session is stale, closed, or missing (skill should prompt)
#
# Options:
#   --state-file <path>   Override state file location
#   --threshold <seconds> Staleness threshold (default: 3600 = 1 hour)
set -uo pipefail

STATE_FILE="${SWAIN_SESSION_STATE:-.agents/session-state.json}"
THRESHOLD=3600

while [ $# -gt 0 ]; do
  case "$1" in
    --state-file)  STATE_FILE="$2"; shift 2 ;;
    --threshold)   THRESHOLD="$2"; shift 2 ;;
    *)             shift ;;
  esac
done

if [ ! -f "$STATE_FILE" ]; then
  echo '{"status": "none", "focus_lane": null, "session_id": null}'
  exit 1
fi

python3 -c "
import json, sys
from datetime import datetime, timezone

with open('$STATE_FILE') as f:
    state = json.load(f)

phase = state.get('phase', 'unknown')
focus = state.get('focus_lane')
sid = state.get('session_id')
activity = state.get('last_activity_time') or state.get('start_time', '')

result = {'focus_lane': focus, 'session_id': sid}

if phase == 'closed':
    result['status'] = 'closed'
    json.dump(result, sys.stdout)
    sys.exit(1)
elif phase == 'active':
    # Check staleness
    try:
        activity_dt = datetime.fromisoformat(activity.replace('Z', '+00:00'))
        age = (datetime.now(timezone.utc) - activity_dt).total_seconds()
        if age > $THRESHOLD:
            result['status'] = 'stale'
            json.dump(result, sys.stdout)
            sys.exit(1)
        else:
            result['status'] = 'active'
            json.dump(result, sys.stdout)
            sys.exit(0)
    except (ValueError, TypeError):
        result['status'] = 'stale'
        json.dump(result, sys.stdout)
        sys.exit(1)
else:
    result['status'] = 'none'
    json.dump(result, sys.stdout)
    sys.exit(1)
"

#!/usr/bin/env bash
# swain-session-digest.sh — Generate a structured JSONL digest of a session
# Part of SPEC-199: Session Digest Auto-Generation
#
# Usage:
#   swain-session-digest.sh --session-id <ID> --start-time <ISO8601> [--focus <ARTIFACT-ID>] [--repo-root <PATH>] [--output <PATH>]
#
# Exit codes:
#   0 — digest written successfully
#   1 — error (missing required args, git not available, etc.)

set -euo pipefail

SESSION_ID=""
START_TIME=""
FOCUS=""
REPO_ROOT=""
OUTPUT_FILE=""

# Parse arguments
while [[ $# -gt 0 ]]; do
  case "$1" in
    --session-id)
      SESSION_ID="$2"
      shift 2
      ;;
    --start-time)
      START_TIME="$2"
      shift 2
      ;;
    --focus)
      FOCUS="$2"
      shift 2
      ;;
    --repo-root)
      REPO_ROOT="$2"
      shift 2
      ;;
    --output)
      OUTPUT_FILE="$2"
      shift 2
      ;;
    *)
      echo "Unknown argument: $1" >&2
      exit 1
      ;;
  esac
done

# Validate required args
if [[ -z "$SESSION_ID" ]]; then
  echo "Error: --session-id is required" >&2
  exit 1
fi
if [[ -z "$START_TIME" ]]; then
  echo "Error: --start-time is required" >&2
  exit 1
fi

# Defaults
if [[ -z "$REPO_ROOT" ]]; then
  REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null)" || {
    echo "Error: not in a git repository and --repo-root not specified" >&2
    exit 1
  }
fi

if [[ -z "$OUTPUT_FILE" ]]; then
  OUTPUT_FILE="$REPO_ROOT/.agents/session-log.jsonl"
fi

# Ensure output directory exists
mkdir -p "$(dirname "$OUTPUT_FILE")"

# --- Evidence gathering ---

# 1. Git commits since start-time
GIT_LOG=$(git -C "$REPO_ROOT" log --after="$START_TIME" --oneline --no-decorate 2>/dev/null || echo "")

# 2. Ticket completions — scan .tickets/ for closed tickets updated after start-time
TICKETS_DIR="$REPO_ROOT/.tickets"
CLOSED_TICKETS=""
if [[ -d "$TICKETS_DIR" ]]; then
  for ticket_file in "$TICKETS_DIR"/*.md; do
    [[ -f "$ticket_file" ]] || continue
    # Check if status is closed
    status=$(sed -n '/^---$/,/^---$/{ /^status:/{ s/^status: *//; p; q; } }' "$ticket_file" 2>/dev/null || echo "")
    if [[ "$status" == "closed" ]]; then
      # Check if file was modified after start-time (use file mtime as proxy)
      # Extract tags for spec references
      tags=$(sed -n '/^---$/,/^---$/{ /^tags:/{ s/^tags: *\[//; s/\].*//; p; q; } }' "$ticket_file" 2>/dev/null || echo "")
      CLOSED_TICKETS="${CLOSED_TICKETS}${tags}"$'\n'
    fi
  done
fi

# 3. Pass everything to Python for JSON construction and output
export SESSION_ID START_TIME FOCUS GIT_LOG CLOSED_TICKETS OUTPUT_FILE REPO_ROOT
uv run python3 -c "
import json
import sys
import os
from datetime import datetime, timezone

session_id = os.environ['SESSION_ID']
start_time = os.environ['START_TIME']
focus = os.environ.get('FOCUS', '')
git_log = os.environ.get('GIT_LOG', '')
output_file = os.environ['OUTPUT_FILE']

# Parse git log lines
commits_lines = [line.strip() for line in git_log.strip().split('\n') if line.strip()]
commit_count = len(commits_lines)

# Extract artifact references and actions from commit messages
# Commit format: <hash> <prefix>(<scope>): <message>  OR  <hash> <prefix>: <message>
artifact_pattern_ids = set()
artifacts_touched = []
seen_ids = set()

import re

# Map conventional-commit prefixes to actions
prefix_map = {
    'feat': 'implemented',
    'fix': 'fixed',
    'docs': 'documented',
    'close': 'completed',
    'test': 'tested',
    'research': 'researched',
    'refactor': 'refactored',
    'chore': 'maintained',
    'ci': 'maintained',
    'style': 'maintained',
    'perf': 'optimized',
}

# Pattern for artifact IDs
artifact_re = re.compile(r'(SPEC|EPIC|INITIATIVE|ADR|SPIKE|VISION|PERSONA|RUNBOOK|DESIGN|JOURNEY)-(\d+)')
# Pattern for conventional commit prefix
prefix_re = re.compile(r'^[a-f0-9]+ (\w+)(?:\([^)]*\))?[!]?:\s*(.*)')

for line in commits_lines:
    # Find artifact IDs in this commit line
    ids_in_line = artifact_re.findall(line)
    if not ids_in_line:
        continue

    # Parse the commit prefix
    prefix_match = prefix_re.match(line)
    action = 'touched'
    summary = line
    if prefix_match:
        prefix = prefix_match.group(1).lower()
        action = prefix_map.get(prefix, 'touched')
        summary = prefix_match.group(2).strip()

    for artifact_type, artifact_num in ids_in_line:
        artifact_id = f'{artifact_type}-{artifact_num}'
        if artifact_id in seen_ids:
            continue
        seen_ids.add(artifact_id)

        # Try to read the artifact title from disk
        title = ''
        repo_root = os.environ['REPO_ROOT']
        # Map artifact type to directory
        type_dir_map = {
            'SPEC': 'spec', 'EPIC': 'epic', 'INITIATIVE': 'initiative',
            'ADR': 'adr', 'SPIKE': 'spike', 'VISION': 'vision',
            'PERSONA': 'persona', 'RUNBOOK': 'runbook', 'DESIGN': 'design',
            'JOURNEY': 'journey',
        }
        type_dir = type_dir_map.get(artifact_type, artifact_type.lower())
        # Search common locations
        for subdir in ['Active', 'Complete', 'Proposed', 'InProgress', 'NeedsManualTest', 'Ready', 'Adopted', 'Retired', 'Superseded', 'Abandoned', 'Draft', '']:
            candidate = os.path.join(repo_root, 'docs', type_dir, subdir)
            if not os.path.isdir(candidate):
                continue
            for fname in os.listdir(candidate):
                if artifact_id not in fname:
                    continue
                fpath = os.path.join(candidate, fname)
                # Handle subdirectory layout: (SPEC-194)-Title/(SPEC-194)-Title.md
                if os.path.isdir(fpath):
                    for inner in os.listdir(fpath):
                        if artifact_id in inner and inner.endswith('.md'):
                            fpath = os.path.join(fpath, inner)
                            break
                    else:
                        continue
                elif not fname.endswith('.md'):
                    continue
                try:
                    with open(fpath) as f:
                        in_frontmatter = False
                        for fline in f:
                            fline = fline.rstrip()
                            if fline == '---':
                                if not in_frontmatter:
                                    in_frontmatter = True
                                    continue
                                else:
                                    break
                            if in_frontmatter and fline.startswith('title:'):
                                title = fline[len('title:'):].strip().strip('\"').strip(\"'\")
                                break
                except (IOError, OSError):
                    pass
                break
            if title:
                break

        artifacts_touched.append({
            'id': artifact_id,
            'title': title,
            'action': action,
            'summary': summary,
        })

# Count tasks closed (from ticket tags referencing specs)
closed_tickets_raw = os.environ.get('CLOSED_TICKETS', '')
tasks_closed = len([line for line in closed_tickets_raw.strip().split('\n') if line.strip()])

# Build session summary
if artifacts_touched:
    summaries = [a['summary'] for a in artifacts_touched]
    session_summary = '; '.join(summaries[:5])
    if len(summaries) > 5:
        session_summary += f' (and {len(summaries) - 5} more)'
elif commit_count > 0:
    session_summary = f'{commit_count} commits with no artifact references.'
else:
    session_summary = 'Empty session — no commits recorded.'

# Build the digest entry
entry = {
    'session_id': session_id,
    'timestamp': datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ'),
    'focus_lane': focus if focus else None,
    'artifacts_touched': artifacts_touched,
    'commits': commit_count,
    'tasks_closed': tasks_closed,
    'session_summary': session_summary,
}

# Append to output file
with open(output_file, 'a') as f:
    f.write(json.dumps(entry, ensure_ascii=False) + '\n')
" <<< "" || {
  echo "Error: Python JSON construction failed" >&2
  exit 1
}

echo "Digest written to $OUTPUT_FILE" >&2
exit 0

#!/usr/bin/env bash
# swain-session-greeting.sh — SPEC-194: Fast-path session greeting
#
# Produces immediate session context without expensive operations.
# Calls the preflight script for all read-only state, then applies
# lightweight mutations (tab naming, lock cleanup, .agents dir).
# Does NOT invoke specgraph, GitHub API, or the full status dashboard.
#
# Usage:
#   swain-session-greeting.sh              # human-readable output
#   swain-session-greeting.sh --json       # structured JSON
#   swain-session-greeting.sh --path DIR   # resolve from DIR
#
# Output (human-readable):
#   Branch, dirty state, bookmark, focus lane, warnings
#
# Output (JSON):
#   { greeting: true, branch, dirty, bookmark, focus, purpose, warnings[] }
#
# Session purpose (SPEC-297):
#   If $SWAIN_PURPOSE is set and the session has no existing bookmark,
#   the purpose text is written to the bookmark deterministically and
#   surfaced as the `purpose` JSON field. Agent skills consume this
#   field; they no longer parse the initial prompt themselves.

set +e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PREFLIGHT_SCRIPT="$SCRIPT_DIR/swain-session-preflight.sh"
TAB_NAME_SCRIPT="$SCRIPT_DIR/swain-tab-name.sh"

JSON_MODE=0
EXTRA_PATH=""

while [[ $# -gt 0 ]]; do
  case "$1" in
    --json) JSON_MODE=1; shift ;;
    --path) EXTRA_PATH="$2"; shift 2 ;;
    *) shift ;;
  esac
done

REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"

# ─── Step 1: Run preflight (single script, no subprocess chain) ───
PREFLIGHT_ARGS=(--repo-root "$REPO_ROOT")
[[ -n "$EXTRA_PATH" ]] && PREFLIGHT_ARGS+=(--path "$EXTRA_PATH")

PREFLIGHT_JSON=""
if [[ -f "$PREFLIGHT_SCRIPT" ]]; then
  PREFLIGHT_JSON=$(bash "$PREFLIGHT_SCRIPT" "${PREFLIGHT_ARGS[@]}" 2>/dev/null)
fi

# Parse preflight output
if command -v jq &>/dev/null && [[ -n "$PREFLIGHT_JSON" ]]; then
  BRANCH=$(echo "$PREFLIGHT_JSON" | jq -r '.git.branch // "unknown"' 2>/dev/null)
  DIRTY=$(echo "$PREFLIGHT_JSON" | jq -r 'if .git.dirty then "true" else "false" end' 2>/dev/null)
  ISOLATED=$(echo "$PREFLIGHT_JSON" | jq -r 'if .git.worktree.isolated then "true" else "false" end' 2>/dev/null)
  BOOKMARK=$(echo "$PREFLIGHT_JSON" | jq -r '.session.bookmark // empty' 2>/dev/null)
  FOCUS=$(echo "$PREFLIGHT_JSON" | jq -r '.session.focus // empty' 2>/dev/null)
  TAB_NAME=$(echo "$PREFLIGHT_JSON" | jq -r '.tmux.tab_name // empty' 2>/dev/null)
  # Collect preflight warnings (structured keys like "stale_tk_locks:3")
  PREFLIGHT_WARNINGS=$(echo "$PREFLIGHT_JSON" | jq -r '.warnings[]? // empty' 2>/dev/null)
else
  BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
  DIRTY="false"
  [[ -n "$(git status --porcelain 2>/dev/null | head -1)" ]] && DIRTY="true"
  ISOLATED="false"
  BOOKMARK=""
  FOCUS=""
  TAB_NAME=""
  PREFLIGHT_WARNINGS=""
fi

# ─── Step 2: Apply mutations ───
WARNINGS=()

# Tab naming (tmux only) — uses the precomputed name, avoids full tab-name.sh resolution
if [[ -n "${TMUX:-}" && -n "$TAB_NAME" && -f "$TAB_NAME_SCRIPT" ]]; then
  TAB_ARGS=("$TAB_NAME")
  [[ -n "$EXTRA_PATH" ]] && TAB_ARGS=(--path "$EXTRA_PATH" --auto)
  TAB=$(bash "$TAB_NAME_SCRIPT" "${TAB_ARGS[@]}" 2>/dev/null)
else
  TAB="$TAB_NAME"
fi

# Clean stale tk locks
for w in $PREFLIGHT_WARNINGS; do
  case "$w" in
    stale_tk_locks:*)
      count="${w#stale_tk_locks:}"
      find "$REPO_ROOT/.tickets/.locks" -type d -mmin +60 -exec rm -rf {} + 2>/dev/null
      WARNINGS+=("cleaned $count stale tk lock(s)")
      ;;
    stale_git_index_lock)
      WARNINGS+=("stale git index.lock detected — may need manual removal")
      ;;
    missing_agents_dir)
      mkdir -p "$REPO_ROOT/.agents"
      WARNINGS+=("created missing .agents/ directory")
      ;;
    *)
      WARNINGS+=("$w")
      ;;
  esac
done

# Update lastBranch in session.json
SESSION_FILE="$REPO_ROOT/.agents/session.json"
if [[ -f "$SESSION_FILE" ]] && command -v jq &>/dev/null; then
  jq --arg branch "$BRANCH" '.lastBranch = $branch' \
    "$SESSION_FILE" > "${SESSION_FILE}.tmp" 2>/dev/null \
    && mv "${SESSION_FILE}.tmp" "$SESSION_FILE" 2>/dev/null
fi

# SPEC-297: Session purpose capture.
# If SWAIN_PURPOSE is set and no bookmark exists yet, write it and re-read.
PURPOSE="${SWAIN_PURPOSE:-}"
if [[ -n "$PURPOSE" && -z "$BOOKMARK" ]]; then
  BOOKMARK_SCRIPT="$SCRIPT_DIR/swain-bookmark.sh"
  if [[ -f "$BOOKMARK_SCRIPT" ]]; then
    SWAIN_REPO_ROOT="$REPO_ROOT" bash "$BOOKMARK_SCRIPT" "$PURPOSE" >/dev/null 2>&1
    BOOKMARK="$PURPOSE"
  fi
fi

# ─── Step 3: Output ───
if [[ "$JSON_MODE" -eq 1 ]]; then
  WARNINGS_JSON="[]"
  if command -v jq &>/dev/null; then
    for w in "${WARNINGS[@]}"; do
      WARNINGS_JSON=$(echo "$WARNINGS_JSON" | jq --arg w "$w" '. + [$w]')
    done
  fi

  if command -v jq &>/dev/null; then
    jq -n \
      --arg branch "$BRANCH" \
      --arg dirty "$DIRTY" \
      --arg bookmark "$BOOKMARK" \
      --arg focus "$FOCUS" \
      --arg isolated "$ISOLATED" \
      --arg tab "$TAB" \
      --arg purpose "$PURPOSE" \
      --argjson warnings "$WARNINGS_JSON" \
      '{
        greeting: true,
        branch: $branch,
        dirty: ($dirty == "true"),
        isolated: ($isolated == "true"),
        bookmark: (if $bookmark == "" then null else $bookmark end),
        focus: (if $focus == "" then null else $focus end),
        purpose: (if $purpose == "" then null else $purpose end),
        tab: (if $tab == "" then null else $tab end),
        warnings: $warnings
      }'
  else
    echo "{\"greeting\":true,\"branch\":\"$BRANCH\",\"dirty\":$DIRTY}"
  fi
else
  state="clean"
  [[ "$DIRTY" == "true" ]] && state="dirty"
  isolation=""
  [[ "$ISOLATED" == "true" ]] && isolation=" (worktree)"

  echo "Branch: $BRANCH${isolation} [$state]"

  if [[ -n "$PURPOSE" ]]; then
    echo "Purpose: $PURPOSE"
  fi

  if [[ -n "$BOOKMARK" ]]; then
    echo "Bookmark: $BOOKMARK"
  fi

  if [[ -n "$FOCUS" ]]; then
    echo "Focus: $FOCUS"
  fi

  for w in "${WARNINGS[@]}"; do
    echo "Warning: $w"
  done
fi

#!/usr/bin/env bash
# swain-session-preflight.sh — read-only session state scanner
#
# Consolidates all session startup reads into a single script.
# Replaces the subprocess chain: greeting → bootstrap → tab-name.
# This script NEVER mutates state (no tab renames, no file writes,
# no lock cleanup). The caller applies mutations using the JSON output.
#
# Usage: bash swain-session-preflight.sh [--repo-root /path] [--path /dir]
#
# JSON schema (all keys present, some may be null on error):
#
#   git.repo_root          string  — resolved repository root
#   git.branch             string  — current branch name
#   git.dirty              bool    — uncommitted changes present
#   git.worktree.isolated  bool    — running inside a linked worktree
#   git.worktree.path      string  — worktree path (null if not isolated)
#
#   tmux.active            bool    — running inside a tmux session
#   tmux.tab_format        string  — tab name format from settings
#   tmux.tab_name          string  — computed tab name (not applied)
#
#   session.focus          string  — focus lane from session.json
#   session.bookmark       string  — bookmark note from session.json
#   session.last_branch    string  — last branch from session.json
#
#   prev_session.exists    bool    — session-state.json found
#   prev_session.status    string  — "active" | "stale" | "closed" | "none"
#   prev_session.session_id string — session identifier
#   prev_session.focus_lane string — focus lane from state
#   prev_session.phase     string  — lifecycle phase
#   prev_session.start_time string — ISO timestamp
#   prev_session.end_time  string  — ISO timestamp (null if active)
#   prev_session.decisions_made int — count
#   prev_session.walkaway  string  — walk-away note (null if none)
#
#   warnings               array   — preflight warnings (read-only observations)
#
# Exit: always 0 (partial results on individual check failures)

set -euo pipefail

REPO_ROOT=""
DETECT_PATH=""

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

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

if [ -z "$DETECT_PATH" ]; then
  DETECT_PATH="$REPO_ROOT"
fi

# --- Collector variables ---

WARNINGS_RAW=""
add_warning() {
  WARNINGS_RAW="${WARNINGS_RAW}${1}
"
}

# --- Git state ---
check_git() {
  GIT_BRANCH=$(git -C "$DETECT_PATH" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
  GIT_DIRTY=false
  if [ -n "$(git -C "$DETECT_PATH" status --porcelain 2>/dev/null | head -1)" ]; then
    GIT_DIRTY=true
  fi

  GIT_WT_ISOLATED=false
  GIT_WT_PATH=""
  GIT_COMMON=$(git -C "$DETECT_PATH" rev-parse --git-common-dir 2>/dev/null || true)
  GIT_DIR=$(git -C "$DETECT_PATH" rev-parse --git-dir 2>/dev/null || true)
  if [ -n "$GIT_COMMON" ] && [ -n "$GIT_DIR" ] && [ "$GIT_COMMON" != "$GIT_DIR" ]; then
    GIT_WT_ISOLATED=true
    GIT_WT_PATH="$DETECT_PATH"
  fi
}

# --- Tmux state (read-only — no renames) ---
check_tmux() {
  TMUX_ACTIVE=false
  TMUX_TAB_FORMAT=""
  TMUX_TAB_NAME=""

  if [ -n "${TMUX:-}" ]; then
    TMUX_ACTIVE=true
  fi

  # Read tab format from settings (project, then user)
  SETTINGS_PROJECT="$REPO_ROOT/swain.settings.json"
  SETTINGS_USER="${XDG_CONFIG_HOME:-$HOME/.config}/swain/settings.json"
  TMUX_TAB_FORMAT='{project} @ {branch}'

  if [ -f "$SETTINGS_USER" ] && command -v jq &>/dev/null; then
    val=$(jq -r '.terminal.tabNameFormat // empty' "$SETTINGS_USER" 2>/dev/null || true)
    [ -n "$val" ] && TMUX_TAB_FORMAT="$val"
  fi
  if [ -f "$SETTINGS_PROJECT" ] && command -v jq &>/dev/null; then
    val=$(jq -r '.terminal.tabNameFormat // empty' "$SETTINGS_PROJECT" 2>/dev/null || true)
    [ -n "$val" ] && TMUX_TAB_FORMAT="$val"
  fi

  # Compute tab name from git context (same logic as tab-name.sh auto_title)
  local common_dir repo_root project
  common_dir=$(git -C "$DETECT_PATH" rev-parse --git-common-dir 2>/dev/null || true)
  if [ -n "$common_dir" ]; then
    repo_root=$(cd "$DETECT_PATH" && cd "$common_dir/.." && pwd 2>/dev/null || true)
  fi
  project=$(basename "${repo_root:-unknown}")

  TMUX_TAB_NAME="${TMUX_TAB_FORMAT//\{project\}/$project}"
  TMUX_TAB_NAME="${TMUX_TAB_NAME//\{branch\}/$GIT_BRANCH}"
}

# --- Session.json (bookmark, focus, last branch) ---
check_session_json() {
  SESSION_FOCUS=""
  SESSION_BOOKMARK=""
  SESSION_LAST_BRANCH=""

  local session_file="$REPO_ROOT/.agents/session.json"

  if [ -f "$session_file" ] && command -v jq &>/dev/null; then
    SESSION_FOCUS=$(jq -r '.focus_lane // empty' "$session_file" 2>/dev/null || true)
    SESSION_BOOKMARK=$(jq -r '.bookmark.note // empty' "$session_file" 2>/dev/null || true)
    SESSION_LAST_BRANCH=$(jq -r '.lastBranch // empty' "$session_file" 2>/dev/null || true)
  fi
}

# --- Session state (previous session resume context) ---
check_session_state() {
  PREV_EXISTS=false
  PREV_STATUS="none"
  PREV_SESSION_ID=""
  PREV_FOCUS_LANE=""
  PREV_PHASE=""
  PREV_START_TIME=""
  PREV_END_TIME=""
  PREV_DECISIONS=0
  PREV_WALKAWAY=""

  local state_file="${SWAIN_SESSION_STATE:-$REPO_ROOT/.agents/session-state.json}"

  if [ -f "$state_file" ]; then
    PREV_EXISTS=true
    # Extract all fields in one python3 call
    eval "$(python3 -c "
import json, sys
from datetime import datetime, timezone

with open('$state_file') as f:
    state = json.load(f)

phase = state.get('phase', 'unknown')
focus = state.get('focus_lane') or ''
sid = state.get('session_id') or ''
activity = state.get('last_activity_time') or state.get('start_time', '')
start = state.get('start_time', '')
end = state.get('end_time') or ''
decisions = state.get('decisions_made', 0)
walkaway = state.get('walkaway') or ''

status = 'none'
if phase == 'closed':
    status = 'closed'
elif phase == 'active':
    try:
        activity_dt = datetime.fromisoformat(activity.replace('Z', '+00:00'))
        age = (datetime.now(timezone.utc) - activity_dt).total_seconds()
        status = 'stale' if age > 3600 else 'active'
    except (ValueError, TypeError):
        status = 'stale'

# Shell-safe quoting via repr
def q(s):
    return s.replace(\"'\", \"'\\\"'\\\"'\")

print(f\"PREV_STATUS='{q(status)}'\")
print(f\"PREV_SESSION_ID='{q(sid)}'\")
print(f\"PREV_FOCUS_LANE='{q(focus)}'\")
print(f\"PREV_PHASE='{q(phase)}'\")
print(f\"PREV_START_TIME='{q(start)}'\")
print(f\"PREV_END_TIME='{q(end)}'\")
print(f\"PREV_DECISIONS={decisions}\")
print(f\"PREV_WALKAWAY='{q(walkaway)}'\")
" 2>/dev/null)" || true
  fi
}

# --- Preflight warnings (read-only observations) ---
check_warnings() {
  # Stale tk locks (report only — don't clean)
  if [ -d "$REPO_ROOT/.tickets/.locks" ]; then
    stale_count=$(find "$REPO_ROOT/.tickets/.locks" -type d -mmin +60 2>/dev/null | wc -l | tr -d ' ')
    if [ "$stale_count" -gt 0 ]; then
      add_warning "stale_tk_locks:$stale_count"
    fi
  fi

  # Stale git index.lock
  if [ -f "$REPO_ROOT/.git/index.lock" ]; then
    add_warning "stale_git_index_lock"
  fi

  # Missing .agents directory
  if [ ! -d "$REPO_ROOT/.agents" ]; then
    add_warning "missing_agents_dir"
  fi
}

# --- Run all checks ---
check_git || true
check_tmux || true
check_session_json || true
check_session_state || true
check_warnings || 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 []

data = {
    'git': {
        'repo_root': sys.argv[1],
        'branch': sys.argv[2] or 'unknown',
        'dirty': to_bool(sys.argv[3]),
        'worktree': {
            'isolated': to_bool(sys.argv[4]),
            'path': to_str_or_null(sys.argv[5]),
        },
    },
    'tmux': {
        'active': to_bool(sys.argv[6]),
        'tab_format': sys.argv[7],
        'tab_name': sys.argv[8],
    },
    'session': {
        'focus': to_str_or_null(sys.argv[9]),
        'bookmark': to_str_or_null(sys.argv[10]),
        'last_branch': to_str_or_null(sys.argv[11]),
    },
    'prev_session': {
        'exists': to_bool(sys.argv[12]),
        'status': sys.argv[13],
        'session_id': to_str_or_null(sys.argv[14]),
        'focus_lane': to_str_or_null(sys.argv[15]),
        'phase': to_str_or_null(sys.argv[16]),
        'start_time': to_str_or_null(sys.argv[17]),
        'end_time': to_str_or_null(sys.argv[18]),
        'decisions_made': to_int(sys.argv[19]),
        'walkaway': to_str_or_null(sys.argv[20]),
    },
    'warnings': to_list(sys.argv[21]),
}

json.dump(data, sys.stdout, indent=2)
print()
" \
  "$REPO_ROOT" "$GIT_BRANCH" "$GIT_DIRTY" \
  "$GIT_WT_ISOLATED" "$GIT_WT_PATH" \
  "$TMUX_ACTIVE" "$TMUX_TAB_FORMAT" "$TMUX_TAB_NAME" \
  "$SESSION_FOCUS" "$SESSION_BOOKMARK" "$SESSION_LAST_BRANCH" \
  "$PREV_EXISTS" "$PREV_STATUS" "$PREV_SESSION_ID" "$PREV_FOCUS_LANE" \
  "$PREV_PHASE" "$PREV_START_TIME" "$PREV_END_TIME" "$PREV_DECISIONS" \
  "$PREV_WALKAWAY" \
  "$WARNINGS_RAW"

#!/usr/bin/env bash
# swain-session-state.sh — Session lifecycle state management
# SPEC-119: Session Lifecycle in swain-session
#
# Commands:
#   init            Create a new session state
#   record-decision Record a decision made during the session
#   close           Close the session with a walk-away signal
#   resume          Read previous session state and emit resume context
#   show            Display current session state
#
# All commands accept --state-file <path> to override the default location.
set -uo pipefail

# Defaults
STATE_FILE="${SWAIN_SESSION_STATE:-.agents/session-state.json}"
SESSION_ROADMAP=""
REPO_ROOT=""
FOCUS=""
BUDGET=5
WALKAWAY=""
NOTE=""

usage() {
  echo "usage: swain-session-state.sh <command> [options]"
  echo ""
  echo "Commands: init, record-decision, close, resume, show"
  echo ""
  echo "Common options:"
  echo "  --state-file <path>      Override state file location"
  echo ""
  echo "init options:"
  echo "  --focus <ID>             Focus lane (vision/initiative ID)"
  echo "  --budget <N>             Decision budget (default: 5)"
  echo "  --session-roadmap <path> Path for SESSION-ROADMAP.md"
  echo "  --repo-root <path>       Repository root for chart.sh"
  echo ""
  echo "record-decision options:"
  echo "  --note <text>            Decision description"
  echo ""
  echo "close options:"
  echo "  --walkaway <text>        Walk-away signal text"
  echo "  --session-roadmap <path> Path to SESSION-ROADMAP.md to finalize"
}

# Parse command
COMMAND="${1:-}"
shift 2>/dev/null || true

if [ -z "$COMMAND" ]; then
  usage
  exit 1
fi

# Parse options
while [ $# -gt 0 ]; do
  case "$1" in
    --state-file)   STATE_FILE="$2"; shift 2 ;;
    --focus)        FOCUS="$2"; shift 2 ;;
    --budget)       BUDGET="$2"; shift 2 ;;
    --walkaway)     WALKAWAY="$2"; shift 2 ;;
    --note)         NOTE="$2"; shift 2 ;;
    --session-roadmap) SESSION_ROADMAP="$2"; shift 2 ;;
    --repo-root)    REPO_ROOT="$2"; shift 2 ;;
    -h|--help)      usage; exit 0 ;;
    *)              echo "Unknown option: $1" >&2; exit 1 ;;
  esac
done

# Generate a short session ID (timestamp + random suffix)
generate_session_id() {
  local ts
  ts=$(date +%Y%m%d-%H%M%S)
  local suffix
  suffix=$(head -c 4 /dev/urandom | od -An -tx1 | tr -d ' \n' | head -c 4)
  echo "session-${ts}-${suffix}"
}

# ISO 8601 timestamp
now_iso() {
  date -u +"%Y-%m-%dT%H:%M:%SZ"
}

cmd_init() {
  local session_id
  session_id=$(generate_session_id)
  local start_time
  start_time=$(now_iso)
  local last_activity_time
  last_activity_time="$start_time"

  # Ensure directory exists
  mkdir -p "$(dirname "$STATE_FILE")"

  # Write initial state
  python3 -c "
import json
state = {
    'session_id': '$session_id',
    'focus_lane': '$FOCUS',
    'phase': 'active',
    'start_time': '$start_time',
    'last_activity_time': '$last_activity_time',
    'end_time': None,
    'decision_budget': $BUDGET,
    'decisions_made': 0,
    'decisions': [],
    'walkaway': None
}
with open('$STATE_FILE', 'w') as f:
    json.dump(state, f, indent=2)
"

  # Generate SESSION-ROADMAP.md if path provided and chart.sh available
  if [ -n "$SESSION_ROADMAP" ]; then
    local repo="${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
    local chart
    chart=$(find "$repo" -path '*/swain-design/scripts/chart.sh' -print -quit 2>/dev/null)
    if [ -n "$chart" ] && [ -n "$FOCUS" ]; then
      bash "$chart" session --focus "$FOCUS" 2>/dev/null
      # chart.sh writes to SESSION-ROADMAP.md in repo root; move if needed
      local default_roadmap="$repo/SESSION-ROADMAP.md"
      if [ "$SESSION_ROADMAP" != "$default_roadmap" ] && [ -f "$default_roadmap" ]; then
        cp "$default_roadmap" "$SESSION_ROADMAP"
      fi
    fi
  fi

  echo "$session_id"
}

cmd_record_decision() {
  if [ ! -f "$STATE_FILE" ]; then
    echo "Error: No active session. Run 'init' first." >&2
    exit 1
  fi

  python3 -c "
import json
from datetime import datetime, timezone

with open('$STATE_FILE') as f:
    state = json.load(f)

current_time = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
state['decisions_made'] = state.get('decisions_made', 0) + 1
state['decisions'].append({
    'note': '''$NOTE''',
    'timestamp': current_time
})
state['last_activity_time'] = current_time

with open('$STATE_FILE', 'w') as f:
    json.dump(state, f, indent=2)
"
}

cmd_close() {
  if [ ! -f "$STATE_FILE" ]; then
    echo "Error: No active session. Run 'init' first." >&2
    exit 1
  fi

  local end_time
  end_time=$(now_iso)

  python3 -c "
import json

with open('$STATE_FILE') as f:
    state = json.load(f)

state['phase'] = 'closed'
state['end_time'] = '$end_time'
state['walkaway'] = '''$WALKAWAY'''

with open('$STATE_FILE', 'w') as f:
    json.dump(state, f, indent=2)
"

  # Append walk-away signal to SESSION-ROADMAP.md if provided
  if [ -n "$SESSION_ROADMAP" ] && [ -f "$SESSION_ROADMAP" ]; then
    cat >> "$SESSION_ROADMAP" <<EOF

## Walk-Away Signal

> $WALKAWAY

*Session closed: $end_time*
EOF
  fi
}

cmd_resume() {
  if [ ! -f "$STATE_FILE" ]; then
    echo "No previous session found."
    exit 0
  fi

  python3 -c "
import json

with open('$STATE_FILE') as f:
    state = json.load(f)

focus = state.get('focus_lane', 'none')
walkaway = state.get('walkaway', 'none')
decisions = state.get('decisions_made', 0)
phase = state.get('phase', 'unknown')
start = state.get('start_time', 'unknown')
end = state.get('end_time', 'unknown')
session_id = state.get('session_id', 'unknown')

print(f'Previous session: {session_id}')
print(f'Focus: {focus}')
print(f'Phase: {phase}')
print(f'Started: {start}')
if end and end != 'None':
    print(f'Ended: {end}')
print(f'Decisions made: {decisions}')
if walkaway and walkaway != 'None':
    print(f'Walk-away: {walkaway}')
"
}

cmd_show() {
  if [ ! -f "$STATE_FILE" ]; then
    echo "No active session."
    exit 0
  fi
  python3 -c "
import json
with open('$STATE_FILE') as f:
    print(json.dumps(json.load(f), indent=2))
"
}

case "$COMMAND" in
  init)             cmd_init ;;
  record-decision)  cmd_record_decision ;;
  close)            cmd_close ;;
  resume)           cmd_resume ;;
  show)             cmd_show ;;
  *)                echo "Unknown command: $COMMAND" >&2; usage; exit 1 ;;
esac