openspec-sync-specs

name	openspec-sync-specs
description	Sync delta specs from a change to main specs. Use when the user wants to update main specs with changes from a delta spec, without archiving the change.
allowed-tools	Bash(openspec:*)
license	MIT
compatibility	Requires openspec CLI.
metadata	{"author":"openspec","version":"1.0","generatedBy":"1.11.0"}

Sync delta specs from a change to main specs.

This is an agent-driven operation - you will read delta specs and directly edit main specs to apply the changes. This allows intelligent merging (e.g., adding a scenario without copying the entire requirement).

Store selection: If the user names a store (a store is a standalone OpenSpec repo registered on this machine) or the work lives in one, run openspec store list --json to discover registered store ids, then pass --store <id> on the commands that read or write specs and changes (new change, status, instructions, list, show, validate, archive, doctor, context, schemas, view). Once selected, treat --store <id> as sticky for the rest of the workflow. Every unscoped example of those commands below is shorthand: before running it, append the flag. For example, run openspec status --change "<name>" --json --store "<id>", not the unscoped form shown below. Other commands do not take the flag. Hints printed by commands already carry the flag; keep it on follow-ups. Without a store, commands act on the nearest local openspec/ root.

<capability-path> is the spec directory relative to specs/ (for example, user-auth or identity/user-auth). Preserve the full path from each delta spec when resolving its main spec.

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 ask the user to select one

   When prompting, show changes that have delta specs (under specs/ directory).

   Always announce: "Using change: " and how to override (e.g., /opsx:sync <other>).

2. Resolve change context

   Run:

   openspec status --change "<name>" --json
   

   The JSON includes planningHome.root. Main specs live under <planningHome.root>/openspec/specs/ — use that (store-aware) root for every main-spec path below, not a hardcoded repo path. When a store is selected it points at the store, not the current repository.

3. Find delta specs

   Use artifactPaths.specs.existingOutputPaths from the status JSON as the only source of delta spec paths. If the specs entry is missing or existingOutputPaths is empty, report that there are no delta specs to sync, do not infer them from other artifacts, and stop without requesting artifact instructions or writing a main spec.

   Sync every path in existingOutputPaths unless the caller narrowed the set. A caller narrows it by naming an explicit list of complete entries from existingOutputPaths — copy those absolute values verbatim. Archive does this inline, and a user can too (for example, by selecting the entry ending in /specs/billing/invoices/spec.md). Then sync only the named paths and leave the remaining delta specs untouched: bulk archive excludes a delta whose implementation it could not find, and syncing it anyway would write a main spec the caller deliberately withheld. Carry that narrowed selection through step 4; never widen it back to the full list. If a named path is not in existingOutputPaths, do not sync it — report it and stop, rather than dropping it silently. If the named list is empty, report that there is nothing to sync and stop without writing a main spec.

   Each delta spec file contains sections like:

   • ## ADDED Requirements - New requirements to add
   • ## MODIFIED Requirements - Changes to existing requirements

Delta Spec Format Reference

## Purpose

Only on a delta that introduces a brand-new capability. Seeds the new main spec.

## ADDED Requirements

### Requirement: New Feature
The system SHALL do something new.

#### Scenario: Basic case
- **WHEN** user does X
- **THEN** system does Y

## MODIFIED Requirements

### Requirement: Existing Feature
The system SHALL keep doing the existing thing, now also handling A.

#### Scenario: Scenario the main spec already has
- **WHEN** user does X
- **THEN** system does Y

#### Scenario: New scenario to add
- **WHEN** user does A
- **THEN** system does B

## REMOVED Requirements

### Requirement: Deprecated Feature

## RENAMED Requirements

- FROM: `### Requirement: Old Name`
- TO: `### Requirement: New Name`

Main Spec Format Reference

Main specs are what the delta merges INTO. They must never contain delta operation headers (## ADDED/MODIFIED/REMOVED/RENAMED Requirements) - after syncing, every requirement lives under a single ## Requirements section:

# <capability> Specification

## Purpose
Short description of what this capability does and why it exists.

## Requirements

### Requirement: New Feature
The system SHALL do something new.

#### Scenario: Basic case
- **WHEN** user does X
- **THEN** system does Y

Key Principle: Intelligent Merging

Unlike programmatic merging, you merge rather than overwrite:

• A MODIFIED block carries the whole requirement - body plus every scenario that survives the change. openspec validate and openspec archive both reject one that drops a scenario the main spec still has.
• Keep anything the delta does not mention, in the main spec's existing order
• Use your judgment to merge changes sensibly

Output On Success

## Specs Synced: <change-name>

Updated main specs:

**<capability-1>**:
- Added requirement: "New Feature"
- Modified requirement: "Existing Feature" (added 1 scenario)

**<capability-2>**:
- Created new spec file
- Added requirement: "Another Feature"

Main specs are now updated. The change remains active - archive when implementation is complete.

Guardrails

• Read both delta and main specs before making changes
• Preserve existing content not mentioned in delta
• Never copy a delta file into a main spec as-is - merge its content so the main spec keeps the Main Spec Format Reference structure, with no delta operation headers
• If something is unclear, ask for clarification
• Show what you're changing as you go
• The operation should be idempotent - running twice should give same result
• Use only artifactPaths.specs.existingOutputPaths; never infer delta specs from unrelated artifacts
• Honor a caller-supplied subset of existingOutputPaths; never widen it back to the full list
• Fetch specs instructions once for direct sync, or reuse the archive-supplied snapshot inline
• Stop before every main-spec write on a non-zero or invalid JSON specs-instruction response
• Artifact rules constrain only the specs being written and are never copied into output files