specpro-cli 0.1.0__py3-none-any.whl

specpro_cli/assets/scripts/bash/check-anti-coupling.sh

@@ -0,0 +1,293 @@
+#!/bin/bash
+#
+# Anti-coupling scan — Pass O, made runnable.
+#
+# Pass O's own text says "**The pattern table is a maintained asset, not a one-off
+# script**" — and until this script existed, there was no table and no script, only the
+# sentence. A pass that is transcribed rather than executed is a statement (原则 I).
+#
+# What it looks for: specpro's distributed assets carrying traces of the HOST project
+# they were first developed against. Those assets ship to every user, so a trace ships
+# with them (宪法 1.3).
+#
+# ⚠️ **The patterns are NOT in this file, and that is the design.** This script is a
+# distributed asset: hardcoding a host-domain term here would BE the leak it exists to
+# find (O3), and the same for a pinned framework or tool name (O2) — **a comment that
+# names either one is itself an instance of the leak**, which is why neither is quoted
+# anywhere in this file. The patterns therefore live in a
+# project-side file — `specs/anti-coupling-patterns.txt` by default — which ships to
+# nobody. One class is not even listed there: **foreign numeric identifiers are DERIVED**
+# from the project's own artifacts, because "foreign" means exactly "not allocated by
+# this project", and the project knows its own numbers.
+#
+# Coverage is all three classes (Pass O: "A scan covering two of them is not 'partial
+# credit'"). A class with no patterns and no derivation is a FAILURE, not a skip — the
+# uncovered class is the finding.
+#
+# Usage:  scripts/bash/check-anti-coupling.sh
+#         ANTI_COUPLING_BASE=<path> scripts/bash/check-anti-coupling.sh   (fixture case)
+# Exit:   0 = no finding;  1 = at least one finding or an uncovered class
+
+# ⚠️ NOT `set -e`: the logic reads grep's exit codes (宪法 2.2.2, second carve-out).
+set -uo pipefail
+
+# ---------------------------------------------------------------------------
+# Repository root — resolved POSITION-INDEPENDENTLY, then TESTED (T180 / ISS-124).
+#
+# ⚠️ The previous form was `dirname "${BASH_SOURCE[0]}"/../..`, which is correct only
+# from the SOURCE layout. From the deployed mirror (`.specpro/scripts/bash/…`) it
+# resolves to `.specpro` — one level short — and every path below then names a tree
+# that does not exist. ⚠️ The failure is silent in the worst direction: a scan over a
+# tree it never read still prints `✓ none`, which is indistinguishable from a clean
+# one (ISS-83's shape). Pass O itself instructs running this from the mirror position.
+#
+# ⚠️ **The sentinel tests the RESULT, not the method.** Whatever produced BASE, it must
+# look like a repository root; when it does not, the script says so and names BASE —
+# never a downstream symptom (the old failure reported "推不出编号范围", which describes
+# an effect three steps away from the cause).
+#
+# Order: git (correct from BOTH positions) → the two candidate depths, each tested.
+# A BASE that IS a root is accepted from any source — including an override: an
+# override that names a non-root is exactly the case the sentinel exists to catch.
+# ---------------------------------------------------------------------------
+is_repo_root() { [ -d "$1/commands" ] && [ -d "$1/templates" ] && [ -d "$1/scripts" ]; }
+
+# ⚠️ **Two sentinels, and which one applies depends on WHO named the base** (`T205` /
+# `ISS-165`). This is not a relaxation of the guard: it is the guard asking the right
+# question in each case.
+#
+#   * **auto-resolution** answers "is this a repository root?" — the three-directory
+#     shape is the evidence, and it must hold because the script CHOSE the directory.
+#   * **an explicit override** answers "can I read what I am about to scan?" — the
+#     caller has already named the tree, and what this scanner actually reads is
+#     `commands/` (the shipped assets) and `specs/` (its own spec, tasks and pattern
+#     table). Demanding `templates/` and `scripts/` here asks about directories this
+#     script never opens.
+#
+# Measured before the split: the anti-coupling fixtures build exactly `commands/` and
+# `specs/`, so every one of them was refused before the scan — and three unit tests went
+# red while the real repository (which has all three) stayed green. A guard whose
+# subjects can no longer be exercised is not a stronger guard.
+is_scannable_base() { [ -d "$1/commands" ] && [ -d "$1/specs" ]; }
+
+resolve_base() {
+    local cand here
+    if cand=$(git rev-parse --show-toplevel 2>/dev/null) && [ -n "$cand" ] && is_repo_root "$cand"; then
+        printf '%s' "$cand"; return 0
+    fi
+    here=$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+    for cand in "$here/../.." "$here/../../.."; do
+        cand=$(CDPATH="" cd "$cand" 2>/dev/null && pwd) || continue
+        is_repo_root "$cand" && { printf '%s' "$cand"; return 0; }
+    done
+    return 1
+}
+
+if [ -n "${ANTI_COUPLING_BASE:-}" ]; then
+    BASE="$ANTI_COUPLING_BASE"
+else
+    BASE=$(resolve_base) || BASE=''
+fi
+
+# ⚠️ The sentinel is chosen by the base's SOURCE, and the message names the one that ran —
+# a reader told to expect `templates/` when the failing check never looks at it would go add
+# a directory that changes nothing.
+if [ -n "${ANTI_COUPLING_BASE:-}" ]; then
+    _sentinel_ok=0; is_scannable_base "$BASE" && _sentinel_ok=1
+    _expect="commands/ and specs/ (what this scanner reads)"
+else
+    _sentinel_ok=0; is_repo_root "$BASE" && _sentinel_ok=1
+    _expect="commands/ , templates/ and scripts/ (a repository root)"
+fi
+if [ "$_sentinel_ok" -eq 0 ]; then
+    echo "✗ BASE is not usable: '${BASE:-<unresolved>}'" >&2
+    echo "  Expected it to contain $_expect ." >&2
+    if [ -n "${ANTI_COUPLING_BASE:-}" ]; then
+        echo "  Source: the ANTI_COUPLING_BASE override." >&2
+    else
+        echo "  Source: auto-resolution (git toplevel, then the script's two possible depths)." >&2
+    fi
+    echo "  ⚠️ Every finding below would be derived from a tree this script never read —" >&2
+    echo "     an absent subject and a clean subject are the same output otherwise." >&2
+    exit 1
+fi
+
+# The roots that SHIP. A user project receives these under different paths, but the
+# class of file is the same; the caller may override with ANTI_COUPLING_ASSETS.
+ASSETS="${ANTI_COUPLING_ASSETS:-commands templates scripts}"
+PATTERNS="${ANTI_COUPLING_PATTERNS:-$BASE/specs/anti-coupling-patterns.txt}"
+OWN_SPEC="${ANTI_COUPLING_OWN_SPEC:-$BASE/specs/spec.md}"
+OWN_TASKS="${ANTI_COUPLING_OWN_TASKS:-$BASE/specs/tasks.md}"
+
+FAIL=0
+echo "Anti-coupling scan: $BASE"
+echo
+
+# --- class 1: foreign numeric identifiers (DERIVED, not listed) ----------------------
+# ⚠️ **The criterion is O1's own wording: "A number above this document's own range is the
+# mechanical tell."** It is a RANGE test, not a set difference — and the first run of this
+# script is why that distinction matters. A set difference flagged `FR-5` · `FR-10` ·
+# `US-1` out of `commands/specpro.checklist.md`, where they are ILLUSTRATIVE placeholders
+# ("Spec §FR-5") that belong to no project at all. Those are not leakage, and reporting
+# them as if they were teaches the reader to skim the output — after which a real hit
+# reads the same as noise. O1 also says the *in-range* identifier carrying a host-specific
+# gloss is "the one that needs a reader to notice": that half is deliberately NOT
+# mechanised here, and saying so is the point.
+echo "  [1/3] foreign numeric identifiers (range-derived from $OWN_SPEC + tasks)"
+
+# ⚠️ **Each prefix's range comes from the artifact that ALLOCATES it — not from every
+# artifact that mentions it.** Reading the range from spec.md *and* tasks.md was wrong and
+# the counter-example caught it: `tasks.md` quotes the foreign identifiers it must fix, so
+# the derived maximum came out as the *quoted* value instead of the *allocated* one — and a
+# range that has absorbed the very identifiers it should catch makes the whole class blind.
+# The measurer must not be fed the thing being measured.
+#
+# ⚠️ **Written here as the prefix form, never as a real identifier** (FR-053): this file is
+# a SHIPPED asset, so quoting the identifiers it exists to catch would ship one project's
+# numbers to every user — the comment forbidding the leak would itself be an instance of it.
+own_source() {  # $1 = prefix → the artifact that allocates it
+    case "$1" in
+        FR | US) echo "$OWN_SPEC" ;;
+        T)       echo "$OWN_TASKS" ;;
+        ISS)     echo "${ANTI_COUPLING_OWN_LEDGER:-$BASE/specs/implement_issues.md}" ;;
+        D)       echo "$OWN_SPEC" ;;
+    esac
+}
+
+own_max() {  # $1 = prefix. The project's highest allocated number for it.
+    src=$(own_source "$1")
+    [ -f "$src" ] || return
+    grep -rhoE "\b$1-[0-9]+" "$src" 2>/dev/null | grep -oE '[0-9]+' | sort -n | tail -1
+}
+
+derived_any=0
+foreign=""
+for prefix in FR US T ISS D; do
+    max=$(own_max "$prefix")
+    if [ -z "$max" ]; then
+        # Not every prefix is used by every project; an unused one has nothing to
+        # compare against, which is a legitimate zero, not a silent gap.
+        continue
+    fi
+    derived_any=1
+    # ⚠️ `$BASE/$root`, never a bare `$ASSETS`: the bare form resolves against the CALLER's
+    # cwd, so it scanned whatever directory happened to be named `commands` — correct when
+    # run from the repository root, wrong everywhere else, and silently so. The fixture
+    # tree caught it; the real-repo run could not have.
+    # ⚠️ **`-o` WITHOUT `-h`, and the filename kept** (ISS-116 / T165). The `-h` this used to
+    # carry suppressed the file name, so a finding named the identifier and nothing else —
+    # the report line could name the identifier but not the `location`, while classes 2 and
+    # 3 both print the file. An O1 finding whose reader has to search the tree for it is a
+    # finding half-delivered.
+    # ⚠️ The identifier is written as the prefix form here too (FR-053) — same reason as
+    # `own_source` above: this is a shipped asset.
+    #
+    # ⚠️ The deduplication is on the WHOLE line, not on the identifier: the same foreign
+    # number legitimately appears in two files, and `sort -u` over the id alone would
+    # collapse them into one — hiding the second location. Sorting the composed lines
+    # dedupes identical (id, file) pairs and keeps distinct files distinct.
+    for root in $ASSETS; do
+        [ -d "$BASE/$root" ] || continue
+        while IFS= read -r hit; do
+            [ -n "$hit" ] || continue
+            file=${hit%%:*}
+            id=$(printf '%s' "$hit" | sed 's/^[^:]*://' | grep -oE "[A-Za-z]+-[0-9]+" | head -1)
+            n=$(printf '%s' "$id" | grep -oE '[0-9]+')
+            [ "$n" -gt "$max" ] 2>/dev/null && foreign="$foreign$id ($prefix max=$max) ${file#$BASE/}"$'\n'
+        done < <(grep -roE "\b$prefix-[0-9]+" "$BASE/$root" 2>/dev/null || true)
+    done
+done
+
+if [ "$derived_any" = 0 ]; then
+    echo "    ✗ could not derive this project's own identifier ranges from $OWN_SPEC / $OWN_TASKS"
+    echo "      → with no range to compare against, EVERY identifier reads as foreign (noise)"
+    echo "        or none does (a silent pass). A scan that cannot tell its own numbers from"
+    echo "        a foreign one MUST NOT report clean."
+    FAIL=1
+elif [ -n "$foreign" ]; then
+    echo "    ✗ identifiers above this project's own range, in shipped assets:"
+    # Sorted for the same reason class 2 is: the enumeration order is an implementation
+    # detail of the scanner, and the parity contract is "same stdout" (FR-008).
+    # ⚠️ `-u`, and it dedupes the COMPOSED line: the same id hit twice in one file collapses,
+    # while the same id in two files does not — the two lines differ by their file name.
+    printf '%s' "$foreign" | sed '/^$/d' | LC_ALL=C sort -u | sed 's/^/        /'
+    echo "        → a reader outside this repository cannot resolve them (O1, HIGH)."
+    FAIL=1
+else
+    echo "    ✓ none"
+fi
+
+# --- classes 2 and 3: declared patterns ---------------------------------------------
+# ⚠️ The classes are spelled out here as the CLASS NAMES Pass O uses; the patterns are read
+# from the project file. Both must be non-empty — "缺一即不通过".
+check_class() {
+    local tag="$1" label="$2" severity="$3"
+    local n
+    n=$(grep -cE "^${tag}\|" "$PATTERNS" 2>/dev/null || true)
+    if [ "${n:-0}" -eq 0 ]; then
+        echo "    ✗ no patterns declared for this class in $PATTERNS"
+        echo "        → Pass O requires all three classes; an uncovered class is the finding,"
+        echo "          not a gap to note and move past."
+        FAIL=1
+        return
+    fi
+    # ⚠️ **A hit is a FINDING unless the pattern file lists it as reviewed** (T200).
+    # The patterns are a coarse word filter; a match cannot tell a worked example from a
+    # parallel list of alternatives, and `T177` triaged this class's hits into both. The
+    # triage is recorded in the pattern file as `reviewed::<class>::<regex>::<file>::<why>`,
+    # so the classification is an INPUT the reviewer can see and change — never a silent
+    # relaxation. Removing an entry restores its finding.
+    local hits="" reviewed_hits=""
+    while IFS='|' read -r _ regex why; do
+        [ -z "${regex:-}" ] && continue
+        for root in $ASSETS; do
+            [ -d "$BASE/$root" ] || continue
+            while IFS= read -r f; do
+                [ -n "$f" ] || continue
+                rel="${f#"$BASE"/}"
+                if grep -qF "reviewed::${tag}::${regex}::${rel}::" "$PATTERNS" 2>/dev/null; then
+                    reviewed_hits="$reviewed_hits        ($why) $rel"$'\n'
+                else
+                    hits="$hits        ($why) $rel"$'\n'
+                fi
+            done < <(grep -rlE "$regex" "$BASE/$root" 2>/dev/null || true)
+        done
+    done < <(grep -E "^${tag}\|" "$PATTERNS")
+    if [ -n "$reviewed_hits" ]; then
+        echo "    ⊘ reviewed generic reference(s) — NOT findings, each with its reason in"
+        echo "      $PATTERNS (remove an entry to restore it as a finding):"
+        printf '%s' "$reviewed_hits" | sed '/^$/d' | LC_ALL=C sort | sed 's/^/  /'
+    fi
+    if [ -n "$hits" ]; then
+        echo "    ✗ $label present in shipped assets ($severity):"
+        # ⚠️ Sorted, because the enumeration order is an implementation detail of the
+        # scanner (grep here, Get-ChildItem in the twin) and the parity contract is
+        # "same stdout". A correct set in a different order is still a different stdout.
+        printf '%s' "$hits" | sed '/^$/d' | LC_ALL=C sort | sed 's/^/  /'
+        FAIL=1
+    else
+        # ⚠️ Reported even when the ⊘ block above is present: "no findings" and "nothing was
+        # scanned" must not look alike, and the reviewed set is disclosed rather than hidden.
+        echo "    ✓ none"
+    fi
+}
+
+echo "  [2/3] host technology stack (patterns from $PATTERNS)"
+check_class "tech" "host technology stack" "O2, HIGH"
+
+echo "  [3/3] host business terms and module names (patterns from $PATTERNS)"
+check_class "term" "host business term / module name" "O3, HIGH"
+
+# --- verdict --------------------------------------------------------------------------
+echo
+if [ "$FAIL" = 0 ]; then
+    echo "✓ anti-coupling: no findings across all three classes"
+    exit 0
+else
+    echo "✗ anti-coupling: FINDINGS (see above)"
+    echo "  → Pass O reports only; the fix is a tool-source change. Register it in the"
+    echo "    [tasks] section of specs/implement_issues.md — a finding without a route is"
+    echo "    indistinguishable from one never reported. And the fix has TWO halves: remove"
+    echo "    the trace, AND add the pattern that would have caught it."
+    exit 1
+fi

specpro_cli/assets/scripts/bash/check-prerequisites.sh

@@ -0,0 +1,176 @@
+#!/usr/bin/env bash
+
+# Consolidated prerequisite checking script
+#
+# This script provides unified prerequisite checking for Spec-Driven Development workflow.
+# It replaces the functionality previously spread across multiple scripts.
+#
+# Usage: ./check-prerequisites.sh [OPTIONS]
+#
+# OPTIONS:
+#   --json              Output in JSON format
+#   --require-tasks     Require tasks.md to exist (for implementation phase)
+#   --include-tasks     Include tasks.md in AVAILABLE_DOCS list
+#   --paths-only        Only output path variables (no validation)
+#   --help, -h          Show help message
+#
+# OUTPUTS:
+#   JSON mode: {"FEATURE_DIR":"...", "AVAILABLE_DOCS":["..."]}
+#   Text mode: FEATURE_DIR:... \n AVAILABLE_DOCS: \n ✓/✗ file.md
+#   Paths only: REPO_ROOT: ... \n BRANCH: ... \n FEATURE_DIR: ... etc.
+
+set -e
+
+# Parse command line arguments
+JSON_MODE=false
+REQUIRE_TASKS=false
+INCLUDE_TASKS=false
+PATHS_ONLY=false
+
+for arg in "$@"; do
+    case "$arg" in
+        --json)
+            JSON_MODE=true
+            ;;
+        --require-tasks)
+            REQUIRE_TASKS=true
+            ;;
+        --include-tasks)
+            INCLUDE_TASKS=true
+            ;;
+        --paths-only)
+            PATHS_ONLY=true
+            ;;
+        --help|-h)
+            cat << 'EOF'
+Usage: check-prerequisites.sh [OPTIONS]
+
+Consolidated prerequisite checking for Spec-Driven Development workflow.
+
+OPTIONS:
+  --json              Output in JSON format
+  --require-tasks     Require tasks.md to exist (for implementation phase)
+  --include-tasks     Include tasks.md in AVAILABLE_DOCS list
+  --paths-only        Only output path variables (no prerequisite validation)
+  --help, -h          Show this help message
+
+EXAMPLES:
+  # Check task prerequisites (plan.md required)
+  ./check-prerequisites.sh --json
+  
+  # Check implementation prerequisites (plan.md + tasks.md required)
+  ./check-prerequisites.sh --json --require-tasks --include-tasks
+  
+  # Get feature paths only (no validation)
+  ./check-prerequisites.sh --paths-only
+  
+EOF
+            exit 0
+            ;;
+        *)
+            echo "ERROR: Unknown option '$arg'. Use --help for usage information." >&2
+            exit 1
+            ;;
+    esac
+done
+
+# Source common functions
+SCRIPT_DIR="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/common.sh"
+
+# Get feature paths
+eval $(get_feature_paths)
+
+# If paths-only mode, output paths and exit (support JSON + paths-only combined)
+if $PATHS_ONLY; then
+    if $JSON_MODE; then
+        # Minimal JSON paths payload (no validation performed)
+        printf '{"REPO_ROOT":"%s","BRANCH":"%s","FEATURE_SCOPE":"%s","FEATURE_DIR":"%s","FEATURE_SPEC":"%s","IMPL_PLAN":"%s","TASKS":"%s"}\n' \
+            "$REPO_ROOT" "$CURRENT_BRANCH" "$FEATURE_SCOPE" "$FEATURE_DIR" "$FEATURE_SPEC" "$IMPL_PLAN" "$TASKS"
+    else
+        echo "REPO_ROOT: $REPO_ROOT"
+        echo "BRANCH: $CURRENT_BRANCH"
+        echo "FEATURE_SCOPE: $FEATURE_SCOPE"
+        echo "FEATURE_DIR: $FEATURE_DIR"
+        echo "FEATURE_SPEC: $FEATURE_SPEC"
+        echo "IMPL_PLAN: $IMPL_PLAN"
+        echo "TASKS: $TASKS"
+    fi
+    exit 0
+fi
+
+# Validate required directories and files
+if [[ ! -d "$FEATURE_DIR" ]]; then
+    echo "ERROR: Feature directory not found: $FEATURE_DIR" >&2
+    echo "Run /specpro-specify first to create the feature structure." >&2
+    exit 1
+fi
+
+if [[ ! -f "$IMPL_PLAN" ]]; then
+    echo "ERROR: plan.md not found in $FEATURE_DIR" >&2
+    echo "Run /specpro-plan first to create the implementation plan." >&2
+    exit 1
+fi
+
+# Check for tasks.md if required
+if $REQUIRE_TASKS && [[ ! -f "$TASKS" ]]; then
+    echo "ERROR: tasks.md not found in $FEATURE_DIR" >&2
+    echo "Run /specpro-tasks first to create the task list." >&2
+    exit 1
+fi
+
+# Build list of available documents
+docs=()
+
+# CRITICAL: spec.md is the primary specification document
+# Created by /specpro-specify, read by all subsequent commands
+[[ -f "$FEATURE_SPEC" ]] && docs+=("spec.md")
+
+# Always check these optional docs
+[[ -f "$RESEARCH" ]] && docs+=("research.md")
+[[ -f "$DATA_MODEL" ]] && docs+=("data-model.md")
+
+# Check contracts directory (only if it exists and has files)
+if [[ -d "$CONTRACTS_DIR" ]] && [[ -n "$(ls -A "$CONTRACTS_DIR" 2>/dev/null)" ]]; then
+    docs+=("contracts/")
+fi
+
+[[ -f "$QUICKSTART" ]] && docs+=("quickstart.md")
+
+# Include tasks.md if requested and it exists
+if $INCLUDE_TASKS && [[ -f "$TASKS" ]]; then
+    docs+=("tasks.md")
+fi
+
+# Include test-tasks.md if it exists (optional high-level test plan; never required)
+[[ -f "$TEST_TASKS" ]] && docs+=("test-tasks.md")
+
+# Output results
+if $JSON_MODE; then
+    # Build JSON array of documents
+    if [[ ${#docs[@]} -eq 0 ]]; then
+        json_docs="[]"
+    else
+        json_docs=$(printf '"%s",' "${docs[@]}")
+        json_docs="[${json_docs%,}]"
+    fi
+    
+    printf '{"FEATURE_DIR":"%s","FEATURE_SCOPE":"%s","AVAILABLE_DOCS":%s}\n' "$FEATURE_DIR" "$FEATURE_SCOPE" "$json_docs"
+else
+    # Text output
+    echo "FEATURE_DIR:$FEATURE_DIR"
+    echo "AVAILABLE_DOCS:"
+
+    # Show status of each potential document
+    check_file "$FEATURE_SPEC" "spec.md"
+    check_file "$RESEARCH" "research.md"
+    check_file "$DATA_MODEL" "data-model.md"
+    check_dir "$CONTRACTS_DIR" "contracts/"
+    check_file "$QUICKSTART" "quickstart.md"
+
+    if $INCLUDE_TASKS; then
+        check_file "$TASKS" "tasks.md"
+    fi
+
+    check_file "$TEST_TASKS" "test-tasks.md"
+fi

specpro_cli/assets/scripts/bash/common.sh

@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+# Common functions and variables for all scripts
+
+# Get repository root, with fallback for non-git repositories
+get_repo_root() {
+    if git rev-parse --show-toplevel >/dev/null 2>&1; then
+        git rev-parse --show-toplevel
+    else
+        # Fall back to script location for non-git repos
+        local script_dir="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+        (cd "$script_dir/../../.." && pwd)
+    fi
+}
+
+# Get current branch (for informational purposes only)
+# NOTE: Branch information is NOT used for directory structure
+# All spec files are stored directly in specs/ directory
+get_current_branch() {
+    # Check git if available
+    if git rev-parse --abbrev-ref HEAD >/dev/null 2>&1; then
+        git rev-parse --abbrev-ref HEAD
+        return
+    fi
+
+    echo "unknown"  # Fallback for non-git repos
+}
+
+# Check if we have git available
+has_git() {
+    git rev-parse --show-toplevel >/dev/null 2>&1
+}
+
+# Get feature paths - all files are in specs/ root directory
+get_feature_paths() {
+    local repo_root=$(get_repo_root)
+    local current_branch=$(get_current_branch)
+    local has_git_repo="false"
+
+    if has_git; then
+        has_git_repo="true"
+    fi
+
+    # All spec files are in specs/ root directory (no branch subdirectories)
+    local specs_dir="$repo_root/specs"
+
+    # ── Feature-scope detection (FR-063 / T050, v0.23) ──
+    # cwd inside specs/fNNN-简称/ ⇒ feature scope: spec/plan/tasks/test-tasks
+    # resolve to THAT directory; constitution/research stay mother-side
+    # (living-reference inheritance, FR-014). Greppable anchors: 「feature 作用域」/「母作用域」
+    local scope_dir="$(pwd -P)"
+    local in_feature="false"
+    case "$scope_dir" in
+        */specs/f[0-9][0-9][0-9]-*) in_feature="true" ;;
+    esac
+
+    local fd implan tasks tt
+    if [ "$in_feature" = "true" ]; then
+        fd="$scope_dir"
+        implan="$scope_dir/plan.md"
+        tasks="$scope_dir/tasks.md"
+        tt="$scope_dir/test-tasks.md"
+    else
+        fd="$specs_dir"
+        implan="$specs_dir/plan.md"
+        tasks="$specs_dir/tasks.md"
+        tt="$specs_dir/test-tasks.md"
+    fi
+
+    # FEATURE_SCOPE: 'true' = feature 作用域 / 'false' = 母作用域 (FR-063)
+    cat <<EOF
+FEATURE_SCOPE='$in_feature'
+REPO_ROOT='$repo_root'
+CURRENT_BRANCH='$current_branch'
+HAS_GIT='$has_git_repo'
+FEATURE_DIR='$fd'
+FEATURE_SPEC='$fd/spec.md'
+IMPL_PLAN='$implan'
+TASKS='$tasks'
+RESEARCH='$specs_dir/research.md'
+DATA_MODEL='$specs_dir/data-model.md'
+QUICKSTART='$specs_dir/quickstart.md'
+TEST_TASKS='$tt'
+CONTRACTS_DIR='$fd/contracts'
+EOF
+}
+
+check_file() { [[ -f "$1" ]] && echo "  ✓ $2" || echo "  ✗ $2"; }
+check_dir() { [[ -d "$1" && -n $(ls -A "$1" 2>/dev/null) ]] && echo "  ✓ $2" || echo "  ✗ $2"; }