@pennyfarthing/core 7.9.0 → 7.9.2

package/pennyfarthing-dist/scripts/workflow/check.py

@@ -1,502 +0,0 @@
-#!/usr/bin/env python3
-"""
-check.py - Quality gate runner for pre-handoff verification
-
-Story 21-1: /check command with dev-handoff integration
-
-Usage: python check.py [OPTIONS]
-
-Options:
-    --skip-check       Skip all checks (emergency bypass)
-    --tests-only       Run only tests, skip lint and typecheck
-    --filter PATTERN   Filter tests by pattern (passed to test runner)
-    --repo REPO        Run checks in specific repo subdirectory
-    --no-lint          Skip lint check
-    --no-typecheck     Skip type check
-    --fast             Skip slow packages (cyclist/Electron) for rapid iteration
-
-Runs lint, type check, and tests concurrently. Reports pass/fail status.
-Returns exit code 0 on all passing, non-zero on any failure.
-"""
-
-import argparse
-import asyncio
-import json
-import os
-import shutil
-import sys
-from dataclasses import dataclass, field
-from enum import Enum
-from pathlib import Path
-from typing import Optional
-
-
-class CheckStatus(Enum):
-    PASS = "pass"
-    FAIL = "fail"
-    SKIP = "skip"
-
-
-@dataclass
-class CheckResult:
-    name: str
-    status: CheckStatus
-    command: Optional[str] = None
-    message: Optional[str] = None
-
-
-@dataclass
-class CheckStats:
-    run: int = 0
-    passed: int = 0
-    failed: int = 0
-    skipped: int = 0
-
-    def record(self, status: CheckStatus) -> None:
-        if status == CheckStatus.PASS:
-            self.run += 1
-            self.passed += 1
-        elif status == CheckStatus.FAIL:
-            self.run += 1
-            self.failed += 1
-        elif status == CheckStatus.SKIP:
-            self.skipped += 1
-
-
-@dataclass
-class RepoConfig:
-    path: str = ""
-    lint_cmd: str = ""
-    test_cmd: str = ""
-    test_filter_flag: str = ""
-    language: str = ""
-
-
-@dataclass
-class CheckContext:
-    project_root: Path
-    working_dir: Path
-    target_repo: str = ""
-    test_filter: str = ""
-    no_lint: bool = False
-    no_typecheck: bool = False
-    fast_mode: bool = False
-    repo_config: RepoConfig = field(default_factory=RepoConfig)
-    stats: CheckStats = field(default_factory=CheckStats)
-
-
-# ANSI colors
-class Colors:
-    def __init__(self, enabled: bool = True):
-        if enabled and sys.stdout.isatty():
-            self.RED = "\033[0;31m"
-            self.GREEN = "\033[0;32m"
-            self.YELLOW = "\033[0;33m"
-            self.CYAN = "\033[0;36m"
-            self.NC = "\033[0m"
-        else:
-            self.RED = ""
-            self.GREEN = ""
-            self.YELLOW = ""
-            self.CYAN = ""
-            self.NC = ""
-
-
-COLORS = Colors()
-
-
-def print_pass(name: str, command: Optional[str] = None) -> None:
-    suffix = f" ({command})" if command else ""
-    print(f"  {COLORS.GREEN}[PASS]{COLORS.NC} {name}{suffix}")
-
-
-def print_fail(name: str, command: Optional[str] = None) -> None:
-    suffix = f" ({command})" if command else ""
-    print(f"  {COLORS.RED}[FAIL]{COLORS.NC} {name}{suffix}")
-
-
-def print_skip(name: str, reason: str = "") -> None:
-    suffix = f" - {reason}" if reason else ""
-    print(f"  {COLORS.YELLOW}[SKIP]{COLORS.NC} {name}{suffix}")
-
-
-def print_section(title: str) -> None:
-    print()
-    print(f"{COLORS.CYAN}{title}{COLORS.NC}")
-    print("=" * 40)
-
-
-def find_project_root() -> Path:
-    """Find project root by looking for .pennyfarthing directory."""
-    current = Path.cwd()
-    while current != current.parent:
-        if (current / ".pennyfarthing").is_dir():
-            return current
-        current = current.parent
-    return Path.cwd()
-
-
-def detect_project_type(working_dir: Path) -> str:
-    """Detect project type based on files present."""
-    if (working_dir / "package.json").exists():
-        return "node"
-
-    # Check for Go files
-    go_files = list(working_dir.glob("*.go"))
-    if go_files:
-        return "go"
-
-    if (working_dir / "go.mod").exists():
-        return "go"
-
-    return "unknown"
-
-
-def has_just_recipe(recipe: str, working_dir: Path) -> bool:
-    """Check if justfile has a specific recipe."""
-    if not (working_dir / "justfile").exists():
-        return False
-    if not shutil.which("just"):
-        return False
-
-    try:
-        import subprocess
-        result = subprocess.run(
-            ["just", "--list"],
-            cwd=working_dir,
-            capture_output=True,
-            text=True,
-            timeout=5
-        )
-        return any(line.startswith(f"{recipe} ") or line.strip() == recipe
-                   for line in result.stdout.splitlines())
-    except Exception:
-        return False
-
-
-def has_npm_script(script: str, working_dir: Path) -> bool:
-    """Check if package.json has a specific script."""
-    package_json = working_dir / "package.json"
-    if not package_json.exists():
-        return False
-
-    try:
-        with open(package_json) as f:
-            data = json.load(f)
-        return script in data.get("scripts", {})
-    except Exception:
-        return False
-
-
-async def run_command(cmd: list[str], cwd: Path) -> tuple[bool, str]:
-    """Run a command asynchronously and return (success, output)."""
-    try:
-        proc = await asyncio.create_subprocess_exec(
-            *cmd,
-            cwd=cwd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        stdout, stderr = await proc.communicate()
-        success = proc.returncode == 0
-        output = stdout.decode() + stderr.decode()
-        return success, output
-    except Exception as e:
-        return False, str(e)
-
-
-async def run_shell_command(cmd: str, cwd: Path) -> tuple[bool, str]:
-    """Run a shell command asynchronously."""
-    try:
-        proc = await asyncio.create_subprocess_shell(
-            cmd,
-            cwd=cwd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        stdout, stderr = await proc.communicate()
-        success = proc.returncode == 0
-        output = stdout.decode() + stderr.decode()
-        return success, output
-    except Exception as e:
-        return False, str(e)
-
-
-async def run_lint(ctx: CheckContext) -> CheckResult:
-    """Run lint check."""
-    if ctx.no_lint:
-        return CheckResult("Lint", CheckStatus.SKIP, message="skipped by --no-lint or --tests-only")
-
-    working_dir = ctx.working_dir
-
-    # Use repo config lint command if available
-    if ctx.repo_config.lint_cmd:
-        success, _ = await run_shell_command(ctx.repo_config.lint_cmd, working_dir)
-        return CheckResult(
-            "Lint",
-            CheckStatus.PASS if success else CheckStatus.FAIL,
-            command=ctx.repo_config.lint_cmd
-        )
-
-    # Prefer justfile recipes
-    if has_just_recipe("lint", working_dir):
-        success, _ = await run_command(["just", "lint"], working_dir)
-        return CheckResult("Lint", CheckStatus.PASS if success else CheckStatus.FAIL, command="just lint")
-
-    project_type = detect_project_type(working_dir)
-
-    if project_type == "node" and has_npm_script("lint", working_dir):
-        success, _ = await run_command(["npm", "run", "lint"], working_dir)
-        return CheckResult("Lint", CheckStatus.PASS if success else CheckStatus.FAIL, command="npm run lint")
-
-    if project_type == "go" and shutil.which("golangci-lint"):
-        success, _ = await run_command(["golangci-lint", "run"], working_dir)
-        return CheckResult("Lint", CheckStatus.PASS if success else CheckStatus.FAIL, command="golangci-lint")
-
-    eslint_path = working_dir / "node_modules" / ".bin" / "eslint"
-    if eslint_path.exists():
-        success, _ = await run_command([str(eslint_path), "."], working_dir)
-        return CheckResult("Lint", CheckStatus.PASS if success else CheckStatus.FAIL, command="eslint")
-
-    return CheckResult("Lint", CheckStatus.SKIP, message="no lint command configured")
-
-
-async def run_typecheck(ctx: CheckContext) -> CheckResult:
-    """Run type check."""
-    if ctx.no_typecheck:
-        return CheckResult("Type Check", CheckStatus.SKIP, message="skipped by --no-typecheck or --tests-only")
-
-    working_dir = ctx.working_dir
-
-    # Prefer justfile recipes
-    if has_just_recipe("typecheck", working_dir):
-        success, _ = await run_command(["just", "typecheck"], working_dir)
-        return CheckResult("Type Check", CheckStatus.PASS if success else CheckStatus.FAIL, command="just typecheck")
-
-    has_tsconfig = (working_dir / "tsconfig.json").exists()
-
-    if has_tsconfig and has_npm_script("typecheck", working_dir):
-        success, _ = await run_command(["npm", "run", "typecheck"], working_dir)
-        return CheckResult("Type Check", CheckStatus.PASS if success else CheckStatus.FAIL, command="npm run typecheck")
-
-    if has_tsconfig and shutil.which("tsc"):
-        success, _ = await run_command(["tsc", "--noEmit"], working_dir)
-        return CheckResult("Type Check", CheckStatus.PASS if success else CheckStatus.FAIL, command="tsc --noEmit")
-
-    tsc_path = working_dir / "node_modules" / ".bin" / "tsc"
-    if has_tsconfig and tsc_path.exists():
-        success, _ = await run_command([str(tsc_path), "--noEmit"], working_dir)
-        return CheckResult("Type Check", CheckStatus.PASS if success else CheckStatus.FAIL, command="tsc --noEmit")
-
-    if has_tsconfig:
-        return CheckResult("Type Check", CheckStatus.SKIP, message="TypeScript found but no typecheck command")
-
-    return CheckResult("Type Check", CheckStatus.SKIP, message="not a TypeScript project")
-
-
-async def run_tests(ctx: CheckContext) -> CheckResult:
-    """Run tests."""
-    working_dir = ctx.working_dir
-    test_filter = ctx.test_filter
-
-    if test_filter:
-        print(f"  Filter: {test_filter}")
-
-    # Use repo config test command if available
-    if ctx.repo_config.test_cmd:
-        cmd = ctx.repo_config.test_cmd
-        if test_filter and ctx.repo_config.test_filter_flag:
-            cmd = f'{cmd} {ctx.repo_config.test_filter_flag} "{test_filter}"'
-        success, _ = await run_shell_command(cmd, working_dir)
-        label = ctx.repo_config.test_cmd
-        if test_filter:
-            label += f" {ctx.repo_config.test_filter_flag} {test_filter}"
-        return CheckResult("Tests", CheckStatus.PASS if success else CheckStatus.FAIL, command=label)
-
-    # Prefer justfile recipes
-    if has_just_recipe("test", working_dir):
-        cmd = ["just", "test"]
-        label = "just test"
-        if test_filter:
-            cmd.append(test_filter)
-            label += f" {test_filter}"
-        success, _ = await run_command(cmd, working_dir)
-        return CheckResult("Tests", CheckStatus.PASS if success else CheckStatus.FAIL, command=label)
-
-    project_type = detect_project_type(working_dir)
-
-    if project_type == "node" and has_npm_script("test", working_dir):
-        # Check for pnpm workspace (monorepo)
-        pnpm_workspace = (working_dir / "pnpm-workspace.yaml").exists()
-        has_pnpm = shutil.which("pnpm") is not None
-
-        if pnpm_workspace and has_pnpm:
-            if ctx.fast_mode:
-                cmd = "pnpm -r --filter '!@pennyfarthing/cyclist' test"
-                label = "pnpm test (fast mode - skipping cyclist)"
-            else:
-                cmd = "pnpm -r test"
-                label = "pnpm test"
-        else:
-            cmd = "npm test"
-            label = "npm test"
-
-        if test_filter:
-            cmd += f' -- -t "{test_filter}"'
-            label += f" -t {test_filter}"
-
-        success, _ = await run_shell_command(cmd, working_dir)
-        return CheckResult("Tests", CheckStatus.PASS if success else CheckStatus.FAIL, command=label)
-
-    if project_type == "go":
-        cmd = "go test ./..."
-        label = "go test ./..."
-        if test_filter:
-            cmd = f'go test -run "{test_filter}" ./...'
-            label = f"go test -run {test_filter} ./..."
-        success, _ = await run_shell_command(cmd, working_dir)
-        return CheckResult("Tests", CheckStatus.PASS if success else CheckStatus.FAIL, command=label)
-
-    jest_path = working_dir / "node_modules" / ".bin" / "jest"
-    if jest_path.exists():
-        cmd = [str(jest_path)]
-        label = "jest"
-        if test_filter:
-            cmd.extend(["-t", test_filter])
-            label += f" -t {test_filter}"
-        success, _ = await run_command(cmd, working_dir)
-        return CheckResult("Tests", CheckStatus.PASS if success else CheckStatus.FAIL, command=label)
-
-    return CheckResult("Tests", CheckStatus.SKIP, message="no test command configured")
-
-
-def print_result(result: CheckResult, stats: CheckStats) -> None:
-    """Print a check result and update stats."""
-    stats.record(result.status)
-
-    if result.status == CheckStatus.PASS:
-        print_pass(result.name, result.command)
-    elif result.status == CheckStatus.FAIL:
-        print_fail(result.name, result.command)
-    else:
-        print_skip(result.name, result.message or "")
-
-
-def print_summary(stats: CheckStats, project_type: str) -> int:
-    """Print summary and return exit code."""
-    print_section("Summary")
-    print()
-    print(f"Checks run:    {stats.run}")
-    print(f"Checks passed: {COLORS.GREEN}{stats.passed}{COLORS.NC}")
-
-    if stats.failed > 0:
-        print(f"Checks failed: {COLORS.RED}{stats.failed}{COLORS.NC}")
-    else:
-        print(f"Checks failed: {stats.failed}")
-
-    if stats.skipped > 0:
-        print(f"Checks skipped: {COLORS.YELLOW}{stats.skipped}{COLORS.NC}")
-
-    print()
-
-    if stats.failed > 0:
-        print(f"{COLORS.RED}FAILED{COLORS.NC} - {stats.failed} check(s) failed")
-        print("Fix issues before handoff to Reviewer.")
-        return 1
-    elif stats.run == 0:
-        print(f"{COLORS.YELLOW}WARNING{COLORS.NC} - No checks ran (project type: {project_type})")
-        print("Consider adding lint/test scripts to package.json or justfile.")
-        return 0
-    else:
-        print(f"{COLORS.GREEN}PASSED{COLORS.NC} - All checks passed")
-        return 0
-
-
-async def main() -> int:
-    parser = argparse.ArgumentParser(
-        description="Quality gate runner for pre-handoff verification"
-    )
-    parser.add_argument("--skip-check", action="store_true",
-                        help="Skip all checks (emergency bypass)")
-    parser.add_argument("--tests-only", action="store_true",
-                        help="Run only tests, skip lint and typecheck")
-    parser.add_argument("--filter", dest="test_filter", default="",
-                        help="Filter tests by pattern")
-    parser.add_argument("--repo", dest="target_repo", default="",
-                        help="Run checks in specific repo subdirectory")
-    parser.add_argument("--no-lint", action="store_true",
-                        help="Skip lint check")
-    parser.add_argument("--no-typecheck", action="store_true",
-                        help="Skip type check")
-    parser.add_argument("--fast", action="store_true",
-                        help="Skip slow packages for rapid iteration")
-
-    args = parser.parse_args()
-
-    # Handle --skip-check
-    if args.skip_check:
-        print("Quality checks skipped by --skip-check flag")
-        print()
-        print("WARNING: Skipping checks is for emergencies only.")
-        print("Ensure checks pass before merging PR.")
-        return 0
-
-    # Handle --tests-only
-    no_lint = args.no_lint or args.tests_only
-    no_typecheck = args.no_typecheck or args.tests_only
-
-    # Find project root
-    project_root = find_project_root()
-
-    # Handle --repo
-    if args.target_repo:
-        working_dir = project_root / args.target_repo
-        if not working_dir.is_dir():
-            print(f"Error: Repo directory not found: {working_dir}")
-            return 1
-    else:
-        working_dir = project_root
-
-    # Create context
-    ctx = CheckContext(
-        project_root=project_root,
-        working_dir=working_dir,
-        target_repo=args.target_repo,
-        test_filter=args.test_filter,
-        no_lint=no_lint,
-        no_typecheck=no_typecheck,
-        fast_mode=args.fast
-    )
-
-    # Print header
-    print()
-    print("Quality Gate Check")
-    print("==================")
-    print(f"Project: {project_root}")
-    if args.target_repo:
-        print(f"Repo: {args.target_repo}")
-    print(f"Working dir: {working_dir}")
-    if args.fast:
-        print(f"{COLORS.YELLOW}Mode: FAST (skipping slow packages){COLORS.NC}")
-
-    project_type = detect_project_type(working_dir)
-
-    # Run lint and typecheck concurrently, then tests
-    # (Tests often depend on lint/typecheck passing in CI, but we run all for reporting)
-    print_section("Lint")
-    lint_result = await run_lint(ctx)
-    print_result(lint_result, ctx.stats)
-
-    print_section("Type Check")
-    typecheck_result = await run_typecheck(ctx)
-    print_result(typecheck_result, ctx.stats)
-
-    print_section("Tests")
-    test_result = await run_tests(ctx)
-    print_result(test_result, ctx.stats)
-
-    return print_summary(ctx.stats, project_type)
-
-
-if __name__ == "__main__":
-    sys.exit(asyncio.run(main()))

package/pennyfarthing-dist/scripts/workflow/check.sh

@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-# check.sh - Quality gate runner for pre-handoff verification
-#
-# Story 21-1: /check command with dev-handoff integration
-#
-# Usage: ./scripts/check.sh [OPTIONS]
-#
-# Options:
-#   --skip-check       Skip all checks (emergency bypass)
-#   --tests-only       Run only tests, skip lint and typecheck
-#   --filter PATTERN   Filter tests by pattern (passed to test runner)
-#   --repo REPO        Run checks in specific repo subdirectory
-#   --no-lint          Skip lint check
-#   --no-typecheck     Skip type check
-#   --fast             Skip slow packages (cyclist/Electron) for rapid iteration
-#
-# Runs lint, type check, and tests. Reports pass/fail status.
-# Returns exit code 0 on all passing, non-zero on any failure.
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-exec python3 "$SCRIPT_DIR/check.py" "$@"

package/pennyfarthing-dist/scripts/workflow/finish-story.sh

@@ -1,159 +0,0 @@
-#!/bin/bash
-# Finish a story: archive, merge PR, transition Jira, update sprint YAML
-# Usage: finish-story.sh <story-id> [--dry-run]
-#
-# Example: finish-story.sh MSSCI-12052
-#          finish-story.sh MSSCI-12052 --dry-run
-#
-# Prerequisites:
-# - Session file exists at .session/{story-id}-session.md
-# - PR is approved and mergeable
-# - Reviewer has approved (phase: finish in session)
-#
-# This script performs:
-# 1. Archive session file to sprint/archive/{jira-key}-session.md
-# 2. Squash merge PR and delete remote branch
-# 3. Transition Jira to Done
-# 4. Update sprint YAML (status: done, completed date)
-# 5. Clean up local branch and session file
-
-set -euo pipefail
-
-STORY_ID="${1:-}"
-DRY_RUN=false
-
-# Parse options
-for arg in "$@"; do
-  case $arg in
-    --dry-run)
-      DRY_RUN=true
-      shift
-      ;;
-  esac
-done
-
-if [[ -z "$STORY_ID" ]]; then
-  echo "Usage: finish-story.sh <story-id> [--dry-run]"
-  echo ""
-  echo "Options:"
-  echo "  --dry-run    Show what would be done without executing"
-  exit 1
-fi
-
-# PROJECT_ROOT should be set by run.sh, but find it if not
-if [[ -z "${PROJECT_ROOT:-}" ]]; then
-  d="$PWD"
-  while [[ ! -d "$d/.pennyfarthing" ]] && [[ "$d" != "/" ]]; do
-    d="$(dirname "$d")"
-  done
-  PROJECT_ROOT="$d"
-fi
-
-SESSION_FILE="$PROJECT_ROOT/.session/${STORY_ID}-session.md"
-SPRINT_FILE="$PROJECT_ROOT/sprint/current-sprint.yaml"
-ARCHIVE_DIR="$PROJECT_ROOT/sprint/archive"
-
-# Ensure archive directory exists
-mkdir -p "$ARCHIVE_DIR"
-
-# Validate session file exists
-if [[ ! -f "$SESSION_FILE" ]]; then
-  echo "Error: Session file not found: $SESSION_FILE"
-  exit 1
-fi
-
-# Extract metadata from session file (handle both "**Jira:**" and "- **Jira:**" formats)
-JIRA_KEY=$(grep -E '\*\*Jira:\*\*' "$SESSION_FILE" | sed 's/.*\*\*Jira:\*\* //' | tr -d ' ' || echo "")
-# Extract branch - strip any trailing annotations like "(pushed)"
-BRANCH=$(grep -E '\*\*Branch:\*\*' "$SESSION_FILE" | sed 's/.*\*\*Branch:\*\* //' | sed 's/ *(.*//' | tr -d ' ' || echo "")
-
-# Try to get PR number from session file first (format: **PR:** #422 - title)
-PR_NUMBER=$(grep -E '\*\*PR:\*\*' "$SESSION_FILE" | sed 's/.*#\([0-9]*\).*/\1/' || echo "")
-
-# Fallback: try to get Jira key from sprint YAML if not in session
-if [[ -z "$JIRA_KEY" || "$JIRA_KEY" == "null" ]]; then
-  JIRA_KEY=$(yq ".epics[].stories[] | select(.id == \"$STORY_ID\") | .jira // \"\"" "$SPRINT_FILE" 2>/dev/null | head -1 || echo "")
-fi
-
-if [[ -z "$JIRA_KEY" || "$JIRA_KEY" == "null" ]]; then
-  echo "Error: Could not determine Jira key for story $STORY_ID"
-  echo "Check session file or sprint YAML for jira: field"
-  exit 1
-fi
-
-# Fallback: get PR number from GitHub if not in session file
-if [[ -z "$PR_NUMBER" ]] && [[ -n "$BRANCH" ]]; then
-  PR_NUMBER=$(gh pr list --head "$BRANCH" --json number --jq '.[0].number' 2>/dev/null || echo "")
-fi
-
-TODAY=$(date +%Y-%m-%d)
-
-echo "=== Finish Story: $STORY_ID ==="
-echo "Jira Key: $JIRA_KEY"
-echo "Branch: ${BRANCH:-none}"
-echo "PR: ${PR_NUMBER:-none}"
-echo ""
-
-if $DRY_RUN; then
-  echo "[DRY RUN] Would perform:"
-  echo "  1. Archive session → $ARCHIVE_DIR/${JIRA_KEY}-session.md"
-  if [[ -n "$PR_NUMBER" ]]; then
-    echo "  2. Merge PR #$PR_NUMBER (squash, delete branch)"
-  else
-    echo "  2. No PR to merge"
-  fi
-  echo "  3. Transition $JIRA_KEY to Done"
-  echo "  4. Update sprint YAML (status: done, completed: $TODAY)"
-  echo "  5. Delete local branch: $BRANCH"
-  echo "  6. Remove session file"
-  exit 0
-fi
-
-# Step 1: Archive session file
-echo "1. Archiving session file..."
-cp "$SESSION_FILE" "$ARCHIVE_DIR/${JIRA_KEY}-session.md"
-echo "   → $ARCHIVE_DIR/${JIRA_KEY}-session.md"
-
-# Step 2: Merge PR (if exists)
-if [[ -n "$PR_NUMBER" ]]; then
-  echo "2. Merging PR #$PR_NUMBER..."
-  gh pr merge "$PR_NUMBER" --squash --delete-branch || {
-    echo "   Warning: PR merge failed (may already be merged)"
-  }
-else
-  echo "2. No PR found for branch $BRANCH (skipping merge)"
-fi
-
-# Step 3: Transition Jira to Done
-echo "3. Transitioning Jira to Done..."
-jira issue move "$JIRA_KEY" "Done" 2>/dev/null || {
-  echo "   Warning: Jira transition failed (may already be Done)"
-}
-
-# Step 4: Update sprint YAML
-echo "4. Updating sprint YAML..."
-# Update status to done
-yq eval -i "(.epics[].stories[] | select(.id == \"$STORY_ID\")).status = \"done\"" "$SPRINT_FILE"
-# Add completed date
-yq eval -i "(.epics[].stories[] | select(.id == \"$STORY_ID\")).completed = \"$TODAY\"" "$SPRINT_FILE"
-# Remove assigned_to (no longer in progress)
-yq eval -i "del((.epics[].stories[] | select(.id == \"$STORY_ID\")).assigned_to)" "$SPRINT_FILE"
-echo "   → status: done, completed: $TODAY"
-
-# Step 5: Clean up git
-echo "5. Cleaning up git..."
-git checkout develop 2>/dev/null || git checkout main 2>/dev/null || true
-git pull origin "$(git branch --show-current)" 2>/dev/null || true
-
-if [[ -n "$BRANCH" ]]; then
-  git branch -d "$BRANCH" 2>/dev/null || echo "   Local branch already deleted"
-fi
-
-# Step 6: Remove session file
-echo "6. Removing session file..."
-rm "$SESSION_FILE"
-
-echo ""
-echo "=== Story $STORY_ID Complete ==="
-echo "Archived: sprint/archive/${JIRA_KEY}-session.md"
-echo "Jira: https://1898andco.atlassian.net/browse/$JIRA_KEY"