@reservine/dx 1.0.0

package/plugins/reservine-dx/scripts/setup-worktree-fe.sh

@@ -0,0 +1,244 @@
+#!/usr/bin/env bash
+#
+# Reservine-DX — Angular Frontend Worktree Setup
+#
+# Sets up a git worktree for the Reservine Angular frontend:
+#   - Symlinks (or copies) node_modules from the main repo
+#   - Copies SSL certs for the dev server
+#   - Copies proxy.conf.json for backend API proxying
+#   - Copies .env / .env.local
+#   - Suggests a dev server port (main uses 1111)
+#
+# Usage:
+#   ./setup-worktree-fe.sh [OPTIONS]
+#
+# Options:
+#   --plan=<name>       Search .claude/plans/ for matching file, extract branch name
+#   --branch=<name>     Create and checkout this branch
+#   --base=<branch>     Base branch for PR (default: main)
+#   --no-dep-link       Run bun install instead of symlinking node_modules
+#   -h, --help          Show this help message
+#
+
+set -euo pipefail
+
+# Source shared core
+SCRIPTS_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPTS_DIR/_core.sh"
+
+# ─── Defaults ───────────────────────────────────────────────────────────────────
+
+DEP_LINK=true
+BRANCH_NAME=""
+BASE_BRANCH="main"
+PLAN_PATTERN=""
+
+# ─── Help ───────────────────────────────────────────────────────────────────────
+
+show_help() {
+    cat << 'EOF'
+Reservine-DX — Angular Frontend Worktree Setup
+
+Usage: ./setup-worktree-fe.sh [OPTIONS]
+
+Options:
+  --plan=<name>       Search .claude/plans/ for matching file, extract branch name
+  --branch=<name>     Create and checkout this branch
+  --base=<branch>     Base branch for PR validation (default: main)
+  --no-dep-link       Run bun install instead of symlinking node_modules
+  -h, --help          Show this help message
+
+Environment Variables:
+  ROOT_WORKTREE_PATH  Path to main repo (auto-detected from git worktree list)
+
+Examples:
+  # Simple setup — auto-detects everything
+  ./setup-worktree-fe.sh
+
+  # Setup with explicit branch
+  ./setup-worktree-fe.sh --branch=feat/my-feature
+
+  # Install node_modules instead of symlinking
+  ./setup-worktree-fe.sh --no-dep-link
+
+  # Setup from a plan file
+  ./setup-worktree-fe.sh --plan=seo-configurator
+EOF
+}
+
+# ─── Parse arguments ────────────────────────────────────────────────────────────
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --plan=*)       PLAN_PATTERN="${1#*=}"; shift ;;
+        --branch=*)     BRANCH_NAME="${1#*=}"; shift ;;
+        --base=*)       BASE_BRANCH="${1#*=}"; shift ;;
+        --no-dep-link)  DEP_LINK=false; shift ;;
+        --log)          LOG_FILE="$(pwd)/setup.log"; shift ;;
+        --log=*)        LOG_FILE="${1#*=}"; shift ;;
+        -h|--help)      show_help; exit 0 ;;
+        *)              error "Unknown option: $1"; show_help; exit 1 ;;
+    esac
+done
+
+init_log "$@"
+
+# ─── Plan resolution ────────────────────────────────────────────────────────────
+
+if [[ -n "$PLAN_PATTERN" ]]; then
+    resolve_plan_file "$PLAN_PATTERN"
+fi
+
+# ─── Pre-flight ─────────────────────────────────────────────────────────────────
+
+resolve_root_worktree_path
+preflight_check
+
+info "Stack: Angular (bun)"
+
+# ─── Branch setup ────────────────────────────────────────────────────────────────
+
+if [[ -n "$BRANCH_NAME" ]]; then
+    setup_branch "$BRANCH_NAME" "$BASE_BRANCH"
+fi
+
+# ─── Environment setup ──────────────────────────────────────────────────────────
+
+if [[ "$IS_CLOUD" == true ]]; then
+    info "Cloud environment — skipping local setup"
+else
+    echo "⚙️  Angular Environment Setup"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+    # ── node_modules ──
+
+    if [[ "$DEP_LINK" == true ]]; then
+        if [[ -d "node_modules" ]] && [[ ! -L "node_modules" ]]; then
+            warn "node_modules/ is a directory — removing to create symlink"
+            rm -rf node_modules
+        fi
+
+        if [[ -L "node_modules" ]]; then
+            info "node_modules/ symlink already exists → $(readlink node_modules)"
+        elif [[ -d "${ROOT_WORKTREE_PATH}/node_modules" ]]; then
+            ln -s "${ROOT_WORKTREE_PATH}/node_modules" node_modules
+            success "Symlinked node_modules/ → main repo"
+        else
+            warn "Main repo has no node_modules/ — running bun install"
+            bun install
+            success "Installed node_modules/"
+        fi
+    else
+        if [[ -d "node_modules" ]] && [[ ! -L "node_modules" ]]; then
+            info "node_modules/ directory already exists (local copy)"
+        else
+            [[ -L "node_modules" ]] && rm node_modules
+            if [[ -d "${ROOT_WORKTREE_PATH}/node_modules" ]]; then
+                info "Copying node_modules/ from main repo (this may take a moment)..."
+                cp -R "${ROOT_WORKTREE_PATH}/node_modules" node_modules
+                success "Copied node_modules/ (local copy)"
+            else
+                bun install
+                success "Installed node_modules/"
+            fi
+        fi
+    fi
+
+    # ── SSL certs ──
+
+    for cert in localhost.pem localhost-key.pem; do
+        if [[ ! -f "$cert" ]] && [[ -f "${ROOT_WORKTREE_PATH}/$cert" ]]; then
+            cp "${ROOT_WORKTREE_PATH}/$cert" .
+            success "Copied $cert"
+        fi
+    done
+
+    # ── proxy.conf.json ──
+    # Priority: 1) already exists (generated by BE --isolated), 2) detect running BE stack, 3) copy from main
+
+    if [[ -f "proxy.conf.json" ]]; then
+        info "proxy.conf.json already exists (generated by BE --isolated)"
+    else
+        # Check if a BE isolated stack is running for this branch
+        BRANCH_SLUG=$(get_branch_slug)
+        BE_APP_PORT=$(docker ps --filter "name=wt-${BRANCH_SLUG}-app" --format "{{.Ports}}" 2>/dev/null \
+            | grep -oE '0\.0\.0\.0:[0-9]+->80' | head -1 | cut -d: -f2 | cut -d- -f1)
+        if [[ -n "$BE_APP_PORT" ]]; then
+            cat > proxy.conf.json <<PROXY_EOF
+{
+  "/api": { "target": "http://localhost:${BE_APP_PORT}", "secure": false, "changeOrigin": true },
+  "/sanctum": { "target": "http://localhost:${BE_APP_PORT}", "secure": false, "changeOrigin": true }
+}
+PROXY_EOF
+            success "Generated proxy.conf.json → isolated BE on :${BE_APP_PORT}"
+        elif [[ -f "${ROOT_WORKTREE_PATH}/proxy.conf.json" ]]; then
+            cp "${ROOT_WORKTREE_PATH}/proxy.conf.json" .
+            success "Copied proxy.conf.json from main repo"
+        fi
+    fi
+
+    # ── .env files ──
+
+    for envfile in .env .env.local; do
+        if [[ ! -f "$envfile" ]] && [[ -f "${ROOT_WORKTREE_PATH}/$envfile" ]]; then
+            cp "${ROOT_WORKTREE_PATH}/$envfile" .
+            success "Copied $envfile"
+        fi
+    done
+
+    # ── .claude/config.local ──
+
+    if [[ ! -f ".claude/config.local" ]] && [[ -f "${ROOT_WORKTREE_PATH}/.claude/config.local" ]]; then
+        mkdir -p .claude
+        cp "${ROOT_WORKTREE_PATH}/.claude/config.local" .claude/config.local
+        success "Copied .claude/config.local"
+    fi
+
+    echo ""
+fi
+
+# ─── Final output ───────────────────────────────────────────────────────────────
+
+echo "✨  Worktree setup complete!"
+echo ""
+
+if [[ "$IS_CLOUD" == false ]]; then
+    # Find first free port in the worktree range (main uses 1111)
+    SUGGESTED_PORT=""
+    for port in 4200 4201 4202 4203 4204 4205; do
+        if ! port_in_use "$port"; then
+            SUGGESTED_PORT=$port
+            break
+        fi
+    done
+    SUGGESTED_PORT=${SUGGESTED_PORT:-4200}  # fallback if all in use
+
+    # Write worktree port to config.local so Playwright MCP can auto-connect
+    mkdir -p .claude
+    if grep -q "^MCP_WORKTREE_PORT=" .claude/config.local 2>/dev/null; then
+        sed -i.bak "s/^MCP_WORKTREE_PORT=.*/MCP_WORKTREE_PORT=$SUGGESTED_PORT/" .claude/config.local
+        rm -f .claude/config.local.bak
+    else
+        echo "" >> .claude/config.local 2>/dev/null || true
+        echo "# Worktree dev server port (auto-detected by setup script)" >> .claude/config.local
+        echo "MCP_WORKTREE_PORT=$SUGGESTED_PORT" >> .claude/config.local
+    fi
+    success "Set MCP_WORKTREE_PORT=$SUGGESTED_PORT in .claude/config.local"
+
+    echo "📦  Angular Worktree Ready"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+    echo "  Start dev server (main uses port 1111):"
+    echo "    nx serve reservine --port $SUGGESTED_PORT"
+    echo ""
+    echo "  With SSL:"
+    echo "    nx serve reservine --port $SUGGESTED_PORT --ssl"
+    echo ""
+    if [[ -f "proxy.conf.json" ]]; then
+        echo "  With local backend proxy:"
+        echo "    nx serve reservine --port $SUGGESTED_PORT --proxy-config=proxy.conf.json"
+        echo ""
+    fi
+fi
+
+print_state "node_modules" "$BRANCH_NAME"

package/plugins/reservine-dx/scripts/setup-worktree.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+#
+# Reservine-DX — Worktree Setup (entry point)
+#
+# Auto-detects the current stack (Angular or Laravel) and delegates to the
+# appropriate stack-specific setup script.
+#
+# Usage:
+#   ./setup-worktree.sh [OPTIONS]
+#
+# The script will detect:
+#   - angular.json / nx.json  → runs setup-worktree-fe.sh
+#   - artisan / composer.json → runs setup-worktree-be.sh
+#
+# All options are forwarded to the stack-specific script.
+# See setup-worktree-fe.sh --help or setup-worktree-be.sh --help for details.
+#
+
+set -euo pipefail
+
+SCRIPTS_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+# Quick help
+if [[ "${1:-}" == "-h" ]] || [[ "${1:-}" == "--help" ]]; then
+    cat << 'EOF'
+Reservine-DX — Worktree Setup
+
+Auto-detects the stack and runs the appropriate setup script.
+
+Usage: ./setup-worktree.sh [OPTIONS]
+
+Stack detection:
+  angular.json / nx.json   → Angular (setup-worktree-fe.sh)
+  artisan / composer.json  → Laravel (setup-worktree-be.sh)
+
+You can also call the stack-specific script directly:
+  ./setup-worktree-fe.sh [OPTIONS]
+  ./setup-worktree-be.sh [OPTIONS]
+
+Run with --help on a specific script for its options:
+  ./setup-worktree-fe.sh --help
+  ./setup-worktree-be.sh --help
+EOF
+    exit 0
+fi
+
+# Detect stack
+if [[ -f "angular.json" ]] || [[ -f "nx.json" ]]; then
+    exec "$SCRIPTS_DIR/setup-worktree-fe.sh" "$@"
+elif [[ -f "artisan" ]] || [[ -f "composer.json" ]]; then
+    exec "$SCRIPTS_DIR/setup-worktree-be.sh" "$@"
+else
+    echo "❌ Could not detect stack (no angular.json, nx.json, artisan, or composer.json found)" >&2
+    echo "" >&2
+    echo "   Run the stack-specific script directly:" >&2
+    echo "   $SCRIPTS_DIR/setup-worktree-fe.sh [OPTIONS]   # Angular" >&2
+    echo "   $SCRIPTS_DIR/setup-worktree-be.sh [OPTIONS]   # Laravel" >&2
+    exit 1
+fi

package/plugins/reservine-dx/skills/cross-plan/SKILL.md

@@ -0,0 +1,339 @@
+---
+name: reservine-dx:cross-plan
+description: >
+  Create an intent file and linked GitHub issue in the sibling repo when a feature requires
+  cross-repo changes. Auto-detects direction (FE→BE or BE→FE) and creates the appropriate
+  intent file template with skill references, GitHub issue tracking, sub-issue linking,
+  and milestone sync. Works from either repo.
+  Triggers: "cross-plan", "create intent file", "needs backend/frontend changes".
+argument-hint: [feature description]
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+---
+
+# Cross-Project Plan (Bidirectional)
+
+Create an intent file and linked GitHub issue in the sibling repo when a feature requires
+cross-repo changes. Auto-detects whether you're in the FE or BE repo and creates the
+appropriate direction-specific artifacts.
+
+## Step 1: Gather Context & Detect Direction
+
+Read the project config to resolve paths and repo identifiers:
+
+```bash
+cat .claude/config 2>/dev/null
+cat .claude/config.local 2>/dev/null
+```
+
+**Auto-detect direction:**
+
+```bash
+if [[ -f "angular.json" ]] || [[ -f "nx.json" ]]; then
+  DIRECTION="FE_TO_BE"
+  CURRENT_REPO="FE"
+  CURRENT_GITHUB_REPO=$GITHUB_REPO  # from .claude/config
+  TARGET_DIR=$(grep 'BACKEND_DIR' .claude/config | cut -d= -f2)
+  TARGET_DIR_ABS=$(grep 'BACKEND_DIR_ABSOLUTE' .claude/config.local 2>/dev/null | cut -d= -f2)
+  [[ -n "$TARGET_DIR_ABS" ]] && TARGET_DIR="$TARGET_DIR_ABS"
+else
+  DIRECTION="BE_TO_FE"
+  CURRENT_REPO="BE"
+  CURRENT_GITHUB_REPO=$GITHUB_REPO
+  TARGET_DIR=$(grep 'FRONTEND_DIR' .claude/config | cut -d= -f2)
+  TARGET_DIR_ABS=$(grep 'FRONTEND_DIR_ABSOLUTE' .claude/config.local 2>/dev/null | cut -d= -f2)
+  [[ -n "$TARGET_DIR_ABS" ]] && TARGET_DIR="$TARGET_DIR_ABS"
+fi
+```
+
+Then read the target repo config:
+```bash
+cat $TARGET_DIR/.claude/config 2>/dev/null
+```
+Extract `GITHUB_REPO` from the target config → `TARGET_GITHUB_REPO`.
+
+**Fallback defaults:**
+- FE repo: `LEFTEQ/reservine`
+- BE repo: `genesiscz/ReservineBack`
+
+### Resolve current issue number
+
+Look for the current issue number from these sources (in priority order):
+1. Conversation context — if working on an issue (e.g., `implement-plan` invoked with `#259`)
+2. Current branch name — extract issue number from patterns like `feat/social-login-259`
+3. If no issue is found, proceed without cross-linking (intent file + standalone issue)
+
+### Resolve feature name
+
+If `$ARGUMENTS` is provided, use it as the feature description. Otherwise, infer from conversation context or ask the user:
+
+1. **Feature name** — short kebab-case identifier (e.g., `sms-confirmation-toggle`)
+2. **What the target repo needs to do** — endpoints/pages, data changes, components
+3. **Why** — business context
+
+## Step 2: Write the Intent File
+
+Create the file at: `<TARGET_DIR>/.claude/plans/future/<feature>.intent.md`
+
+### FE→BE template (API-focused)
+
+```markdown
+# <Feature Name> — Intent
+
+> **Auto-invoke these skills when starting work on this plan:**
+> 1. `/reservine-dx:implement-plan` — full end-to-end implementation orchestrator (worktree, tests, PR)
+> 2. `/reservine:api` — API endpoint implementation patterns (migration, model, service, controller, routes, tests)
+
+## What we need
+<Business-level description of what the backend must provide>
+
+## API changes needed
+<Endpoints to add/modify, request/response shapes, HTTP methods>
+
+## Permissions & authorization
+<Required roles, new permissions, middleware considerations>
+
+## Why
+<Business context — why this change matters>
+
+## FE context
+<What the frontend is doing, which components/services will consume the API>
+
+## Data shape expected by FE
+<TypeScript interfaces or JSON examples the frontend expects>
+
+## Tracking
+- FE issue: <FE_GITHUB_REPO>#<current-issue>
+- BE issue: <BE_GITHUB_REPO>#<be-issue>
+```
+
+### BE→FE template (UI-focused)
+
+```markdown
+# <Feature Name> — Intent
+
+> **Auto-invoke these skills when starting work on this plan:**
+> 1. `/reservine-dx:implement-plan` — full end-to-end implementation orchestrator (design critique, questionnaire, worktree, E2E tests, PR)
+> 2. `/reservine:design` — UI design & component composition
+> 3. `/reservine:play` — Playwright MCP browser tools for E2E testing
+> 4. _(optional, when creating/modifying forms)_ `/reservine:form-builder`
+
+## What we need
+<Business-level description of what the frontend must provide>
+
+## UI changes needed
+<Pages/components to add/modify, expected UX flow>
+
+## Data shape from BE
+<What the API returns — response format, TypeScript types, endpoint paths>
+
+## Why
+<Business context — why this change matters>
+
+## BE context
+<What the backend is doing, which endpoints are available, auth requirements>
+
+## Tracking
+- FE issue: <FE_GITHUB_REPO>#<fe-issue>
+- BE issue: <BE_GITHUB_REPO>#<current-issue>
+```
+
+**Note:** The `## Tracking` section uses placeholders initially — update it after the target issue is created (Step 3).
+
+## Step 3: Create Target GitHub Issue
+
+Create a GitHub issue in the target repo for tracking implementation:
+
+### FE→BE: Create BE issue
+
+```bash
+TARGET_ISSUE_URL=$(gh issue create --repo $TARGET_GITHUB_REPO \
+  --title "<Feature Title> — Backend" \
+  --body "$(cat <<'EOF'
+- [ ] @LEFTEQ read this
+- [ ] @genesiscz read this
+
+---
+
+## Summary
+<1-3 sentence business-level summary from intent file>
+
+## Intent File
+Implementation plan: `<relative-path-to-intent-file>`
+
+> Open a session in the BE repo and run:
+> `Implement the feature described in <absolute-path-to-intent-file>`
+
+## FE Reference
+Frontend implementation: <FE_GITHUB_REPO>#<current-issue>
+EOF
+)")
+```
+
+### BE→FE: Create FE issue
+
+```bash
+TARGET_ISSUE_URL=$(gh issue create --repo $TARGET_GITHUB_REPO \
+  --title "<Feature Title>" \
+  --body "$(cat <<'EOF'
+- [ ] @LEFTEQ read this
+- [ ] @genesiscz read this
+
+---
+
+## Summary
+<1-3 sentence business-level summary from intent file>
+
+## Intent File
+Implementation plan: `<relative-path-to-intent-file>`
+
+> Open a session in the FE repo and run:
+> `Implement the feature described in <absolute-path-to-intent-file>`
+
+## BE Reference
+Backend implementation: <BE_GITHUB_REPO>#<current-issue>
+EOF
+)")
+```
+
+Extract the target issue number from the returned URL.
+
+### Milestone sync
+
+If the current issue has a milestone, apply the same milestone to the target issue:
+
+```bash
+MILESTONE=$(gh issue view <current-issue> --repo $CURRENT_GITHUB_REPO --json milestone --jq '.milestone.title // empty')
+if [[ -n "$MILESTONE" ]]; then
+  gh issue edit <target-issue> --repo $TARGET_GITHUB_REPO --milestone "$MILESTONE"
+fi
+```
+
+### Apply label
+
+```bash
+gh issue edit <target-issue> --repo $TARGET_GITHUB_REPO --add-label "status:planning" 2>/dev/null || true
+```
+
+### Update intent file tracking section
+
+Now that the target issue number is known, update the `## Tracking` section in the intent file
+with the actual issue numbers.
+
+## Step 4: Link Issues
+
+### Sub-issue linking (FE = parent, BE = child)
+
+Determine which is the FE issue and which is the BE issue:
+- **FE→BE**: FE issue = `<current-issue>` in `FE_GITHUB_REPO`, BE issue = `<target-issue>` in `BE_GITHUB_REPO`
+- **BE→FE**: FE issue = `<target-issue>` in `FE_GITHUB_REPO`, BE issue = `<current-issue>` in `BE_GITHUB_REPO`
+
+FE is always the parent:
+
+```bash
+# Get FE issue node ID
+FE_OWNER=$(echo $FE_GITHUB_REPO | cut -d/ -f1)
+FE_NAME=$(echo $FE_GITHUB_REPO | cut -d/ -f2)
+FE_NODE_ID=$(gh api graphql -f query='
+  { repository(owner:"'"$FE_OWNER"'", name:"'"$FE_NAME"'") {
+    issue(number:<fe-issue>) { id }
+  } }' --jq '.data.repository.issue.id')
+
+# Get BE issue node ID
+BE_OWNER=$(echo $BE_GITHUB_REPO | cut -d/ -f1)
+BE_NAME=$(echo $BE_GITHUB_REPO | cut -d/ -f2)
+BE_NODE_ID=$(gh api graphql -f query='
+  { repository(owner:"'"$BE_OWNER"'", name:"'"$BE_NAME"'") {
+    issue(number:<be-issue>) { id }
+  } }' --jq '.data.repository.issue.id')
+
+# Add BE as sub-issue of FE
+gh api graphql -f query='
+  mutation {
+    addSubIssue(input: {
+      issueId: "'"$FE_NODE_ID"'"
+      subIssueId: "'"$BE_NODE_ID"'"
+    }) {
+      issue { id }
+      subIssue { id }
+    }
+  }'
+```
+
+If the sub-issue API fails (feature not available), fall back to cross-reference comments only.
+
+### Cross-reference comments
+
+```bash
+# On current repo issue
+gh issue comment <current-issue> --repo $CURRENT_GITHUB_REPO \
+  --body "**Target Issue:** $TARGET_GITHUB_REPO#<target-issue>
+Frontend implementation tracked here. Intent file: \`<path-to-intent-file>\`"
+
+# On target repo issue
+gh issue comment <target-issue> --repo $TARGET_GITHUB_REPO \
+  --body "**Source Issue:** $CURRENT_GITHUB_REPO#<current-issue>
+Linked as sub-issue for implementation tracking."
+```
+
+### No current issue available
+
+If no current issue was found in Step 1:
+- Skip sub-issue linking entirely
+- Skip cross-reference comments
+- Create the target issue without the reference section
+- Note in the output that no source issue was linked
+
+## Step 5: Plan Directory Structure
+
+The target repo uses this directory layout:
+
+```
+.claude/plans/
+├── future/           # ← you write here
+│   └── <feature>.intent.md
+├── active/           # ← receiving AI moves here when starting work
+│   └── <feature>/
+│       ├── <feature>.intent.md
+│       └── <feature>.technical.md
+└── finished/         # ← after implementation
+    └── <feature>/
+```
+
+## Step 6: Output the Handoff
+
+After writing the intent file and creating/linking issues, output this EXACT format (replace placeholders):
+
+---
+
+**Cross-plan ready.**
+
+Target issue created: `<TARGET_GITHUB_REPO>#<target-issue>` — <link-to-target-issue>
+Linked to source issue: `<CURRENT_GITHUB_REPO>#<current-issue>`
+
+Intent file written to:
+`<full absolute path to the intent file>`
+
+Open a new session in **<target repo name>** and paste:
+
+```
+Implement the feature described in <full absolute path to intent file>. Read the intent file — it contains the requirements and lists which skills to auto-invoke before writing code. Create a technical plan first, then implement.
+```
+
+---
+
+If no source issue was linked, replace the "Linked to" line with:
+`No source issue linked (not detected in conversation context).`
+
+## Rules
+
+- Intent files are **business-level** — describe WHAT is needed, not HOW to build it
+- Never write implementation details in the intent file — that's the receiving repo's job
+- Always create the target GitHub issue — it's the tracking ticket for the cross-repo work
+- Always attempt to link issues when a source issue number is available
+- FE is always the parent in sub-issue relationships
+- Always use the exact handoff format above — the user copies it into the next session
+- The receiving AI reads the intent file, invokes the listed skills, and handles the rest