@dccxx/auggiegw 1.0.28 → 1.0.29

package/.claude/commands/{opsx/apply.md → spec-apply.md}

@@ -1,152 +1,163 @@
 ---
-name: "OPSX: Apply"
-description: Implement tasks from an OpenSpec change (Experimental)
-category: Workflow
-tags: [workflow, artifacts, experimental]
+name: spec-apply
+description: spec-apply
 ---
 
-Implement tasks from an OpenSpec change.
-
-**Input**: Optionally specify a change name (e.g., `/opsx:apply add-auth`). If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
-
-**Steps**
-
-1. **Select the 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
-
-   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
-   ```
-   Parse the JSON to understand:
-   - `schemaName`: The workflow being used (e.g., "spec-driven")
-   - Which artifact contains the tasks (typically "tasks" for spec-driven, check status for others)
-
-3. **Get apply instructions**
-
-   ```bash
-   openspec instructions apply --change "<name>" --json
-   ```
-
-   This returns:
-   - Context file paths (varies by schema)
-   - Progress (total, complete, remaining)
-   - Task list with status
-   - Dynamic instruction based on current state
-
-   **Handle states:**
-   - If `state: "blocked"` (missing artifacts): show message, suggest using `/opsx:continue`
-   - If `state: "all_done"`: congratulate, suggest archive
-   - Otherwise: proceed to implementation
-
-4. **Read context files**
-
-   Read the files listed in `contextFiles` from the apply instructions output.
-   The files depend on the schema being used:
-   - **spec-driven**: proposal, specs, design, tasks
-   - Other schemas: follow the contextFiles from CLI output
-
-5. **Show current progress**
-
-   Display:
-   - Schema being used
-   - Progress: "N/M tasks complete"
-   - Remaining tasks overview
-   - Dynamic instruction from CLI
-
-6. **Implement tasks (loop until done or blocked)**
-
-   For each pending task:
-   - Show which task is being worked on
-   - Make the code changes required
-   - Keep changes minimal and focused
-   - Mark task complete in the tasks file: `- [ ]` → `- [x]`
-   - Continue to next task
-
-   **Pause if:**
-   - Task is unclear → ask for clarification
-   - Implementation reveals a design issue → suggest updating artifacts
-   - Error or blocker encountered → report and wait for guidance
-   - User interrupts
-
-7. **On completion or pause, show status**
-
-   Display:
-   - Tasks completed this session
-   - Overall progress: "N/M tasks complete"
-   - If all done: suggest archive
-   - If paused: explain why and wait for guidance
-
-**Output During Implementation**
-
-```
-## Implementing: <change-name> (schema: <schema-name>)
-
-Working on task 3/7: <task description>
-[...implementation happening...]
-✓ Task complete
-
-Working on task 4/7: <task description>
-[...implementation happening...]
-✓ Task complete
-```
-
-**Output On Completion**
-
-```
-## Implementation Complete
-
-**Change:** <change-name>
-**Schema:** <schema-name>
-**Progress:** 7/7 tasks complete ✓
-
-### Completed This Session
-- [x] Task 1
-- [x] Task 2
-...
-
-All tasks complete! You can archive this change with `/opsx:archive`.
-```
-
-**Output On Pause (Issue Encountered)**
-
-```
-## Implementation Paused
-
-**Change:** <change-name>
-**Schema:** <schema-name>
-**Progress:** 4/7 tasks complete
-
-### Issue Encountered
-<description of the issue>
-
-**Options:**
-1. <option 1>
-2. <option 2>
-3. Other approach
-
-What would you like to do?
-```
-
-**Guardrails**
-- Keep going through tasks until done or blocked
-- Always read context files before starting (from the apply instructions output)
-- If task is ambiguous, pause and ask before implementing
-- If implementation reveals issues, pause and suggest artifact updates
-- Keep code changes minimal and scoped to each task
-- Update task checkbox immediately after completing each task
-- Pause on errors, blockers, or unclear requirements - don't guess
-- Use contextFiles from CLI output, don't assume specific file names
-
-**Fluid Workflow Integration**
-
-This skill supports the "actions on a change" model:
-
-- **Can be invoked anytime**: Before all artifacts are done (if tasks exist), after partial implementation, interleaved with other actions
-- **Allows artifact updates**: If implementation reveals design issues, suggest updating artifacts - not phase-locked, work fluidly
+Implement tasks from an OpenSpec change.
+
+**⚠️ MODE: IMPLEMENTATION** — This command puts you in implementation mode. You write code, complete tasks, and modify files. This is the OPPOSITE of explore mode (`/spec-plan`). When this command ends (completion or pause), you remain in implementation context until the user explicitly switches mode.
+
+**Input**: Optionally specify a change name. If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
+
+**Steps**
+
+1. **Select the 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
+
+   Always announce: "Using change: <name>" and how to override (e.g., `/spec-apply <other>`).
+
+2. **Check status to understand the schema**
+   ```bash
+   openspec status --change "<name>" --json
+   ```
+   Parse the JSON to understand:
+   - `schemaName`: The workflow being used (e.g., "spec-driven")
+   - Which artifact contains the tasks (typically "tasks" for spec-driven, check status for others)
+
+3. **Get apply instructions**
+
+   ```bash
+   openspec instructions apply --change "<name>" --json
+   ```
+
+   This returns:
+   - Context file paths (varies by schema - could be proposal/specs/design/tasks or spec/tests/implementation/docs)
+   - Progress (total, complete, remaining)
+   - Task list with status
+   - Dynamic instruction based on current state
+
+   **Handle states:**
+   - If `state: "blocked"` (missing artifacts): show message, suggest using openspec-continue-change
+   - If `state: "all_done"`: congratulate, suggest archive
+   - Otherwise: proceed to implementation
+
+4. **Read context files**
+
+   Read the files listed in `contextFiles` from the apply instructions output.
+   The files depend on the schema being used:
+   - **spec-driven**: proposal, specs, design, tasks
+   - Other schemas: follow the contextFiles from CLI output
+
+5. **Show current progress**
+
+   Display:
+   - Schema being used
+   - Progress: "N/M tasks complete"
+   - Remaining tasks overview
+   - Dynamic instruction from CLI
+
+6. **Implement tasks (loop until done or blocked)**
+
+   For each pending task:
+   - Show which task is being worked on
+   - Make the code changes required
+   - Keep changes minimal and focused
+   - Mark task complete in the tasks file: `- [ ]` → `- [x]`
+   - Continue to next task
+
+   **Pause if:**
+   - Task is unclear → ask for clarification
+   - Implementation reveals a design issue → suggest updating artifacts
+   - Error or blocker encountered → report and wait for guidance
+   - User interrupts
+
+7. **On completion or pause, show status**
+
+   Display:
+   - Tasks completed this session
+   - Overall progress: "N/M tasks complete"
+   - If all done: suggest archive
+   - If paused: explain why and wait for guidance
+
+**Output During Implementation**
+
+```
+## Implementing: <change-name> (schema: <schema-name>)
+
+Working on task 3/7: <task description>
+[...implementation happening...]
+✓ Task complete
+
+Working on task 4/7: <task description>
+[...implementation happening...]
+✓ Task complete
+```
+
+**Output On Completion**
+
+```
+## Implementation Complete
+
+**Change:** <change-name>
+**Schema:** <schema-name>
+**Progress:** 7/7 tasks complete ✓
+
+### Completed This Session
+- [x] Task 1
+- [x] Task 2
+...
+
+All tasks complete! Ready to archive this change.
+```
+
+**Output On Pause (Issue Encountered)**
+
+```
+## Implementation Paused
+
+**Change:** <change-name>
+**Schema:** <schema-name>
+**Progress:** 4/7 tasks complete
+
+### Issue Encountered
+<description of the issue>
+
+**Options:**
+1. <option 1>
+2. <option 2>
+3. Other approach
+
+What would you like to do?
+```
+
+**Guardrails**
+- Keep going through tasks until done or blocked
+- Always read context files before starting (from the apply instructions output)
+- If task is ambiguous, pause and ask before implementing
+- If implementation reveals issues, pause and suggest artifact updates
+- Keep code changes minimal and scoped to each task
+- Update task checkbox immediately after completing each task
+- Pause on errors, blockers, or unclear requirements - don't guess
+- Use contextFiles from CLI output, don't assume specific file names
+
+**Fluid Workflow Integration**
+
+This skill supports the "actions on a change" model:
+
+- **Can be invoked anytime**: Before all artifacts are done (if tasks exist), after partial implementation, interleaved with other actions
+- **Allows artifact updates**: If implementation reveals design issues, suggest updating artifacts - not phase-locked, work fluidly
+
+**Mode Transition Hints**
+
+After implementation completes or pauses, suggest next actions that respect mode boundaries:
+
+- To think/explore/brainstorm → `/spec-plan`
+- To create a new change → `/spec-ff`
+- To verify implementation → `/spec-verify`
+- To archive completed work → `/spec-archive`
+
+**IMPORTANT**: After this command ends, do NOT automatically continue writing code on subsequent user messages unless the user explicitly asks to continue implementation or invokes `/spec-apply` again. If the user invokes `/spec-plan`, you MUST fully switch to explore mode — no code writing. If the user invokes `/spec-ff`, you MUST fully switch to change creation mode — no code writing, no continuing tasks.

package/.claude/commands/spec-archive.md

@@ -0,0 +1,88 @@
+---
+name: spec-archive
+description: spec-archive
+---
+
+---
+model: claude-sonnet-4-5
+---
+
+Archive a completed change in the experimental workflow.
+
+**Input**: Optionally specify a change name. If omitted, infer from conversation context or auto-select.
+
+**Steps**
+
+1. **Resolve the target change (smart detection)**
+
+   Resolve which change to archive using this priority order — do NOT prompt unless truly ambiguous:
+
+   1. **Explicit name provided** → use it directly
+   2. **Conversation context** → if the user recently ran `/spec-apply <name>` or `/spec-verify <name>` or otherwise worked on a specific change in this conversation, auto-select it and display: `Auto-selected "<name>" (from conversation context)`
+   3. **Single active change** → run `openspec list --json`, if only 1 active (non-archived) change exists, auto-select it and display: `Auto-selected "<name>" (only active change)`
+   4. **Ambiguous** → multiple active changes and no clear context. Only then use **AskUserQuestion tool** to let the user select. Show only active changes with their schema.
+
+2. **Check artifact and task completion status (non-blocking)**
+
+   Run `openspec status --change "<name>" --json` to check artifact completion.
+   Read the tasks file (typically `tasks.md`) to check for incomplete tasks.
+
+   Collect warnings but **do NOT prompt for confirmation** — proceed automatically:
+
+   - **Incomplete artifacts**: Note which artifacts are not `done` → include in final summary as warning
+   - **Incomplete tasks**: Count `- [ ]` vs `- [x]` → include in final summary as warning
+   - **No tasks file**: Proceed without task-related warning
+
+3. **Auto-sync delta specs**
+
+   Check for delta specs at `openspec/changes/<name>/specs/`.
+
+   - **No delta specs exist** → skip sync, proceed to archive
+   - **Delta specs exist but already synced** (main specs already reflect all changes) → skip sync, proceed to archive
+   - **Delta specs exist and need syncing** → display a brief summary of what will be synced, then **automatically sync** using the openspec-sync-specs skill (agent-driven). Do NOT prompt for sync/skip choice.
+
+4. **Perform the archive**
+
+   Create the archive directory if it doesn't exist:
+   ```bash
+   mkdir -p openspec/changes/archive
+   ```
+
+   Generate target name using current date: `YYYY-MM-DD-<change-name>`
+
+   **Check if target already exists:**
+   - If yes: Fail with error, suggest renaming existing archive or using different date
+   - If no: Move the change directory to archive
+
+   ```bash
+   mv openspec/changes/<name> openspec/changes/archive/YYYY-MM-DD-<name>
+   ```
+
+5. **Display consolidated summary**
+
+   Show a single summary that includes everything — results and any warnings collected during the process:
+
+**Output On Success**
+
+```
+## Archive Complete
+
+**Change:** <change-name>
+**Schema:** <schema-name>
+**Archived to:** openspec/changes/archive/YYYY-MM-DD-<name>/
+**Specs:** ✓ Synced to main specs (or "No delta specs" or "Already synced")
+
+⚠️ 2 artifacts were incomplete: design, tasks
+⚠️ 3/7 tasks were incomplete
+(or "All artifacts complete. All tasks complete." if no warnings)
+```
+
+**Guardrails**
+- Auto-select change when inferable from conversation context or when only one active change exists
+- Only prompt for change selection when truly ambiguous (multiple active changes, no context)
+- Never prompt for confirmation on incomplete artifacts or tasks — show warnings in summary
+- Never prompt for sync decision — always auto-sync when delta specs need syncing
+- Use artifact graph (openspec status --json) for completion checking
+- Preserve .openspec.yaml when moving to archive (it moves with the directory)
+- Show clear consolidated summary with all warnings at the end
+- Use openspec-sync-specs approach (agent-driven) for syncing

package/.claude/commands/spec-ff.md

@@ -0,0 +1,147 @@
+---
+name: spec-ff
+description: spec-ff
+---
+
+Create a new change — explore if needed, then generate all artifacts for implementation.
+
+**⚠️ MODE BOUNDARY RESET:** When this command is invoked, **stop any prior activity** — whether you were implementing code (`/spec-apply`), exploring (`/spec-plan`), or anything else. You are now in **change creation mode**. No code writing. No continuing prior tasks. Fresh start.
+
+**Input**: A description of what to build, optionally with a kebab-case name. Can range from vague ("login page") to specific ("add JWT auth with refresh tokens using Redis session store").
+
+---
+
+## Phase 0: Context Check
+
+Before evaluating the user's request, check what already exists:
+
+```bash
+openspec list --json
+```
+
+**If active changes exist**, the user might want to:
+- **Create a brand new change** — proceed normally to Phase 1
+- **Update an existing change's artifacts** — e.g., "I forgot to add email validation to the auth change"
+
+**How to tell the difference:**
+- User's input clearly relates to an active change → ask: "You have an active change `<name>`. Want to update its artifacts, or create a separate change?"
+- User's input is unrelated to any active change → proceed to Phase 1 (new change)
+- User explicitly says "new" or provides a new name → proceed to Phase 1
+
+**If updating an existing change**: Skip `openspec new change`, go directly to Phase 2 step 3 (get status) using the existing change name. Update only the artifacts that need changes.
+
+---
+
+## Phase 1: Understand
+
+Evaluate the user's input to decide the next phase.
+
+**If no input provided**, ask what they want to build (open-ended, no preset options). Do NOT proceed without a request.
+
+**If input provided**, assess clarity:
+
+| Signal | Means | Next Phase |
+|--------|-------|------------|
+| Clear scope, known tech, specific enough to write a proposal | **Ready** | → Phase 2 (Create) |
+| Vague idea, missing key decisions, multiple possible approaches, unknown constraints | **Needs exploration** | → Explore (below) |
+
+**Bias toward action.** If you can make reasonable assumptions, go to Phase 2. Only explore when the ambiguity would lead to fundamentally wrong artifacts.
+
+---
+
+## Explore (when needed)
+
+**Goal**: Get enough clarity to create good artifacts. This is NOT open-ended brainstorming — it's focused exploration with a destination.
+
+**Subagent rule**: If you use subagents during exploration (e.g., for codebase analysis, planning), instruct them to **report findings only — no file creation**.
+
+**Stance**: Curious, visual, grounded. Ask questions that emerge naturally. Use ASCII diagrams when they help. Investigate the codebase for context.
+
+**What you might do:**
+- Ask 2-3 clarifying questions (not an interrogation)
+- Sketch the problem space with ASCII diagrams
+- Investigate the codebase to surface relevant patterns, integration points, or constraints
+- Compare approaches briefly if there's a real fork in the road
+
+**Keep it focused.** You're exploring to CREATE, not exploring to explore. When you have enough to write a solid proposal, move on.
+
+**When sufficient clarity emerges**, present a brief summary and ask for confirmation:
+
+```
+## Ready to create
+
+**What**: [1-2 sentence summary of the change]
+**Approach**: [key technical decisions]
+**Scope**: [what's in, what's out]
+
+Create this change? (yes / discuss more)
+```
+
+- User confirms → Phase 2
+- User wants to discuss more → continue exploring
+- If exploration reveals this is too vague or the user just wants to think → suggest `/spec-plan` for open-ended exploration
+
+---
+
+## Phase 2: Create
+
+Once the request is clear (either from input or after exploration):
+
+1. **Derive a kebab-case name** from the description (e.g., "add user authentication" → `add-user-auth`).
+
+2. **Create the change directory**
+   ```bash
+   openspec new change "<name>"
+   ```
+
+3. **Get the artifact build order**
+   ```bash
+   openspec status --change "<name>" --json
+   ```
+   Parse: `applyRequires` (artifact IDs needed before implementation) and `artifacts` (list with status and dependencies).
+
+4. **Create artifacts in dependency order**
+
+   Use the **TodoWrite tool** to track progress.
+
+   For each artifact that is `ready` (dependencies satisfied):
+   - Get instructions: `openspec instructions <artifact-id> --change "<name>" --json`
+   - The instructions JSON includes:
+     - `context`: Project background (constraints for you — do NOT include in output)
+     - `rules`: Artifact-specific rules (constraints for you — do NOT include in output)
+     - `template`: The structure to use for your output file
+     - `instruction`: Schema-specific guidance for this artifact type
+     - `outputPath`: Where to write the artifact
+     - `dependencies`: Completed artifacts to read for context
+   - Read any completed dependency files for context
+   - Create the artifact file using `template` as structure
+   - Apply `context` and `rules` as constraints — do NOT copy them into the file
+   - Show brief progress: "✓ Created <artifact-id>"
+
+   Continue until all `applyRequires` artifacts have `status: "done"`. Re-check with `openspec status` after each artifact.
+
+   If an artifact requires user input (unclear context), ask and continue.
+
+5. **Show final status**
+   ```bash
+   openspec status --change "<name>"
+   ```
+
+**Output**: Change name/location, artifacts created, and: "Run `/spec-apply` to start implementation."
+
+---
+
+**Artifact Creation Guidelines**
+
+- Follow the `instruction` field from `openspec instructions` for each artifact type
+- Read dependency artifacts for context before creating new ones
+- Use `template` as structure — fill in its sections
+- **`context` and `rules` are constraints for YOU, not content for the file** — never copy them into output
+
+**Guardrails**
+- Create ALL artifacts needed for implementation (as defined by schema's `apply.requires`)
+- Always read dependency artifacts before creating a new one
+- Prefer making reasonable decisions to keep momentum — only ask when critically unclear
+- If a change with that name already exists, suggest continuing that change instead
+- Verify each artifact file exists after writing before proceeding to next
+- **Don't over-explore** — 2-3 rounds of questions max before creating. If still unclear, create with best understanding and note assumptions in the proposal