create-yss-spec 1.1.3 → 2.0.0

package/template/.claude/skills/excalidraw-diagram-generator/scripts/add-arrow.py

@@ -77,7 +77,7 @@ def create_arrow(
 ) -> list:
     """
     Create an arrow element.
-    
+
     Args:
         from_x: Starting X coordinate
         from_y: Starting Y coordinate
@@ -86,12 +86,12 @@ def create_arrow(
         style: Line style (solid, dashed, dotted)
         color: Arrow color
         label: Optional text label on the arrow
-    
+
     Returns:
         List of elements (arrow and optional label)
     """
     elements = []
-    
+
     # Arrow element
     arrow = {
         "id": generate_unique_id(),
@@ -133,12 +133,12 @@ def create_arrow(
         "lastCommittedPoint": None
     }
     elements.append(arrow)
-    
+
     # Optional label
     if label:
         mid_x = (from_x + to_x) / 2 - (len(label) * 5)
         mid_y = (from_y + to_y) / 2 - 10
-        
+
         label_element = {
             "id": generate_unique_id(),
             "type": "text",
@@ -177,7 +177,7 @@ def create_arrow(
             "lineHeight": 1.25
         }
         elements.append(label_element)
-    
+
     return elements
 
 
@@ -193,7 +193,7 @@ def add_arrow_to_diagram(
 ) -> None:
     """
     Add an arrow to an Excalidraw diagram.
-    
+
     Args:
         diagram_path: Path to the Excalidraw diagram file
         from_x: Starting X coordinate
@@ -206,28 +206,28 @@ def add_arrow_to_diagram(
     """
     print(f"Creating arrow from ({from_x}, {from_y}) to ({to_x}, {to_y})")
     arrow_elements = create_arrow(from_x, from_y, to_x, to_y, style, color, label)
-    
+
     if label:
         print(f"  With label: '{label}'")
-    
+
     # Load diagram
     print(f"Loading diagram: {diagram_path}")
     with open(diagram_path, 'r', encoding='utf-8') as f:
         diagram = json.load(f)
-    
+
     # Add arrow elements
     if 'elements' not in diagram:
         diagram['elements'] = []
-    
+
     original_count = len(diagram['elements'])
     diagram['elements'].extend(arrow_elements)
     print(f"  Added {len(arrow_elements)} elements (total: {original_count} -> {len(diagram['elements'])})")
-    
+
     # Save diagram
     print(f"Saving diagram")
     with open(diagram_path, 'w', encoding='utf-8') as f:
         json.dump(diagram, f, indent=2, ensure_ascii=False)
-    
+
     print(f"✓ Successfully added arrow to diagram")
 
 
@@ -247,20 +247,20 @@ def main():
         print("  python add-arrow.py diagram.excalidraw 300 200 500 300")
         print("  python add-arrow.py diagram.excalidraw 300 200 500 300 --label 'HTTP'")
         sys.exit(1)
-    
+
     diagram_path = Path(sys.argv[1])
     from_x = float(sys.argv[2])
     from_y = float(sys.argv[3])
     to_x = float(sys.argv[4])
     to_y = float(sys.argv[5])
-    
+
     # Parse optional arguments
     style = "solid"
     color = "#1e1e1e"
     label = None
     # Default: use edit suffix to avoid editor overwrite issues
     use_edit_suffix = True
-    
+
     i = 6
     while i < len(sys.argv):
         if sys.argv[i] == '--style':
@@ -296,12 +296,12 @@ def main():
         else:
             print(f"Error: Unknown option: {sys.argv[i]}")
             sys.exit(1)
-    
+
     # Validate inputs
     if not diagram_path.exists():
         print(f"Error: Diagram file not found: {diagram_path}")
         sys.exit(1)
-    
+
     try:
         work_path, final_path = prepare_edit_path(diagram_path, use_edit_suffix)
         add_arrow_to_diagram(work_path, from_x, from_y, to_x, to_y, style, color, label)

package/template/.claude/skills/excalidraw-diagram-generator/scripts/add-icon-to-diagram.py

@@ -37,60 +37,60 @@ def calculate_bounding_box(elements: List[Dict[str, Any]]) -> Tuple[float, float
     """Calculate the bounding box (min_x, min_y, max_x, max_y) of icon elements."""
     if not elements:
         return (0, 0, 0, 0)
-    
+
     min_x = float('inf')
     min_y = float('inf')
     max_x = float('-inf')
     max_y = float('-inf')
-    
+
     for element in elements:
         if 'x' in element and 'y' in element:
             x = element['x']
             y = element['y']
             width = element.get('width', 0)
             height = element.get('height', 0)
-            
+
             min_x = min(min_x, x)
             min_y = min(min_y, y)
             max_x = max(max_x, x + width)
             max_y = max(max_y, y + height)
-    
+
     return (min_x, min_y, max_x, max_y)
 
 
 def transform_icon_elements(
-    elements: List[Dict[str, Any]], 
-    target_x: float, 
+    elements: List[Dict[str, Any]],
+    target_x: float,
     target_y: float
 ) -> List[Dict[str, Any]]:
     """
     Transform icon elements to target coordinates with unique IDs.
-    
+
     Args:
         elements: Icon elements from JSON file
         target_x: Target X coordinate (top-left position)
         target_y: Target Y coordinate (top-left position)
-    
+
     Returns:
         Transformed elements with new coordinates and IDs
     """
     if not elements:
         return []
-    
+
     # Calculate bounding box
     min_x, min_y, max_x, max_y = calculate_bounding_box(elements)
-    
+
     # Calculate offset
     offset_x = target_x - min_x
     offset_y = target_y - min_y
-    
+
     # Create ID mapping: old_id -> new_id
     id_mapping = {}
     for element in elements:
         if 'id' in element:
             old_id = element['id']
             id_mapping[old_id] = generate_unique_id()
-    
+
     # Create group ID mapping
     group_id_mapping = {}
     for element in elements:
@@ -98,47 +98,47 @@ def transform_icon_elements(
             for old_group_id in element['groupIds']:
                 if old_group_id not in group_id_mapping:
                     group_id_mapping[old_group_id] = generate_unique_id()
-    
+
     # Transform elements
     transformed = []
     for element in elements:
         new_element = element.copy()
-        
+
         # Update coordinates
         if 'x' in new_element:
             new_element['x'] = new_element['x'] + offset_x
         if 'y' in new_element:
             new_element['y'] = new_element['y'] + offset_y
-        
+
         # Update ID
         if 'id' in new_element:
             new_element['id'] = id_mapping[new_element['id']]
-        
+
         # Update group IDs
         if 'groupIds' in new_element:
             new_element['groupIds'] = [
                 group_id_mapping[gid] for gid in new_element['groupIds']
             ]
-        
+
         # Update binding references if they exist
         if 'startBinding' in new_element and new_element['startBinding']:
             if 'elementId' in new_element['startBinding']:
                 old_id = new_element['startBinding']['elementId']
                 if old_id in id_mapping:
                     new_element['startBinding']['elementId'] = id_mapping[old_id]
-        
+
         if 'endBinding' in new_element and new_element['endBinding']:
             if 'elementId' in new_element['endBinding']:
                 old_id = new_element['endBinding']['elementId']
                 if old_id in id_mapping:
                     new_element['endBinding']['elementId'] = id_mapping[old_id]
-        
+
         # Update containerId if it exists
         if 'containerId' in new_element and new_element['containerId']:
             old_id = new_element['containerId']
             if old_id in id_mapping:
                 new_element['containerId'] = id_mapping[old_id]
-        
+
         # Update boundElements if they exist
         if 'boundElements' in new_element and new_element['boundElements']:
             new_bound_elements = []
@@ -149,31 +149,31 @@ def transform_icon_elements(
                         bound_elem['id'] = id_mapping[old_id]
                 new_bound_elements.append(bound_elem)
             new_element['boundElements'] = new_bound_elements
-        
+
         transformed.append(new_element)
-    
+
     return transformed
 
 
 def load_icon(icon_name: str, library_path: Path) -> List[Dict[str, Any]]:
     """
     Load icon elements from library.
-    
+
     Args:
         icon_name: Name of the icon (e.g., "EC2", "VPC")
         library_path: Path to the icon library directory
-    
+
     Returns:
         List of icon elements
     """
     icon_file = library_path / "icons" / f"{icon_name}.json"
-    
+
     if not icon_file.exists():
         raise FileNotFoundError(f"Icon file not found: {icon_file}")
-    
+
     with open(icon_file, 'r', encoding='utf-8') as f:
         icon_data = json.load(f)
-    
+
     return icon_data.get('elements', [])
 
 
@@ -216,12 +216,12 @@ def finalize_edit_path(work_path: Path, final_path: Path | None) -> None:
 def create_text_label(text: str, x: float, y: float) -> Dict[str, Any]:
     """
     Create a text label element.
-    
+
     Args:
         text: Label text
         x: X coordinate
         y: Y coordinate
-    
+
     Returns:
         Text element dictionary
     """
@@ -274,7 +274,7 @@ def add_icon_to_diagram(
 ) -> None:
     """
     Add an icon to an Excalidraw diagram.
-    
+
     Args:
         diagram_path: Path to the Excalidraw diagram file
         icon_name: Name of the icon to add
@@ -287,43 +287,43 @@ def add_icon_to_diagram(
     print(f"Loading icon: {icon_name}")
     icon_elements = load_icon(icon_name, library_path)
     print(f"  Loaded {len(icon_elements)} elements")
-    
+
     # Transform icon elements
     print(f"Transforming to position ({x}, {y})")
     transformed_elements = transform_icon_elements(icon_elements, x, y)
-    
+
     # Calculate icon bounding box for label positioning
     if label and transformed_elements:
         min_x, min_y, max_x, max_y = calculate_bounding_box(transformed_elements)
         icon_width = max_x - min_x
         icon_height = max_y - min_y
-        
+
         # Position label below icon, centered
         label_x = min_x + (icon_width / 2) - (len(label) * 5)
         label_y = max_y + 10
-        
+
         label_element = create_text_label(label, label_x, label_y)
         transformed_elements.append(label_element)
         print(f"  Added label: '{label}'")
-    
+
     # Load diagram
     print(f"Loading diagram: {diagram_path}")
     with open(diagram_path, 'r', encoding='utf-8') as f:
         diagram = json.load(f)
-    
+
     # Add transformed elements
     if 'elements' not in diagram:
         diagram['elements'] = []
-    
+
     original_count = len(diagram['elements'])
     diagram['elements'].extend(transformed_elements)
     print(f"  Added {len(transformed_elements)} elements (total: {original_count} -> {len(diagram['elements'])})")
-    
+
     # Save diagram
     print(f"Saving diagram")
     with open(diagram_path, 'w', encoding='utf-8') as f:
         json.dump(diagram, f, indent=2, ensure_ascii=False)
-    
+
     print(f"✓ Successfully added '{icon_name}' icon to diagram")
 
 
@@ -342,22 +342,22 @@ def main():
         print("  python add-icon-to-diagram.py diagram.excalidraw EC2 500 300")
         print("  python add-icon-to-diagram.py diagram.excalidraw EC2 500 300 --label 'Web Server'")
         sys.exit(1)
-    
+
     diagram_path = Path(sys.argv[1])
     icon_name = sys.argv[2]
     x = float(sys.argv[3])
     y = float(sys.argv[4])
-    
+
     # Default library path
     script_dir = Path(__file__).parent
     default_library_path = script_dir.parent / "libraries" / "aws-architecture-icons"
-    
+
     # Parse optional arguments
     library_path = default_library_path
     label = None
     # Default: use edit suffix to avoid editor overwrite issues
     use_edit_suffix = True
-    
+
     i = 5
     while i < len(sys.argv):
         if sys.argv[i] == '--library-path':
@@ -383,16 +383,16 @@ def main():
         else:
             print(f"Error: Unknown option: {sys.argv[i]}")
             sys.exit(1)
-    
+
     # Validate inputs
     if not diagram_path.exists():
         print(f"Error: Diagram file not found: {diagram_path}")
         sys.exit(1)
-    
+
     if not library_path.exists():
         print(f"Error: Library path not found: {library_path}")
         sys.exit(1)
-    
+
     try:
         work_path, final_path = prepare_edit_path(diagram_path, use_edit_suffix)
         add_icon_to_diagram(work_path, icon_name, x, y, library_path, label)
@@ -404,4 +404,3 @@ def main():
 
 if __name__ == '__main__':
     main()
-

package/template/.claude/skills/grill-me/SKILL.md

@@ -0,0 +1,7 @@
+---
+name: grill-me
+description: A relentless interview to sharpen a plan or design.
+disable-model-invocation: true
+---
+
+Run a `/grilling` session.

package/template/.claude/skills/grill-me/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Grill Me"
+  short_description: "Sharpen a plan through interview"
+policy:
+  allow_implicit_invocation: false

package/template/.claude/skills/grill-with-docs/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Grill with Docs"
+  short_description: "Grill a design and write its docs"
+policy:
+  allow_implicit_invocation: false

package/template/.claude/skills/grilling/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: grilling
+description: Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases.
+---
+
+Interview me relentlessly about every aspect of this until we reach a shared understanding. Walk down each branch of the decision tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
+
+Ask the questions one at a time, waiting for feedback on each question before continuing. Asking multiple questions at once is bewildering.
+
+If a *fact* can be found by exploring the environment (filesystem, tools, etc.), look it up rather than asking me. The *decisions*, though, are mine — put each one to me and wait for my answer.
+
+Do not act on it until I confirm we have reached a shared understanding.

package/template/.claude/skills/grilling/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Grilling"
+  short_description: "Stress-test thinking one question at a time"

package/template/.claude/skills/handoff/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: handoff
+description: Compact the current conversation into a handoff document for another agent to pick up.
+argument-hint: "What will the next session be used for?"
+disable-model-invocation: true
+---
+
+Write a handoff document summarising the current conversation so a fresh agent can continue the work. Save to the temporary directory of the user's OS - not the current workspace.
+
+Include a "suggested skills" section in the document, which suggests skills that the agent should invoke.
+
+Do not duplicate content already captured in other artifacts (specs, plans, ADRs, issues, commits, diffs). Reference them by path or URL instead.
+
+Redact any sensitive information, such as API keys, passwords, or personally identifiable information.
+
+If the user passed arguments, treat them as a description of what the next session will focus on and tailor the doc accordingly.

package/template/.claude/skills/handoff/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Handoff"
+  short_description: "Compact a conversation into a handoff"
+policy:
+  allow_implicit_invocation: false

package/template/.claude/skills/implement/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: implement
-description: "Implement a piece of work based on a PRD or set of issues."
+description: "Implement a piece of work based on a spec or set of tickets."
 disable-model-invocation: true
 ---
 
-Implement the work described by the user in the PRD or issues.
+Implement the work described by the user in the spec or tickets.
 
 Use /tdd where possible, at pre-agreed seams.
 

package/template/.claude/skills/implement/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Implement"
+  short_description: "Build work from a spec or tickets"
+policy:
+  allow_implicit_invocation: false

package/template/.claude/skills/improve-codebase-architecture/SKILL.md

@@ -17,6 +17,11 @@ This command is _informed_ by the project's domain model and built on a shared d
 
 ### 1. Explore
 
+**Scope before you scan — YAGNI.** Deepening a module pays off by making future changes to it easier, so put extra weight on the parts of the codebase that have recently changed. Decide *where* to look before you look:
+
+- If the user named a direction — a module, a subsystem, a pain point — take it, and skip the inference below.
+- Otherwise, walk back a good stretch of the commit history (`git log --oneline`) to find the codebase's hot spots — the files and areas that keep coming up — and let those paths pull your attention first. If the changes are scattered with no clear hot spot, widen the net.
+
 Read the project's domain glossary (`CONTEXT.md`) and any ADRs in the area you're touching first.
 
 Then use the Agent tool with `subagent_type=Explore` to walk the codebase. Don't follow rigid heuristics — explore organically and note where you experience friction:
@@ -56,7 +61,7 @@ Do NOT propose interfaces yet. After the file is written, ask the user: "Which o
 
 ### 3. Grilling loop
 
-Once the user picks a candidate, run the `/grilling` skill to walk the design tree with them — constraints, dependencies, the shape of the deepened module, what sits behind the seam, what tests survive.
+Once the user picks a candidate, run the `/grilling` skill to walk the decision tree with them — constraints, dependencies, the shape of the deepened module, what sits behind the seam, what tests survive.
 
 Side effects happen inline as decisions crystallize — run the `/domain-modeling` skill to keep the domain model current as you go:
 

package/template/.claude/skills/improve-codebase-architecture/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Improve Codebase Architecture"
+  short_description: "Find and grill architecture improvements"
+policy:
+  allow_implicit_invocation: false

package/template/.claude/skills/prototype/LOGIC.md

@@ -36,7 +36,7 @@ The right shape depends on the question:
 
 Pick whichever shape best fits the question being asked, *not* whichever is easiest to wire to a TUI. Keep it pure: no I/O, no terminal code, no `console.log` for control flow. The TUI imports it and calls into it; nothing flows the other direction.
 
-This is what makes the prototype useful past its own lifetime. When the question's been answered, the validated reducer / machine / function set can be lifted into the real module — the TUI shell gets deleted.
+This is what makes the prototype useful past its own lifetime: when the question's been answered, the validated reducer / machine / function set can be lifted into the real module on its own.
 
 ### 4. Build the smallest TUI that exposes the state
 
@@ -66,9 +66,9 @@ If the host project has no task runner, just put the command at the top of the p
 
 Give the user the run command. They'll drive it themselves; the interesting moments are when they say "wait, that shouldn't be possible" or "huh, I assumed X would be different" — those are the bugs in the _idea_, which is the whole point. If they want new actions added, add them. Prototypes evolve.
 
-### 7. Capture the answer
+### 7. Capture the answer and the prototype
 
-When the prototype has done its job, the answer to the question is the only thing worth keeping. If the user is around, ask what it taught them. If not, leave a `NOTES.md` next to the prototype so the answer can be filled in (or filled in by you, if you've watched the session) before the prototype gets deleted.
+Once the prototype has answered its question, capture the answer, then capture the prototype the way the [SKILL](SKILL.md) describes. The logic-specific mapping: the validated reducer / machine / function set lifts into the real module (the decision, absorbed); the TUI shell rides along to the throwaway branch that keeps the prototype as a primary source.
 
 ## Anti-patterns
 

package/template/.claude/skills/prototype/SKILL.md

@@ -21,10 +21,6 @@ The two branches produce very different artifacts — getting this wrong wastes
 1. **Throwaway from day one, and clearly marked as such.** Locate the prototype code close to where it will actually be used (next to the module or page it's prototyping for) so context is obvious — but name it so a casual reader can see it's a prototype, not production. For throwaway UI routes, obey whatever routing convention the project already uses; don't invent a new top-level structure.
 2. **One command to run.** Whatever the project's existing task runner supports — `pnpm <name>`, `python <path>`, `bun <path>`, etc. The user must be able to start it without thinking.
 3. **No persistence by default.** State lives in memory. Persistence is the thing the prototype is _checking_, not something it should depend on. If the question explicitly involves a database, hit a scratch DB or a local file with a clear "PROTOTYPE — wipe me" name.
-4. **Skip the polish.** No tests, no error handling beyond what makes the prototype _runnable_, no abstractions. The point is to learn something fast and then delete it.
+4. **Skip the polish.** No tests, no error handling beyond what makes the prototype _runnable_, no abstractions. The point is to learn something fast.
 5. **Surface the state.** After every action (logic) or on every variant switch (UI), print or render the full relevant state so the user can see what changed.
-6. **Delete or absorb when done.** When the prototype has answered its question, either delete it or fold the validated decision into the real code — don't leave it rotting in the repo.
-
-## When done
-
-The _answer_ is the only thing worth keeping from a prototype. Capture it somewhere durable (commit message, ADR, issue, or a `NOTES.md` next to the prototype) along with the question it was answering. If the user is around, that capture is a quick conversation; if not, leave the placeholder so they (or you, on the next pass) can fill in the verdict before deleting the prototype.
+6. **Capture it when done.** Fold any validated decision into the real code, then capture the prototype itself as a **primary source**: commit it to a throwaway branch, out of main, and leave a context pointer to that branch on the implementation issue. Capture the answer too — the verdict and the question it settled — in the issue or a commit. The main branch keeps only the validated decision.

package/template/.claude/skills/prototype/UI.md

@@ -97,12 +97,12 @@ Surface the URL (and the `?variant=` keys). The user will flip through whenever
 
 ### 6. Capture the answer and clean up
 
-Once a variant has won, write down which one and why (commit message, ADR, issue, or a `NOTES.md` next to the prototype if running AFK and the user hasn't responded yet). Then:
+Once a variant has won, capture the answer — which variant and why — then capture the prototype the way the [SKILL](SKILL.md) describes. Fold the winner into the real code and move the rest onto the throwaway branch, not into main:
 
-- **Sub-shape A** — delete the losing variants and the switcher; fold the winner into the existing page.
-- **Sub-shape B** — promote the winning variant to a real route, delete the throwaway route and the switcher.
+- **Sub-shape A** — fold the winner into the existing page; drop the losing variants and the switcher from main.
+- **Sub-shape B** — promote the winning variant to a real route; drop the throwaway route and the switcher from main.
 
-Don't leave variant components or the switcher lying around. They rot fast and confuse the next reader.
+The full set of variants is the primary source, so it lands on the throwaway branch, not the bin — variant components and the switcher left in the main branch rot fast and confuse the next reader.
 
 ## Anti-patterns
 

package/template/.claude/skills/prototype/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Prototype"
+  short_description: "Prototype to answer a design question"

package/template/.claude/skills/research/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Research"
+  short_description: "Research from high-trust sources"

package/template/.claude/skills/resolving-merge-conflicts/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Resolving Merge Conflicts"
+  short_description: "Resolve merge and rebase conflicts"