ac-framework 1.5.0 → 1.6.0

package/framework/.claude/commands/opsx/ac.md

@@ -1,5 +1,6 @@
- **Fundamental Principle**: *"Quality over speed. Documentation before code. Planning before execution."*
----
+**Fundamental Principle**: *"Quality over speed. Documentation before code. Planning before execution."*
+
+--- YOU SHOULD FOLLOW THIS EXACT WORKFLOW HERE, DONT SKIP STEPS, DONT CHANGE THE ORDER OF THE WORKFLOW, DONT SKIP SKILLS, DONT SKIP PHASES, DONT SKIP ANYTHING, JUST FOLLOW THE WORKFLOW EXACTLY AS IT IS WRITTEN HERE
 
 ## 🛠️ Available Skills
 
@@ -10,6 +11,17 @@
 | `secure-coding-cybersecurity` | Detects and prevents security vulnerabilities (SQLi, XSS, command injection, hardcoded secrets). Follows OWASP Top 10 standards. | Secure code validation |
 | `code-maintainability` | Analyzes code maintainability: duplication, documentation, error handling, naming conventions, SOLID architecture, performance. | Refactoring and standards |
 | `error-handling-patterns` | Error handling patterns in multiple languages: exceptions, Result types, retry, circuit breaker, graceful degradation. | Application resilience |
+| `performance-optimizer` | Methodologies for measuring, profiling, and optimizing code (caching, algorithm complexity, resource usage). | Performance Engineering |
+| `test-generator` | Generate comprehensive test suites (Unit, Integration, E2E) ensuring requirements are met. | Test Driven Development |
+
+### SpecKit Consistency & Quality Skills
+
+| Skill | Description | Primary Use |
+|-------|-------------|---------------|
+| `project-constitution` | Manage the project's core principles and ensuring alignment. | Project Governance |
+| `requirement-checklist` | Generate quality control checklists for requirements (unit tests for specs). | Requirements Quality |
+| `spec-analysis` | Analyze consistency across Spec, Plan, and Tasks. | Consistency Check |
+| `spec-clarification` | Interactively clarify specific sections of the spec. | Ambiguity Resolution |
 
 ### Planning and Design Skills
 
@@ -39,12 +51,28 @@
 | Skill | Description | Primary Use |
 |-------|-------------|---------------|
 | `project-index` | Generates structured project documentation: structure analysis, domains, agent guides. | Indexing and context |
+| `sync-index` | Keep project documentation (`project-index` and sub-skills) in sync with codebase changes. | Documentation Sync |
 | `systematic-debugging` | Structured debugging in 4 phases: root cause investigation, pattern analysis, hypothesis, implementation. | Problem resolution |
 | `changelog-generator` | Creates automated changelogs from git commits, translating technical to user language. | Version history |
 | `skill-writer` | Guide to create new skills for Claude Code with correct structure and frontmatter. | Create new skills |
 
 ---
 
+## 📍 IMPORTANT: How to Use Skills
+
+**Skills are loaded as tools, NOT CLI commands.**
+
+The skills listed above are located at `framework/.agent/skills/<skill-name>/SKILL.md`. When you need to use a skill:
+
+1. **The Agent automatically loads the skill file** - No CLI command needed
+2. **Read the SKILL.md file** to understand its instructions
+3. **Follow the skill's guidance** exactly as written
+4. **Skills provide structured workflows** for specific tasks
+
+**Do NOT use CLI commands like `acfm spec <command>` unless the skill specifically instructs you to.** OpenSpec skills guide you through their workflow via the SKILL.md content, not through CLI invocations.
+
+---
+
 ## 🚀 Workflow: New Project
 
 When starting a project **from scratch**, follow this mandatory workflow:
@@ -60,239 +88,174 @@ When starting a project **from scratch**, follow this mandatory workflow:
              │
              ▼
     ┌──────────────────────────────────────────────┐
-    │  PHASE 1: FOUNDATIONS (Mandatory)            │
-    │                                              │
-    │  1. secure-coding-cybersecurity              │
+    │  PHASE 1: FOUNDATIONS & GOVERNANCE           │
+    │  1. project-constitution                     │
+    │     └─ Define core principles                │
+    │  2. secure-coding-cybersecurity              │
     │     └─ Establish security guidelines         │
-    │                                              │
-    │  2. code-maintainability                     │
+    │  3. code-maintainability                     │
     │     └─ Define quality standards              │
-    │                                              │
-    │  3. brainstorming                            │
-    │     └─ Architecture and design decisions     │
     └────────────────────┬─────────────────────────┘
                          │
                          ▼
     ┌──────────────────────────────────────────────┐
-    │  PHASE 2: SPECIFICATION (Mandatory)          │
-    │                                              │
-    │  4. openspec-new-change                      │
-    │     └─ Create change with proposal           │
-    │                                              │
-    │  5. openspec-continue-change                 │
-    │     └─ Create specs, design, tasks           │
-    │        (or use openspec-ff-change)           │
+    │  PHASE 2: CONTEXT & DISCOVERY                │
+    │  4. project-index                            │
+    │     └─ Document initial structure            │
+    │  5. openspec-explore                         │
+    │     └─ Explore target architecture           │
+    │  6. brainstorming                            │
+    │     └─ Generate ideas and architecture       │
     └────────────────────┬─────────────────────────┘
                          │
                          ▼
     ┌──────────────────────────────────────────────┐
-    │  PHASE 3: IMPLEMENTATION                     │
-    │                                              │
-    │  6. openspec-apply-change                    │
-    │     └─ Implement the tasks                   │
+    │  PHASE 3: REQUIREMENTS & DESIGN              │
+    │  7. spec-clarification (CRITICAL)            │
+    │     └─ CLARIFY requirements first            │
+    │  8. openspec-new-change                      │
+    │     └─ Create proposal                       │
+    │  9. openspec-continue-change                 │
+    │     └─ Draft Specs, Design, Tasks            │
+    │  10. spec-analysis                           │
+    │     └─ Verify consistency                    │
+    │  11. requirement-checklist                   │
+    │     └─ "Unit test" the specs                 │
+    │  12. api-design-principles [IF APIs]         │
+    │     └─ Design REST/GraphQL APIs              │
+    │  13. interface-design [IF UI]                │
+    │     └─ Design dashboards/apps interface      │
     └────────────────────┬─────────────────────────┘
                          │
                          ▼
     ┌──────────────────────────────────────────────┐
-    │  PHASE 4: VALIDATION AND CLOSURE             │
-    │                                              │
-    │  7. systematic-debugging                     │
-    │     └─ Verify no errors                      │
-    │                                              │
-    │  8. openspec-verify-change                   │
+    │  PHASE 4: IMPLEMENTATION                     │
+    │  14. test-generator                          │
+    │     └─ TDD: Write tests first                │
+    │  15. openspec-apply-change                   │
+    │     └─ Implement code to pass tests          │
+    │  16. secure-coding-cybersecurity             │
+    │     └─ Audit code for security               │
+    │  17. error-handling-patterns                 │
+    │     └─ Verify robust error handling          │
+    │  18. performance-optimizer                   │
+    │     └─ Optimize critical paths               │
+    └────────────────────┬─────────────────────────┘
+                         │
+                         ▼
+    ┌──────────────────────────────────────────────┐
+    │  PHASE 5: VALIDATION & CLOSURE               │
+    │  19. systematic-debugging                    │
+    │     └─ Resolve any issues                    │
+    │  20. openspec-verify-change                  │
     │     └─ Validate against specs                │
-    │                                              │
-    │  9. changelog-generator                      │
-    │     └─ Generate in changelogs/by-ai/         │
-    │                                              │
-    │  10. openspec-archive-change                 │
-    │      └─ Archive the change                   │
+    │  21. sync-index                              │
+    │     └─ Update project documentation          │
+    │  22. changelog-generator                     │
+    │     └─ Generate release notes                │
+    │  23. openspec-archive-change                 │
+    │     └─ Archive the change                    │
     └──────────────────────────────────────────────┘
 ```
 
-### Phase Descriptions - New Project
-
-| Phase | Skill | Description | Expected Output |
-|------|-------|-------------|-----------------|
-| 1 | `secure-coding-cybersecurity` | Establish security guidelines: input validation, sanitization, injection prevention, secrets handling | `.agents/security-guidelines.md` |
-| 2 | `code-maintainability` | Define conventions: naming, folder structure, design patterns, DRY, testing | `.agents/maintainability-rules.md` |
-| 3 | `brainstorming` | Generate architecture ideas, question approach, explore alternatives | `.agents/architecture-decisions.md` |
-| 4 | `openspec-new-change` | Create change with proposal (why, what changes, capabilities) | `openspec/changes/<name>/proposal.md` |
-| 5 | `openspec-continue-change` | Create specs (WHEN/THEN requirements), design (technical decisions), tasks (checklist) | Complete OpenSpec artifacts |
-| 6 | `openspec-apply-change` | Implement code according to specs and tasks | Functional code |
-| 7 | `systematic-debugging` | Structured debugging: investigate root cause, don't guess | Validation report |
-| 8 | `openspec-verify-change` | Verify completeness, correctness, and coherence | Verification report |
-| 9 | `changelog-generator` | Document changes in user language | `changelogs/by-ai/[date]-[feature].md` |
-| 10 | `openspec-archive-change` | Move change to archive with date | `openspec/changes/archive/YYYY-MM-DD-<name>/` |
+**Conditional Skills Notes:**
+- `[IF APIs]`: Use api-design-principles only if the project involves REST/GraphQL APIs
+- `[IF UI]`: Use interface-design only if the project has dashboards, admin panels, or apps
 
 ---
 
-## 🔍 Workflow: Existing Project
+## 🔄 Workflow: Existing Project
 
-When working on an **already created** project that does NOT have `.md` documentation files:
+When working on an **existing codebase** (adding features, fixing bugs, refactoring):
 
 ```
 ┌─────────────────────────────────────────────────────────────────────────────────┐
-│                        WORKFLOW: EXISTING PROJECT (NO DOCS)                      │
+│                        WORKFLOW: EXISTING PROJECT                                │
 └─────────────────────────────────────────────────────────────────────────────────┘
 
-    ┌─────────────────────────────────────────────────────────────────────────┐
-    │                                                                          │
-    │   ⚠️  CHECK: No documentation .md files exist in                         │
-    │       .agents/ or openspec/                                              │
-    │                                                                          │
-    └────────────────────────────────────────────────────┬─────────────────────┘
-                                                         │
-                                                         ▼
-    ┌─────────────────────────────────────────────────────────────────────────┐
-    │                                                                          │
-    │   🔄 STEP 0: project-index                                               │
-    │   Generate complete documentation for existing project                   │
-    │   ├─ Analyze folder structure                                            │
-    │   ├─ Identify domains (UI, Backend, DB, etc.)                            │
-    │   ├─ Create specific sub-skills per domain                               │
-    │   └─ Generate agent-guidance files                                       │
-    │                                                                          │
-    │   Output:                                                                │
-    │   ├─ .agents/project-index.md                                            │
-    │   ├─ .agents/agent-<domain>.md (in each folder)                          │
-    │   └─ .claude/skills/project-index-<domain>/SKILL.md                      │
-    │                                                                          │
-    └─────────────────────────────────────────────────────────────────────────┘
-```
-
-### Post-Indexing
-
-Once the project is indexed, continue with the [Changes Workflow](#-workflow-changesiterations).
-
----
-
-## 🔄 Workflow: Changes/Iterations
-
-For **each change or new feature** in an already documented project:
-
-```
-┌─────────────────────────────────────────────────────────────────────────────────┐
-│                           WORKFLOW: CHANGES AND ITERATIONS                       │
-└─────────────────────────────────────────────────────────────────────────────────┘
-
-    ┌─────────────────────────┐
-    │   START CHANGE          │
-    └────────┬────────────────┘
+    ┌─────────────────┐
+    │  START CHANGE   │
+    └────────┬────────┘
              │
              ▼
-    ┌─────────────────────────┐     ┌──────────────────────────────────────────┐
-    │  1. openspec-explore    │────▶│  2. brainstorming                        │
-    │  (Explore current       │     │  (Based on exploration:                  │
-    │   code and structure)   │     │   - Generate ideas                       │
-    └─────────────────────────┘     │   - Suggest improvements                 │
-                                    │   - Ask key questions to user)           │
-                                    └─────────────────┬────────────────────────┘
-                                                      │
-                                                      ▼
-    ┌─────────────────────────┐     ┌──────────────────────────────────────────┐
-    │  3. openspec-new        │────▶│  4. openspec-continue / ff               │
-    │  (Create specification  │     │  (Create specs, design, tasks)           │
-    │   for change/feature)   │     └─────────────────┬────────────────────────┘
-    └─────────────────────────┘                       │
-                                                      ▼
-    ┌─────────────────────────┐     ┌──────────────────────────────────────────┐
-    │  5. openspec-apply      │────▶│  6. systematic-debugging                 │
-    │  (Implement changes     │     │  (Verify no errors,                      │
-    │   according to tasks)   │     │   validate patterns)                     │
-    └─────────────────────────┘     └─────────────────┬────────────────────────┘
-                                                      │
-                                                      ▼
-    ┌─────────────────────────┐     ┌──────────────────────────────────────────┐
-    │  7. openspec-verify     │────▶│  8. changelog-generator                  │
-    │  (Verify against        │     │  (Generate change record                 │
-    │   specs and design)     │     │   in changelogs/by-ai/)                  │
-    └─────────────────────────┘     └─────────────────┬────────────────────────┘
-                                                      │
-                                                      ▼
-    ┌─────────────────────────┐     ┌──────────────────────────────────────────┐
-    │  9. openspec-archive    │────▶│  10. openspec-sync-specs (optional)      │
-    │  (Archive completed     │     │  (Sync specs to main)                    │
-    │   change)               │     └──────────────────────────────────────────┘
-    └─────────────────────────┘
-                                                      │
-                                                      ▼
-    ┌─────────────────────────────────────────────────────────────────────────┐
-    │                                                                          │
-    │   ✅ CHANGE COMPLETED AND DOCUMENTED                                    │
-    │                                                                          │
-    └─────────────────────────────────────────────────────────────────────────┘
+    ┌──────────────────────────────────────────────┐
+    │  PHASE 1: CONTEXT & ANALYSIS                 │
+    │  1. project-index (if needed)                │
+    │     └─ Map current system                    │
+    │  2. openspec-explore                         │
+    │     └─ Deep dive into relevant modules       │
+    │  3. brainstorming                            │
+    │     └─ Ideate on feature/fix                 │
+    └────────────────────┬─────────────────────────┘
+                         │
+                         ▼
+    ┌──────────────────────────────────────────────┐
+    │  PHASE 2: DISCOVERY & CLARIFICATION          │
+    │  4. spec-clarification (CRITICAL)            │
+    │     └─ CLARIFY requirements first            │
+    │  5. openspec-new-change                      │
+    │     └─ Initialize change artifact            │
+    └────────────────────┬─────────────────────────┘
+                         │
+                         ▼
+    ┌──────────────────────────────────────────────┐
+    │  PHASE 3: DESIGN & PLANNING                  │
+    │  6. openspec-continue-change                 │
+    │     └─ Draft Specs, Design, Tasks            │
+    │  7. spec-analysis                            │
+    │     └─ Check consistency with existing       │
+    │  8. requirement-checklist                    │
+    │     └─ Validate requirements                 │
+    │  9. api-design-principles [IF APIs]          │
+    │     └─ Design API changes                    │
+    │  10. interface-design [IF UI]                │
+    │     └─ Design interface changes              │
+    └────────────────────┬─────────────────────────┘
+                         │
+                         ▼
+    ┌──────────────────────────────────────────────┐
+    │  PHASE 4: IMPLEMENTATION                     │
+    │  11. test-generator                          │
+    │     └─ Generate tests for new feature        │
+    │  12. openspec-apply-change                   │
+    │     └─ Implement code                        │
+    │  13. secure-coding-cybersecurity             │
+    │     └─ Audit new code                        │
+    │  14. error-handling-patterns                 │
+    │     └─ Verify error handling                 │
+    │  15. performance-optimizer                   │
+    │     └─ Ensure no perf degradation            │
+    └────────────────────┬─────────────────────────┘
+                         │
+                         ▼
+    ┌──────────────────────────────────────────────┐
+    │  PHASE 5: OPTIMIZATION & VERIFICATION        │
+    │  16. systematic-debugging                    │
+    │     └─ Fix regressions                       │
+    │  17. openspec-verify-change                  │
+    │     └─ Final verification                    │
+    │  18. sync-index (IMPORTANT)                  │
+    │     └─ Update docs with new changes          │
+    │  19. changelog-generator                     │
+    │     └─ Generate release notes                │
+    │  20. openspec-archive-change                 │
+    │     └─ Archive change                        │
+    └──────────────────────────────────────────────┘
 ```
 
-### Phase Descriptions - Changes/Iterations
-
-| Phase | Skill | Description | Required Input | Expected Output |
-|------|-------|-------------|-----------------|-----------------|
-| 1 | `openspec-explore` | Analyze current code state, identify dependencies and modification points | Change request context | Impact report in `.agents/exploration-report.md` |
-| 2 | `brainstorming` | Generate ideas based on exploration, suggest alternatives, ask user questions | Exploration report | `.agents/brainstorming-session.md` with decisions |
-| 3 | `openspec-new-change` | Create change container with initial proposal | Brainstorming decisions | `openspec/changes/<name>/proposal.md` |
-| 4 | `openspec-continue-change` or `openspec-ff-change` | Create specs, design, and tasks | Approved proposal | Complete OpenSpec artifacts |
-| 5 | `openspec-apply-change` | Implement tasks as described | Tasks ready | Modified code following specs |
-| 6 | `systematic-debugging` | Validate no errors, verify applied patterns | Modified code | Validation report in `.agents/debug-report.md` |
-| 7 | `openspec-verify-change` | Verify implementation matches specs and design | Artifacts + code | Verification report |
-| 8 | `changelog-generator` | Document change in history | Implemented feature | `changelogs/by-ai/[YYYY-MM-DD]-[feature].md` |
-| 9 | `openspec-archive-change` | Archive completed change | Change ready | `openspec/changes/archive/YYYY-MM-DD-<name>/` |
-| 10 | `openspec-sync-specs` (optional) | Synchronize delta specs to main specs | Delta specs | Main specs updated |
+**Conditional Skills Notes:**
+- `[IF APIs]`: Use api-design-principles only if modifying/creating REST/GraphQL APIs
+- `[IF UI]`: Use interface-design only if modifying dashboards, admin panels, or apps
+- `project-index`: Run only if you haven't indexed the project yet or need to refresh context
 
 ---
 
-## ✅ Validation Checklist
+## 📝 Skill Loading Reference
 
-Before considering any task as **completed**, verify:
+All skills are located in: `framework/.agent/skills/`
 
-```
-╔═══════════════════════════════════════════════════════════════════════════════════╗
-║                              MANDATORY CHECKLIST                                   ║
-╠═══════════════════════════════════════════════════════════════════════════════════╣
-║                                                                                    ║
-║  □ Security                                                                        ║
-║    └─ □ secure-coding-cybersecurity executed                                     ║
-║    └─ □ No known vulnerabilities (SQL injection, XSS, etc.)                       ║
-║    └─ □ Inputs validated and sanitized                                            ║
-║    └─ □ Secrets/keys not hardcoded                                                ║
-║    └─ □ No eval() or dynamic code execution with user input                       ║
-║                                                                                    ║
-║  □ Maintainability                                                                 ║
-║    └─ □ code-maintainability executed                                            ║
-║    └─ □ Code follows project conventions                                          ║
-║    └─ □ Functions/classes have single responsibility                              ║
-║    └─ □ Descriptive and semantic names                                            ║
-║    └─ □ No duplicate code (DRY principle)                                         ║
-║    └─ □ Documentation explains "why", not "what"                                  ║
-║                                                                                    ║
-║  □ Error Handling                                                                  ║
-║    └─ □ error-handling-patterns applied                                           ║
-║    └─ □ All errors handled gracefully                                             ║
-║    └─ □ Edge cases covered (null, empty, boundaries)                              ║
-║                                                                                    ║
-║  □ Specification (OpenSpec)                                                        ║
-║    └─ □ Change created with proposal, specs, design, tasks                        ║
-║    └─ □ Implementation matches specification                                      ║
-║    └─ □ All WHEN/THEN scenarios implemented                                       ║
-║    └─ □ Design decisions documented                                               ║
-║                                                                                    ║
-║  □ Implementation                                                                  ║
-║    └─ □ All tasks marked complete [- [x]]                                         ║
-║    └─ □ Code tested and functional                                                ║
-║    └─ □ No console.logs or debug code                                             ║
-║                                                                                    ║
-║  □ Validation                                                                      ║
-║    └─ □ systematic-debugging executed without critical errors                     ║
-║    └─ □ openspec-verify-change passed (or reviewed)                               ║
-║    └─ □ Design patterns correctly applied                                         ║
-║                                                                                    ║
-║  □ Documentation                                                                   ║
-║    └─ □ Project index updated if structure changed                                ║
-║    └─ □ Changelog generated in changelogs/by-ai/                                  ║
-║    └─ □ README updated if necessary                                               ║
-║                                                                                    ║
-║  □ Closure                                                                         ║
-║    └─ □ Change archived with openspec-archive-change                              ║
-║    └─ □ Delta specs synchronized (if applicable)                                  ║
-║                                                                                    ║
-╚═══════════════════════════════════════════════════════════════════════════════════╝
+To load a skill, read its SKILL.md file:
+- Example: Read `framework/.agent/skills/spec-clarification/SKILL.md` to use the clarification workflow
+- Example: Read `framework/.agent/skills/interface-design/SKILL.md` to use interface design principles
+
+**Remember**: Skills are documentation-based workflows, NOT CLI commands. Load them by reading the SKILL.md files.

package/framework/.claude/commands/opsx/apply.md

@@ -16,13 +16,13 @@ Implement tasks from an OpenSpec change.
    If a name is provided, use it. Otherwise:
    - Infer from conversation context if the user mentioned a change
    - Auto-select if only one active change exists
-   - If ambiguous, run `openspec list --json` to get available changes and use the **AskUserQuestion tool** to let the user select
+   - If ambiguous, run `acfm spec list --json` to get available changes and use the **AskUserQuestion tool** to let the user select
 
    Always announce: "Using change: <name>" and how to override (e.g., `/opsx:apply <other>`).
 
 2. **Check status to understand the schema**
    ```bash
-   openspec status --change "<name>" --json
+   acfm spec status --change "<name>" --json
    ```
    Parse the JSON to understand:
    - `schemaName`: The workflow being used (e.g., "spec-driven")
@@ -31,7 +31,7 @@ Implement tasks from an OpenSpec change.
 3. **Get apply instructions**
 
    ```bash
-   openspec instructions apply --change "<name>" --json
+   acfm spec instructions apply --change "<name>" --json
    ```
 
    This returns:

package/framework/.claude/commands/opsx/archive.md

@@ -13,7 +13,7 @@ Archive a completed change in the experimental workflow.
 
 1. **If no change name provided, prompt for selection**
 
-   Run `openspec list --json` to get available changes. Use the **AskUserQuestion tool** to let the user select.
+   Run `acfm spec list --json` to get available changes. Use the **AskUserQuestion tool** to let the user select.
 
    Show only active changes (not already archived).
    Include the schema used for each change if available.
@@ -22,7 +22,7 @@ Archive a completed change in the experimental workflow.
 
 2. **Check artifact completion status**
 
-   Run `openspec status --change "<name>" --json` to check artifact completion.
+   Run `acfm spec status --change "<name>" --json` to check artifact completion.
 
    Parse the JSON to understand:
    - `schemaName`: The workflow being used
@@ -149,7 +149,7 @@ Target archive directory already exists.
 
 **Guardrails**
 - Always prompt for change selection if not provided
-- Use artifact graph (openspec status --json) for completion checking
+- Use artifact graph (acfm spec status --json) for completion checking
 - Don't block archive on warnings - just inform and confirm
 - Preserve .openspec.yaml when moving to archive (it moves with the directory)
 - Show clear summary of what happened

package/framework/.claude/commands/opsx/bulk-archive.md

@@ -15,7 +15,7 @@ This skill allows you to batch-archive changes, handling spec conflicts intellig
 
 1. **Get active changes**
 
-   Run `openspec list --json` to get all active changes.
+   Run `acfm spec list --json` to get all active changes.
 
    If no active changes exist, inform user and stop.
 
@@ -32,7 +32,7 @@ This skill allows you to batch-archive changes, handling spec conflicts intellig
 
    For each selected change, collect:
 
-   a. **Artifact status** - Run `openspec status --change "<name>" --json`
+   a. **Artifact status** - Run `acfm spec status --change "<name>" --json`
       - Parse `schemaName` and `artifacts` list
       - Note which artifacts are `done` vs other states
 

package/framework/.claude/commands/opsx/continue.md

@@ -13,7 +13,7 @@ Continue working on a change by creating the next artifact.
 
 1. **If no change name provided, prompt for selection**
 
-   Run `openspec list --json` to get available changes sorted by most recently modified. Then use the **AskUserQuestion tool** to let the user select which change to work on.
+   Run `acfm spec list --json` to get available changes sorted by most recently modified. Then use the **AskUserQuestion tool** to let the user select which change to work on.
 
    Present the top 3-4 most recently modified changes as options, showing:
    - Change name
@@ -27,7 +27,7 @@ Continue working on a change by creating the next artifact.
 
 2. **Check current status**
    ```bash
-   openspec status --change "<name>" --json
+   acfm spec status --change "<name>" --json
    ```
    Parse the JSON to understand current state. The response includes:
    - `schemaName`: The workflow schema being used (e.g., "spec-driven")
@@ -50,7 +50,7 @@ Continue working on a change by creating the next artifact.
    - Pick the FIRST artifact with `status: "ready"` from the status output
    - Get its instructions:
      ```bash
-     openspec instructions <artifact-id> --change "<name>" --json
+     acfm spec instructions <artifact-id> --change "<name>" --json
      ```
    - Parse the JSON. The key fields are:
      - `context`: Project background (constraints for you - do NOT include in output)
@@ -75,7 +75,7 @@ Continue working on a change by creating the next artifact.
 
 4. **After creating an artifact, show progress**
    ```bash
-   openspec status --change "<name>"
+   acfm spec status --change "<name>"
    ```
 
 **Output**

package/framework/.claude/commands/opsx/explore.md

@@ -86,7 +86,7 @@ You have full context of the OpenSpec system. Use it naturally, don't force it.
 
 At the start, quickly check what exists:
 ```bash
-openspec list --json
+acfm spec list --json
 ```
 
 This tells you:

package/framework/.claude/commands/opsx/ff.md

@@ -22,13 +22,13 @@ Fast-forward through artifact creation - generate everything needed to start imp
 
 2. **Create the change directory**
    ```bash
-   openspec new change "<name>"
+   acfm spec new "<name>"
    ```
    This creates a scaffolded change at `openspec/changes/<name>/`.
 
 3. **Get the artifact build order**
    ```bash
-   openspec status --change "<name>" --json
+   acfm spec status --change "<name>" --json
    ```
    Parse the JSON to get:
    - `applyRequires`: array of artifact IDs needed before implementation (e.g., `["tasks"]`)
@@ -43,7 +43,7 @@ Fast-forward through artifact creation - generate everything needed to start imp
    a. **For each artifact that is `ready` (dependencies satisfied)**:
       - Get instructions:
         ```bash
-        openspec instructions <artifact-id> --change "<name>" --json
+        acfm spec instructions <artifact-id> --change "<name>" --json
         ```
       - The instructions JSON includes:
         - `context`: Project background (constraints for you - do NOT include in output)
@@ -58,7 +58,7 @@ Fast-forward through artifact creation - generate everything needed to start imp
       - Show brief progress: "✓ Created <artifact-id>"
 
    b. **Continue until all `applyRequires` artifacts are complete**
-      - After creating each artifact, re-run `openspec status --change "<name>" --json`
+      - After creating each artifact, re-run `acfm spec status --change "<name>" --json`
       - Check if every artifact ID in `applyRequires` has `status: "done"` in the artifacts array
       - Stop when all `applyRequires` artifacts are done
 
@@ -68,7 +68,7 @@ Fast-forward through artifact creation - generate everything needed to start imp
 
 5. **Show final status**
    ```bash
-   openspec status --change "<name>"
+   acfm spec status --change "<name>"
    ```
 
 **Output**
@@ -81,7 +81,7 @@ After completing all artifacts, summarize:
 
 **Artifact Creation Guidelines**
 
-- Follow the `instruction` field from `openspec instructions` for each artifact type
+- Follow the `instruction` field from `acfm spec instructions` for each artifact type
 - The schema defines what each artifact should contain - follow it
 - Read dependency artifacts for context before creating new ones
 - Use the `template` as a starting point, filling in based on context