specpro-cli 0.1.0__py3-none-any.whl

specpro_cli/assets/commands/specpro.constitution.md

@@ -0,0 +1,488 @@
+---
+description: Guide project constitution creation through AI auto-determination of project nature, clause extraction from embedded library, and automatic quality standards generation with multi-language template support.
+handoffs:
+  - label: Build Specification
+    agent: specpro-specify
+    prompt: Implement the feature specification based on the generated constitution. I want to build...
+writes:
+  # This command's write surface: only what it produces AS THE PRODUCER of that
+  # (artifact, unit) pair. A write this command makes on a non-producer path is a
+  # boundary violation by definition (FR-051) and MUST NOT be declared here.
+  # The full ownership map is the UNION of every command's writes: block.
+  - artifact: specs/constitution.md
+    unit: "whole file - the constitution it produces, including the Amendment Record"
+  - artifact: specs/implement_issues.md
+    unit: "the [constitution] section's entries marked [x]; the statistics table (**its own row only** — seven commands declare this artifact); appended ISS-NNN entries in any section — registration is routing; only [x]-marking is section-scoped"
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding. User input may include a project description (in the user's language) or be empty.
+
+**Rerun safety — detect the artifact, default to incremental** ⚠️ [settled 2026-09-13]:
+
+**Before writing `specs/constitution.md`, detect whether it already exists.** Use the SAME check in every command:
+
+```bash
+[ -s specs/constitution.md ] && echo EXISTS || echo NEW    # -s: exists AND non-empty (an empty placeholder counts as NEW)
+```
+
+| Detection | Mode |
+|-----------|------|
+| **NEW** (absent or empty) | **Initial** — generate from scratch |
+| **EXISTS** | **Incremental** — evolve it; **never silently regenerate from scratch** |
+
+⚠️ **This command carries the heaviest consequence of any in the set**: the constitution is the project's foundation — every downstream command reads it, and principles derived from it are baked into plan / tasks / test-plan. Regenerating it from scratch **silently invalidates all of that**.
+
+**Overwriting an existing constitution requires explicit, confirmed intent:**
+1. Only when the user *explicitly* asks (in their own words) does the initial path run on an existing constitution.
+2. **Even then, confirm once more before writing** — name what will be replaced and what downstream artifacts (plan · tasks · test-plan · test-tasks) will be left resting on the old text; wait for the answer.
+3. **Silence is not consent.** An unspecified run on an existing constitution is ALWAYS incremental.
+
+> **Why a shared rule rather than per-command courtesy**: nine of the twelve non-implementation commands already had some protection, but each wrote it its own way (`EXISTING_SPEC` check · "creates a NEW file" · `NEVER overwrite` · "incremental regeneration" · `AUTO_MODE=false`), and **three had none at all — this one among them**. Overwriting an artifact the user has been evolving is not recoverable within the session; the cost of asking is one prompt.
+
+
+### Scope Resolution 🆕 (FR-063 / T050 · v0.23)
+
+1. **作用域判定**: 当前工作目录位于 `specs/fNNN-简称/` 内 ⇒ **feature 作用域**(读写范围 = 本 feature 目录,由 `check-prerequisites.sh` 的作用域感知解析);位于仓库根或 `specs/` 根 ⇒ **母作用域**(读写母规格链)。feature 作用域内 MUST NOT 写母产物——唯一例外:**发现登记**(台账路由,`[specify]`/`[plan]` 分区)。
+2. **新会话首次执行**: 若 `specs/features.md` 存在且含 `active` 行、而用户未指明作用域 ⇒ **询问用户**在母作用域还是某个 feature 内工作,MUST NOT 自行挑选。
+3. 本命令的产物路径随之解析:feature 作用域下落 `<feature 目录>/`,母作用域下落 `specs/`。
+
+## Outline
+
+This command uses a **guided AI-determination approach** with embedded clause library and **multi-language template support**. The process follows:
+
+1. **Language Configuration**: Set artifact language FIRST (before loading template)
+2. **Project Nature Assessment**: AI determines project type and calculates quality standards
+3. **Clauses Extraction**: Auto-extract appropriate clauses from embedded library
+4. **Technical Traits Selection**: User confirms technical characteristics
+5. **Template Loading**: Load language-specific template based on user choice
+6. **Constitution Generation**: Generate appropriate constitution in target language
+7. **Final Output**: Write constitution file
+
+Follow this execution flow:
+
+**CRITICAL: Language Configuration MUST happen BEFORE template loading to prevent AI language confusion**
+
+**Branch: `--review-issues`** ⚠️ [when passed, this **replaces steps 0–8 below** — it is not an extra step in the flow]
+
+This is the **only** consumer of the `[constitution]` section in `specs/implement_issues.md`. The
+constitution is the project's foundation, so an amendment arriving by this route is a **targeted
+edit of specific clauses**, never a regeneration — steps 0–8 generate a constitution from scratch
+and MUST NOT run on this branch.
+
+a. **Detect, then ask** (when `--review-issues` was not passed):
+   - Read the `[constitution]` section of `specs/implement_issues.md`; filter open `[ ]` entries.
+   - **None** → continue with the normal flow (steps 0–8). **No prompt.**
+   - **Some** → **ask**: "N open `[constitution]` issues. Process them first, or run normally?"
+     *Process first* → continue below. *Run normally* → continue with steps 0–8.
+   - **Rationale**: the flag used to be the whole switch — not passing it left pending issues
+     **silently unprocessed**, and **which issues were pending was invisible until the command
+     ran**. Detect-then-ask makes it an explicit choice; the flag only means *"don't ask me"*.
+
+b. **If there is nothing to process** (no file, or no open `[ ]` entry in `[constitution]`):
+   display `✓ No pending [constitution] issues to process` and exit. Do not run steps 0–8.
+
+c. **Process each open entry, in file order**:
+   - Read the entry's Problem / Recommendation / Evidence.
+   - Apply it as a **targeted edit to `specs/constitution.md`** — the specific clause it names.
+     ⚠️ **A carve-out or exception MUST be written as a CATEGORY, never as an instance**: a
+     clause reading "`<one named file>` is exempt" is a rule that governs exactly one file, and
+     the next member of its class falls through it untouched.
+   - ⚠️ **Write the enforcement point** (Core Principle I): **which step triggers it, what
+     condition fails, who stops.** A clause with no enforcement point is a statement, and the
+     Governance section's own rule is that such a clause **should be deleted rather than kept as
+     decoration** — so an amendment that cannot name one must be reported back, not written in.
+   - Mark **that entry** `[x]` in `specs/implement_issues.md`, and update that section's row in
+     the statistics table. ⚠️ **Marking is section-scoped: never mark another section's entries
+     `[x]`.**
+     ⚠️ **Appending is NOT section-scoped** — **登记即路由**: a command registers a finding in
+     whichever section owns its **fix**, not in its own. That is the ledger's **only** routing
+     act, and a rule reading "each commands owns only its own section" **abolishes it** while
+     looking like a tidiness rule. ⚠️ **The two acts must not be derived from one another.**
+     (Truth: `specs/contracts/ledger.md` → `## Write boundary` — **pointed at, not restated**.)
+
+d. **Same round, no exceptions** ⚠️ [the half-recorded amendment is the failure this prevents]:
+   - Update `**Version**` and `**Last Amended**` in `specs/constitution.md`.
+   - Append the `Amendment Record` row — including the **受影响既有产物** column: name the
+     artifacts that depended on the clause as it was. An amendment that silently invalidates a
+     downstream derivation leaves it reading as if nothing changed.
+   - Run `.specpro/scripts/bash/verify-ledger.sh` and fix any violation before continuing.
+     ⚠️ Marking entries `[x]` changes the counts, so this applies here too.
+
+e. **Then report** what was amended, and which artifacts the Amendment Record now lists as affected.
+
+0. **Language Configuration** 🌐 [FIRST STEP - BEFORE TEMPLATE LOADING]:
+
+   **a. Detect interaction language**: `INTERACTION_LANGUAGE = "zh" if Chinese detected, "en" otherwise`
+
+   **b. Display language selection**:
+   ```markdown
+   🌐 Artifact Language
+
+   Select the language for the generated constitution:
+
+   1️⃣ **English** (en) - Generate constitution in English
+   2️⃣ **Chinese** (zh) - Generate constitution in Chinese
+   3️⃣ **Japanese** (ja) - Generate constitution in Japanese
+   4️⃣ **Korean** (ko) - Generate constitution in Korean
+
+   Your choice (1-4):
+   ```
+
+   **c. Set artifact language**: `ARTIFACT_LANGUAGE = selected code ("en", "zh", "ja", "ko")`
+
+   **d. Store for template selection**: `TEMPLATE_PATH = .specpro/templates/constitution-template.md` (single skeleton, shared by all artifact languages)
+
+1. **Load classification and clause frameworks**:
+   - The classification framework and clause library are embedded below (no external dependencies)
+   - Template will be loaded in step 5 AFTER language is determined
+
+**PROJECT CLASSIFICATION FRAMEWORK** 📊 (Embedded reference)
+
+**6 Project Types** (For AI auto-determination):
+- **Type 1 - Prototype/MVP**: Concept validation, proof of concept, demo, no long-term maintenance
+- **Type 2 - Personal/Team Tool**: Productivity scripts, internal utilities, helper tools, very small user base
+- **Type 3 - Enterprise Internal App**: Internal OA systems, admin panels, department tools, no external exposure
+- **Type 4 - General Business App**: External-facing business systems for regular users, customer-facing
+- **Type 5 - Platform/Middleware**: Critical infrastructure, shared dependencies, component libraries, APIs
+- **Type 6 - High-Risk/Compliant**: Financial, medical, government, security, life-safety related
+
+**Quality Assurance Matrix** (Auto-calculated based on PROJECT_TYPE):
+| PROJECT_TYPE | HIGH-RISK Coverage | MEDIUM-RISK Coverage | LOW-RISK Coverage |
+|--------------|-------------------|---------------------|------------------|
+| Type 1 (Prototype/MVP) | 70% | 50% | 0% |
+| Type 2 (Personal/Team Tool) | 80% | 60% | 0% |
+| Type 3 (Enterprise Internal App) | 85% | 70% | 30% |
+| Type 4 (General Business App) | 90% | 75% | 40% |
+| Type 5 (Platform/Middleware) | 95% | 85% | 50% |
+| Type 6 (High-Risk/Compliant) | 98% | 90% | 70% |
+
+**Risk Assessment Criteria** (For downstream workflows to classify individual modules):
+- **HIGH Risk Indicators**: Financial transactions, payment processing, medical data, government services, authentication systems
+- **MEDIUM Risk Indicators**: User data processing, business logic, API endpoints, database operations, session management
+- **LOW Risk Indicators**: UI components, helper functions, development tools, diagnostic features, configuration management
+
+**CLAUSES LIBRARY** 📚 (Embedded reference for clause extraction)
+
+**Universal Clauses** (Required for ALL projects):
+- **1.1 Version Control**: Git-based tracking, meaningful commits, branch protection, PR reviews
+- **1.2 Documentation Requirements**: API docs, architecture diagrams, README, CHANGELOG
+- **1.3 Code Quality**: Linting, complexity limits, no hardcoded credentials, meaningful naming
+
+**Type-Specific Clauses** (Based on PROJECT_TYPE):
+- **2.1 Prototype/MVP**: Rapid Iteration - Speed over perfection, technical debt acceptable, minimal docs
+- **2.2 Personal/Team Tool**: Simplified Process - Core functionality tested, UI optional, basic error handling
+- **2.3 Enterprise Internal App**: Internal Stability - Business logic tested, data integrity critical, internal auth
+- **2.4 General Business App**: User Experience - User-facing features tested, performance optimized, user-friendly errors
+- **2.5 Platform/Middleware**: Reliability - Near-zero downtime, backwards compatibility, performance SLAs
+- **2.6 High-Risk/Compliant**: Compliance - Regulatory compliance, security audits, data protection, incident response
+
+**Risk-Specific Clauses** (Based on project characteristics):
+- **3.1 HIGH Risk**: Security First - Security reviews, penetration testing, encryption, strict access controls
+- **3.2 MEDIUM Risk**: Quality Assurance - Code reviews, integration testing, performance testing, logging standards
+- **3.3 LOW Risk**: Basic Quality - Core functionality testing, simplified reviews, basic error handling
+
+**Technical Clauses** (User-confirmed characteristics):
+- **4.1 Multiplatform Architecture**: Shared code platform-independent, platform-specific code isolated, consistent behavior
+- **4.2 Protocol-Oriented Design**: Protocols documented, independently testable, version compatibility requirements
+- **4.3 Performance Critical**: Performance requirements defined, performance testing mandatory, resource limits
+
+2. **Project Nature Assessment** 🤖 [AI AUTO-DETERMINATION]:
+
+   **a. Extract project description from user input**:
+   - If `$ARGUMENTS` contains project description: Extract keywords and context
+   - If `$ARGUMENTS` is empty: Ask user to describe their project briefly
+   - Example inputs to handle:
+     * "I want to build a personal accounting tool"
+     * "Enterprise internal OA system"
+     * "Financial trading platform"
+     * Empty → Prompt: "Please briefly describe your project:"
+
+   **b. AI determines project type** (NO user selection):
+   - Analyze project description against the 6 project types in PROJECT CLASSIFICATION FRAMEWORK
+   - **Keywords analysis**: Identify project characteristics from description
+   - **Auto-select project type** based on analysis:
+     * **Type 1 (Prototype/MVP)**: Keywords like "demo", "proof of concept", "test", "MVP", "prototype"
+     * **Type 2 (Personal/Team Tool)**: Keywords like "personal tool", "utility", "helper", "small team", "script"
+     * **Type 3 (Enterprise Internal App)**: Keywords like "internal", "OA", "admin", "CMS", "HR system"
+     * **Type 4 (General Business App)**: Keywords like "e-commerce", "SaaS", "platform", "user-facing", "business"
+     * **Type 5 (Platform/Middleware)**: Keywords like "library", "component", "infrastructure", "API", "framework"
+     * **Type 6 (High-Risk/Compliant)**: Keywords like "financial", "trading", "medical", "payment", "government"
+   - **Store result**: `PROJECT_TYPE = [1-6]`
+
+   **c. AI determines quality assurance standards** (based on PROJECT_TYPE):
+   - Use the Quality Assurance Matrix from PROJECT CLASSIFICATION FRAMEWORK
+   - **Auto-calculate coverage targets**:
+     * Type 1: `HIGH_RISK_COVERAGE = "70%"`, `MEDIUM_RISK_COVERAGE = "50%"`, `LOW_RISK_COVERAGE = "0%"`
+     * Type 2: `HIGH_RISK_COVERAGE = "80%"`, `MEDIUM_RISK_COVERAGE = "60%"`, `LOW_RISK_COVERAGE = "0%"`
+     * Type 3: `HIGH_RISK_COVERAGE = "85%"`, `MEDIUM_RISK_COVERAGE = "70%"`, `LOW_RISK_COVERAGE = "30%"`
+     * Type 4: `HIGH_RISK_COVERAGE = "90%"`, `MEDIUM_RISK_COVERAGE = "75%"`, `LOW_RISK_COVERAGE = "40%"`
+     * Type 5: `HIGH_RISK_COVERAGE = "95%"`, `MEDIUM_RISK_COVERAGE = "85%"`, `LOW_RISK_COVERAGE = "50%"`
+     * Type 6: `HIGH_RISK_COVERAGE = "98%"`, `MEDIUM_RISK_COVERAGE = "90%"`, `LOW_RISK_COVERAGE = "70%`
+   - **Store results**: `HIGH_RISK_COVERAGE`, `MEDIUM_RISK_COVERAGE`, `LOW_RISK_COVERAGE`
+
+3. **Clauses Extraction** 📚 [AUTO-EXTRACTION FROM EMBEDDED LIBRARY]:
+
+   **a. Extract mandatory clauses** (P0 - Universal + Type-Specific):
+   - **Universal Clauses** (ALL projects):
+     * 1.1 Version Control: Git-based tracking, meaningful commits, branch protection, PR reviews
+     * 1.2 Documentation Requirements: API docs, architecture diagrams, README, CHANGELOG
+     * 1.3 Code Quality: Linting, complexity limits, no hardcoded credentials
+   - **Type-Specific Clause** (Based on PROJECT_TYPE):
+     * Type 1: Rapid Iteration Clause
+     * Type 2: Simplified Process Clause
+     * Type 3: Internal Stability Clause
+     * Type 4: User Experience Clause
+     * Type 5: Reliability Clause
+     * Type 6: Compliance Clause
+   - **Store**: `EXTRACTED_CLAUSES_P0 = [Universal_3_Clauses + Type_1_Clause]`
+
+   **b. Extract risk-specific clauses** (P1):
+   - **Risk-Specific Clause** (Based on project characteristics):
+     * HIGH Risk characteristics detected: Security First Clause
+     * MEDIUM Risk characteristics detected: Quality Assurance Clause
+     * LOW Risk characteristics detected: Basic Quality Clause
+   - **Quality Assurance Clauses** (From matrix):
+     * 5.1 Test Coverage Requirements: HIGH-RISK >[XX]%, MEDIUM-RISK >[YY]%, LOW-RISK >[ZZ]%
+     * 5.2 Code Review Requirements: Based on PROJECT_TYPE strictness level
+   - **Store**: `EXTRACTED_CLAUSES_P1 = [Risk_Clause + QA_2_Clauses]`
+
+   **c. Extract technical trait clauses** (P2 - User-confirmed characteristics):
+
+   **AI auto-detection** (based on project description keywords):
+   - **Architecture Traits**:
+     * Multiplatform: keywords like "multiplatform", "cross-platform", "iOS & Android", "desktop & mobile"
+     * Microservices: keywords like "microservice", "distributed", "service mesh"
+     * Event-Driven: keywords like "event-driven", "async", "message queue", "kafka"
+     * Layered Architecture: keywords like "layered", "MVC", "tiered architecture"
+   - **Interface Traits**:
+     * RESTful API: keywords like "REST", "RESTful", "HTTP API", "REST API"
+     * GraphQL: keywords like "GraphQL", "GQL", "graph"
+     * gRPC: keywords like "gRPC", "rpc", "protobuf"
+     * WebSocket: keywords like "WebSocket", "realtime", "socket", "ws://"
+     * Webhook: keywords like "webhook", "callback", "notification"
+   - **Data Traits**:
+     * Data-Intensive: keywords like "big data", "analytics", "data warehouse", "reporting"
+     * Realtime Data: keywords like "realtime", "streaming", "low latency", "live"
+     * High Concurrency: keywords like "high concurrency", "scale", "concurrent", "thousands of users"
+     * Data Consistency: keywords like "transactional", "ACID", "financial", "payment", "inventory"
+
+   **Display technical traits selection menu**:
+   ```markdown
+   🔧 Technical Traits Confirmation
+
+   Based on your project description, AI detected the following technical traits:
+   [AI-detected traits list]
+
+   Please confirm or modify your technical traits:
+
+   **Architecture Traits**:
+   ☐ 1.1 Multiplatform Architecture
+   ☐ 1.2 Microservices Architecture
+   ☐ 1.3 Event-Driven Architecture
+   ☐ 1.4 Layered Architecture
+
+   **Interface Traits**:
+   ☐ 2.1 RESTful API
+   ☐ 2.2 GraphQL API
+   ☐ 2.3 gRPC API
+   ☐ 2.4 WebSocket
+   ☐ 2.5 Webhook
+
+   **Data Traits**:
+   ☐ 3.1 Data-Intensive
+   ☐ 3.2 Realtime Data
+   ☐ 3.3 High Concurrency
+   ☐ 3.4 Data Consistency Critical
+
+   **Performance Traits**:
+   ☐ 4.1 Low Latency Requirements
+   ☐ 4.2 High Throughput Requirements
+   ☐ 4.3 Resource Constrained
+
+   **Security Traits**:
+   ☐ 5.1 Authentication/Authorization
+   ☐ 5.2 Data Encryption
+   ☐ 5.3 Audit Logging
+   ☐ 5.4 Data Masking
+
+   **Protocol Traits**:
+   ☐ 6.1 Protocol-Oriented Design
+   ☐ 6.2 Streaming Protocol
+   ☐ 6.3 Message Queue
+
+   **Deployment Traits**:
+   ☐ 7.1 Containerization
+   ☐ 7.2 Serverless
+   ☐ 7.3 Edge Computing
+
+   **Monitoring Traits**:
+   ☐ 8.1 Observability
+   ☐ 8.2 Debuggability
+
+   **Testing Traits**:
+   ☐ 9.1 Test-Driven Development
+   ☐ 9.2 Behavior-Driven Development
+
+   **Extensibility Traits**:
+   ☐ 10.1 Plugin Architecture
+   ☐ 10.2 Scalability
+
+   **Selection Guide**:
+   - Use ☑️ to select applicable traits
+   - AI will pre-select based on project description
+   - Not all traits apply to every project
+   - Select traits that impact your development approach
+
+   Enter selections (e.g., "1.1 2.1 3.4" or "confirmed" to accept AI suggestions):
+   ```
+
+   **Handle user input**:
+   - If "confirmed": Use AI-detected traits
+   - If specific trait IDs (e.g., "1.1 2.1 3.4"): Parse and use selected traits
+   - If empty: Ask for at least one selection
+
+   **Extract corresponding technical clauses**:
+   For each selected trait, include the corresponding technical clause:
+   - Architecture trait → Clause defines architecture requirements
+   - Interface trait → Clause defines interface and communication requirements
+   - Data trait → Clause defines data handling and consistency requirements
+   - Performance trait → Clause defines performance and resource requirements
+   - Security trait → Clause defines security and compliance requirements
+   - Protocol trait → Clause defines protocol and communication requirements
+   - Deployment trait → Clause defines deployment and infrastructure requirements
+   - Monitoring trait → Clause defines observability and debuggability requirements
+   - Testing trait → Clause defines testing methodology requirements
+   - Extensibility trait → Clause defines extension and scalability requirements
+
+   - **Store**: `EXTRACTED_CLAUSES_P2 = [Technical_Clauses for all selected traits]`
+
+   **d. Display extracted technical clauses for confirmation**:
+   ```markdown
+   🔧 Technical Clauses Selected
+
+   [List of selected technical traits with their corresponding clauses]
+
+   Total technical clauses extracted: [N]
+
+   Confirm these technical clauses? (yes/modify)
+   ```
+
+   **e. Handle user confirmation**:
+   - If "yes": Proceed with extracted technical clauses
+   - If "modify": Allow user to add/remove specific traits, re-extract
+   - **Finalize**: `EXTRACTED_CLAUSES_P2 = [All confirmed technical clauses]`
+
+4. **Load Template** 📄 [AFTER LANGUAGE CONFIGURATION]:
+
+   **CRITICAL**: Template loading happens AFTER language selection to prevent AI confusion
+
+   **a. Single skeleton template (language-independent)**:
+   - `TEMPLATE_PATH = .specpro/templates/constitution-template.md`
+   - This is the ONLY constitution template, used for ALL artifact languages
+   - Fixed structural anchors in the skeleton (section headings such as `Core Principles`, `Governance`; the `Version` / `Ratified` / `Last Amended` labels) are ALWAYS English, regardless of [ARTIFACT_LANGUAGE]
+   - Placeholder VALUES (`[PRINCIPLE_N_NAME]`, `[SECTION_N_CONTENT]`, etc.) are generated content, NOT anchors: replace them in [ARTIFACT_LANGUAGE]
+
+   **b. Read template content**: Load the template file content
+
+5. **Draft the constitution content** 📝 [IN TARGET LANGUAGE]:
+
+   **a. CRITICAL LANGUAGE INSTRUCTION (two-layer language rule)**:
+   ```markdown
+   **LANGUAGE REQUIREMENT**:
+   - ALL constitution PROSE content MUST be generated in: [ARTIFACT_LANGUAGE]
+   - Ignore the language of examples in the template
+   - Structural anchors are ALWAYS English, regardless of [ARTIFACT_LANGUAGE]:
+     * Section headings: `Core Principles`, `Governance`, `Project Clauses`
+     * Field labels: `Version`, `Ratified`, `Last Amended`, `Artifact Language`
+   - Generated content (principle names/descriptions, section content, governance rules) MUST be in [ARTIFACT_LANGUAGE]
+   - Technical terms may remain in English (API, REST, JSON, etc.)
+   ```
+
+   **b. Replace placeholders**:
+   - `[PROJECT_NAME]` → Derived from input (in target language)
+   - `[CONSTITUTION_VERSION]` → "1.0.0" or increment
+   - `[RATIFICATION_DATE]` → Today (YYYY-MM-DD)
+   - `[LAST_AMENDED_DATE]` → Today (YYYY-MM-DD)
+   - `[PRINCIPLE_N_NAME]` → Principle name in target language
+   - `[PRINCIPLE_N_DESCRIPTION]` → Principle description in target language
+   - `[SECTION_N_NAME]` → Section name in target language
+   - `[SECTION_N_CONTENT]` → Section content in target language
+   - `[GOVERNANCE_RULES]` → Governance rules in target language
+
+   **c. Add Project Clauses section** (content in [ARTIFACT_LANGUAGE]):
+   ```markdown
+   ## Project Clauses
+
+   **Universal Clauses**:
+   - 1.1 Version Control: [details in ARTIFACT_LANGUAGE]
+   - 1.2 Documentation: [details in ARTIFACT_LANGUAGE]
+   - 1.3 Code Quality: [details in ARTIFACT_LANGUAGE]
+
+   **Type-Specific Clause** ([Type_N]): [content in ARTIFACT_LANGUAGE]
+
+   **Risk-Specific Clause** ([Risk_Level]): [content in ARTIFACT_LANGUAGE]
+
+   **Quality Assurance Clauses**:
+   - Test Coverage: HIGH >[XX]%, MEDIUM >[YY]%, LOW >[ZZ]%
+   - Code Review: [requirements in ARTIFACT_LANGUAGE]
+
+   [Technical Clauses if applicable, in ARTIFACT_LANGUAGE]
+   ```
+
+   **d. Add Artifact Language section**:
+   ```markdown
+   **Artifact Language**: [ARTIFACT_LANGUAGE]
+   **Purpose**: Define language for generated specs and artifacts
+   ```
+
+   **e. Include/exclude principles**:
+   - Based on project type and user-confirmed technical characteristics
+   - Remove unused principle sections entirely
+
+6. **Quality validation** ✅:
+
+   **a. Language consistency check**:
+   - Verify ALL prose content is in [ARTIFACT_LANGUAGE]
+   - Check for language mixing (except technical terms and the fixed English structural anchors listed in Step 5a)
+
+   **b. Check placeholders**: No `[ALL_CAPS_IDENTIFIER]` tokens remain
+
+   **c. Validate consistency**: Principles declarative, testable, no vague language
+
+   **d. Validate formatting**: Markdown hierarchy, consistent spacing, no trailing whitespace
+
+7. **Write final constitution** 💾:
+
+   Write to `specs/constitution.md`, verify successful write
+
+8. **Output summary** 📊:
+
+   ```markdown
+   ✅ Constitution Generated Successfully
+
+   📋 Project: [Type N - Name]
+   🌐 Languages: Artifact=[ARTIFACT_LANGUAGE], Interaction=[INTERACTION_LANGUAGE]
+   📊 Quality: HIGH>[XX]%, MEDIUM>[YY]%, LOW>[ZZ]%
+   📋 Clauses: [N] total extracted
+
+   📄 Location: specs/constitution.md
+   🎯 Next: /specpro-specify
+   ```
+
+## Important Notes
+
+**Language Priority**: Language configuration happens FIRST to prevent AI confusion from English template
+
+**Template Fallback**: If language-specific template doesn't exist, use English template but generate content in target language
+
+**Clauses Library**: Fully embedded, auto-extracted based on project type, user can modify
+
+**Risk Levels**: Constitution defines QA standards, downstream workflows classify individual modules
+
+**Formatting**: Consistent headings, <100 char lines, single blank lines between sections

specpro_cli/assets/commands/specpro.feature.md

@@ -0,0 +1,115 @@
+---
+description: Initialize a new feature (independent second-level spec) — dedup check, name confirmation, fNNN directory + registry row, then hand off to /specpro-specify
+writes:
+  # This command's write surface: only what it produces AS THE PRODUCER of that
+  # (artifact, unit) pair (FR-051). ⚠️ specs/spec.md is deliberately NOT here:
+  # the feature mechanism writes ZERO bytes to the mother spec (FR-013 v0.23 /
+  # FR-015 — the whole point of the standalone registry file).
+  - artifact: specs/features.md
+    unit: "the registry file — skeleton on first creation (field legend + empty table); exactly ONE meta row appended per created feature; status transitions (active/delivered/deprecated). Never any US/FR/design content"
+  - artifact: specs/fNNN-简称/
+    unit: "the empty feature directory created at init (the spec inside it is produced by /specpro-specify, not by this command)"
+handoffs:
+  - label: Write the feature spec
+    agent: specpro-specify
+    prompt: Work in feature scope — the target directory is specs/fNNN-简称/ (created and registered by /specpro-feature). Generate the feature's spec.md there from templates/feature-spec-template.md. The mother spec (specs/spec.md) is NOT the target and MUST stay byte-identical.
+    send: true
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+**Rerun safety — init is idempotent per feature, never a regenerate** ⚠️:
+
+This command **initializes**: dedup-check → confirm the name → allocate the next `fNNN` → create the directory → append ONE registry row. If the requested feature **already exists** (name or id in `specs/features.md`), report it and stop — this command never re-initializes, never renumbers, and never touches an existing feature directory. Spec content inside the directory belongs to `/specpro-specify`, not here.
+
+---
+
+
+### Scope Resolution 🆕 (FR-063 / T050 · v0.23)
+
+1. **作用域判定**: 当前工作目录位于 `specs/fNNN-简称/` 内 ⇒ **feature 作用域**(读写范围 = 本 feature 目录,由 `check-prerequisites.sh` 的作用域感知解析);位于仓库根或 `specs/` 根 ⇒ **母作用域**(读写母规格链)。feature 作用域内 MUST NOT 写母产物——唯一例外:**发现登记**(台账路由,`[specify]`/`[plan]` 分区)。
+2. **新会话首次执行**: 若 `specs/features.md` 存在且含 `active` 行、而用户未指明作用域 ⇒ **询问用户**在母作用域还是某个 feature 内工作,MUST NOT 自行挑选。
+3. 本命令的产物路径随之解析:feature 作用域下落 `<feature 目录>/`,母作用域下落 `specs/`。
+
+## Purpose
+
+Anchor the executor to the target directory for a **new, independent feature** — a complete functional unit, NOT an augmentation of existing functionality (FR-009 v0.23). Everything after initialization is **specify's job, unchanged**: generation, clarification, and quality checks all run in feature scope exactly as they do for the mother spec. This command does **not** generate any spec content, does **not** run clarify/qc, and does **not** touch the mother spec — zero bytes (FR-013/FR-015).
+
+Contract: `specs/contracts/feature-spec-command.md` (v1.1) — the authoritative version of everything below.
+
+---
+
+## Execution Steps
+
+### Step 1 — Precondition: the mother spec exists
+
+```bash
+[ -s specs/spec.md ] || { echo "❌ no mother spec (specs/spec.md) — a feature inherits from it; run /specpro-constitution + /specpro-specify first"; exit 1; }
+```
+
+### Step 2 — Scope check: no nesting (FR-012)
+
+If the current working directory is inside `specs/fNNN-简称/`:
+
+> ℹ️ **You are inside feature `fNNN-简称`. feature commands do not nest. The new feature will be created in the MOTHER scope** (repo root, next to `specs/spec.md`), as `f(NNN+1)`.
+
+State this explicitly and continue in mother scope (do not silently pick — the user must see where the new feature lands).
+
+### Step 3 — Dedup check (FR-012 ①)
+
+The new feature is an **independent new function** — it must not overlap the mother spec's existing requirements:
+
+- Read `specs/spec.md`'s US/FR titles and the user's description.
+- **Overlap found** (the description substantially restates an existing mother FR/US) → present BOTH readings to the user: "this looks like an augmentation of `<FR-id>` rather than a new feature — extend the mother spec, or proceed as an independent feature?" Proceed only on the user's explicit choice.
+- No overlap → continue.
+
+### Step 4 — Name confirmation + id allocation (FR-012 ②③ / FR-010 / FR-011)
+
+1. From the user's input, propose a 简称 (kebab-case, 2-4 words).
+2. **Show it to the user for confirmation** — never silently pick.
+3. Validate against `specs/features.md` (create the file from the skeleton below if absent):
+   - 简称 already used → refuse, propose alternatives (FR-011)
+   - Format must be `fNNN-简称` (three-digit zero-padded, monotonic from `001`); **never reuse** a deprecated feature's number (FR-010/FR-011)
+
+### Step 5 — Create + register (FR-012 ③)
+
+```bash
+mkdir -p "specs/fNNN-简称"
+```
+
+Append EXACTLY ONE row to `specs/features.md`:
+
+```markdown
+| fNNN | 简称 | active | specs/fNNN-简称/ |
+```
+
+**Never** write anything else to the registry, and **never** write ANY byte to `specs/spec.md` — verify before finishing:
+
+```bash
+git diff --stat -- specs/spec.md   # must be EMPTY
+```
+
+### Step 6 — Hand off to /specpro-specify
+
+The frontmatter `handoffs` (send: true) carries the target directory: `/specpro-specify` generates `specs/fNNN-简称/spec.md` from `templates/feature-spec-template.md`, then clarify → qc → "review your spec or plan" — **identical to the main flow**. When it finishes, report the feature as created and point the user at the new spec.
+
+---
+
+## Registry skeleton (`specs/features.md`, first creation only)
+
+```markdown
+# Feature Registry
+
+每一个 feature（独立第二级规格，`specs/fNNN-简称/`）在此登记。本文件**只记元信息**——feature 的需求内容住各自目录，MUST NOT 记入母规格（FR-013）。维护者：`/specpro-feature`（创建时只增一行；状态转换见下）。
+
+`status` 取值：`active`（推进中）· `delivered`（已完成交付）· `deprecated`（废弃，编号保留不复用）。
+
+| id | name | status | path |
+|----|------|--------|------|
+```