ateschh-kit 1.0.0

package/workflows/map-codebase.md

@@ -0,0 +1,136 @@
+---
+command: "/map-codebase"
+description: "Analyzes an existing codebase before starting work. Spawns 4 parallel mapper agents."
+phase: "pre-start"
+agents: ["architect", "requirements-expert", "tester", "coder"]
+skills: []
+outputs: [".planning/codebase/ (7 documentation files)"]
+---
+
+# /map-codebase — Map an Existing Codebase
+
+## What This Does
+
+Before working on an existing project (vs. starting from scratch), this command spawns 4 parallel mapper agents to analyze the codebase and generate structured documentation.
+
+Output is saved to `.planning/codebase/` and feeds into `/new-project` for projects you're taking over.
+
+Inspired by GSD's `/gsd-map-codebase` command.
+
+## When to Use
+
+- Taking over an existing project
+- Resuming work on a project that wasn't built with this system
+- Onboarding to a team codebase
+
+## Mapper Agents (Run in Parallel)
+
+### Agent 1 — Tech Stack Mapper
+Reads: package.json / pubspec.yaml / go.mod / requirements.txt / etc.
+Identifies:
+- Runtime and framework (with versions)
+- All installed packages and their purpose
+- Build tools and CI/CD
+Output: `.planning/codebase/01-tech-stack.md`
+
+### Agent 2 — Architecture Mapper
+Reads: folder structure, main entry points, routing files
+Identifies:
+- Directory structure and conventions
+- Key modules and their responsibilities
+- Data flow patterns
+- External service integrations
+Output: `.planning/codebase/02-architecture.md`
+
+### Agent 3 — Quality & Standards Mapper
+Reads: ESLint/TSConfig/Prettier configs, test files, CI config
+Identifies:
+- Code style rules in use
+- Test coverage and testing patterns
+- Type safety level
+- Known issues (TODOs, FIXMEs, deprecated usages)
+Output: `.planning/codebase/03-quality-standards.md`
+
+### Agent 4 — Core Concerns Mapper
+Reads: auth files, database schema, API routes, state management
+Identifies:
+- Auth architecture
+- Database schema summary
+- Core business logic
+- State management approach
+Output: `.planning/codebase/04-core-concerns.md`
+
+## Steps
+
+### Step 1: Confirm Directory
+
+Ask: "What folder are we analyzing? (current directory or specify path)"
+
+### Step 2: Launch All 4 Agents
+
+Launch all 4 simultaneously — they work in parallel.
+
+Status update while running:
+```
+🔍 Mapping codebase...
+  [1/4] Tech stack mapper... ✅
+  [2/4] Architecture mapper... 🔄
+  [3/4] Quality mapper... 🔄
+  [4/4] Core concerns mapper... ✅
+```
+
+### Step 3: Synthesize
+
+After all 4 complete, generate:
+
+`.planning/codebase/05-summary.md`:
+```markdown
+# Codebase Summary
+
+**Tech Stack**: {one-line summary}
+**Architecture**: {pattern — e.g., monorepo, MVC, feature-based}
+**Quality Level**: {estimated — poor / fair / good / excellent}
+**Complexity**: {low / medium / high}
+
+## Top 3 things to know
+1. ...
+2. ...
+3. ...
+
+## Top 3 risks or problems
+1. ...
+2. ...
+3. ...
+```
+
+`.planning/codebase/06-getting-started.md` — how to run the project locally
+
+`.planning/codebase/07-conventions.md` — coding conventions in use (naming, file structure, patterns)
+
+### Step 4: Report to User
+
+```
+✅ Codebase mapped!
+
+📁 .planning/codebase/ — 7 files generated:
+  01-tech-stack.md
+  02-architecture.md
+  03-quality-standards.md
+  04-core-concerns.md
+  05-summary.md
+  06-getting-started.md
+  07-conventions.md
+
+Tech Stack: {one-line}
+Quality Level: {rating}
+Top risk: {top finding}
+
+Ready to start working! Run /new-project to set up project tracking,
+or ask me anything about the codebase.
+```
+
+## Notes
+
+- This workflow does NOT modify any existing code
+- All output is read-only documentation in `.planning/`
+- Use `/quick` for immediate one-off tasks on the codebase

package/workflows/new-project.md

@@ -0,0 +1,96 @@
+---
+command: "/new-project"
+description: "Starts a new project, creates folder structure and base files"
+phase: "start"
+agents: []
+skills: []
+outputs: ["projects/{name}/ folder", "Updated ACTIVE-PROJECT.md"]
+---
+
+# /new-project — Start a New Project
+
+## When to Use
+
+When you want to start working on a new application idea.
+
+## Prerequisites
+
+- No active project (if one exists, ask the user to `/finish` or archive it first)
+
+## Steps
+
+### Step 1: Check for Active Project
+
+Read `.state/ACTIVE-PROJECT.md`:
+- If active project exists → "You're currently working on {project}. Finish it first (`/finish`) or archive it. Shall I continue?"
+- If no active project → proceed
+
+### Step 2: Get Project Info
+
+Ask the user 2 things:
+```
+1. What should the project be called? (no spaces or special characters, e.g., my-app)
+2. In one sentence, what does it do?
+```
+
+### Step 3: Create Folder Structure
+
+Create `projects/{name}/` folder.
+
+Copy from templates:
+- `templates/project/REQUIREMENTS.md` → `projects/{name}/REQUIREMENTS.md`
+- `templates/project/DESIGN.md` → `projects/{name}/DESIGN.md`
+- `templates/project/STRUCTURE.md` → `projects/{name}/STRUCTURE.md`
+- `templates/project/STATE.md` → `projects/{name}/STATE.md`
+- `templates/project/PLAN.md` → `projects/{name}/PLAN.md`
+- `templates/project/DECISIONS.md` → `projects/{name}/DECISIONS.md`
+
+Also create:
+- `projects/{name}/BACKLOG.md` (empty)
+- `projects/{name}/sessions/` (folder)
+- `projects/{name}/src/` (folder)
+
+### Step 4: Fill in STATE.md
+
+Update with:
+- Project name
+- Start date (today)
+- Phase 1 IN PROGRESS
+
+### Step 5: Update ACTIVE-PROJECT.md
+
+Write to `.state/ACTIVE-PROJECT.md`:
+```markdown
+# Active Project
+
+- **Project**: {name}
+- **Path**: projects/{name}
+- **Phase**: 1/6
+- **Last worked on**: {today}
+- **Next task**: Run /brainstorm and describe your idea
+```
+
+### Step 6: Update SESSION-LOG.md
+
+Append to `.state/SESSION-LOG.md`:
+```
+## {date} — {name}
+- **Done**: Project created
+- **Status**: Phase 1 starting
+- **Next**: /brainstorm
+```
+
+### Step 7: Confirm to User
+
+```
+✅ Project "{name}" created!
+
+📁 Folder: projects/{name}
+📋 Phase: 1/6 — Idea & Research
+
+Ready! Now use `/brainstorm` and tell me about your idea.
+```
+
+## Next Step
+
+`/brainstorm`

package/workflows/next.md

@@ -0,0 +1,79 @@
+---
+command: "/next"
+description: "Auto-pilot: reads STATE.md and runs the correct next step automatically."
+phase: "any"
+agents: []
+skills: []
+outputs: ["Executes the appropriate next workflow"]
+---
+
+# /next — Auto-Pilot
+
+## What This Does
+
+Reads your project's current state and automatically runs the right next step.
+No manual decision required from the user.
+
+Inspired by GSD's `/gsd-next` command.
+
+## Steps
+
+### Step 1: Read State
+
+Read `.state/ACTIVE-PROJECT.md` → get active project name.
+Read `projects/{name}/STATE.md` → get current phase and task.
+
+### Step 2: Determine Next Action
+
+Use this decision tree:
+
+```
+No active project?
+→ Tell user to run /new-project
+
+Phase 1 not complete?
+→ Run /brainstorm
+
+Phase 2 not complete?
+→ Run /requirements
+
+Phase 3 not complete?
+→ Run /design
+
+Phase 4 in progress?
+→ Run /build (next unchecked task in PLAN.md)
+
+Phase 4 complete?
+→ Run /test
+
+Phase 5 complete?
+→ Run /deploy
+
+Phase 6 complete?
+→ Run /finish
+
+State is unclear?
+→ Run /status and ask user what to do next
+```
+
+### Step 3: Announce What You're About to Do
+
+Before executing:
+```
+🤖 Auto-pilot: {detected state}
+➡️ Running: /{command} — {reason}
+
+Proceeding in 3 seconds... (type "stop" to cancel)
+```
+
+If no response in 3 seconds → execute.
+
+### Step 4: Execute
+
+Run the detected workflow exactly as if the user typed its command.
+
+## Tips
+
+- Run `/next` repeatedly to move through phases automatically
+- If something goes wrong, `/status` gives a full picture
+- `/quick` is for one-off tasks that don't fit the main pipeline

package/workflows/quick.md

@@ -0,0 +1,82 @@
+---
+command: "/quick"
+description: "Ad-hoc task without the full pipeline. For small, one-off requests."
+phase: "any"
+agents: []
+skills: []
+outputs: ["Completed ad-hoc task", "Logged in BACKLOG.md if relevant"]
+---
+
+# /quick — Quick Task
+
+## What This Does
+
+Handles small, focused tasks that don't need the full new-project pipeline.
+For things like: "add dark mode", "fix this bug", "refactor this file", "explain this code".
+
+Inspired by GSD's `/gsd-quick` command.
+
+## When to Use
+
+✅ Use `/quick` for:
+- Bug fixes
+- Small feature additions
+- Code explanations or reviews
+- Refactoring a specific file
+- One-off scripts or utilities
+
+❌ Don't use `/quick` for:
+- Starting a new full project (use `/new-project`)
+- Anything that touches REQUIREMENTS.md or DESIGN.md
+- Multi-day features
+
+## Steps
+
+### Step 1: Get the Task
+
+Ask the user (if not already stated in the command):
+```
+What do you want to do? (be specific — one sentence)
+```
+
+### Step 2: Mini-Plan
+
+Generate a quick plan (max 3 steps):
+```
+Quick Task Plan:
+1. {step 1}
+2. {step 2}
+3. {step 3}
+
+Estimated time: {X minutes}
+Files affected: {list}
+
+Proceed?
+```
+
+### Step 3: Execute
+
+Execute the plan directly — no agent spawning unless task is complex (>50 lines).
+
+Run L1+L2 checks after (same as /build).
+
+### Step 4: Log if Relevant
+
+If the task reveals something for the main project:
+- Bug found → log fix in STATE.md
+- Feature idea → add to BACKLOG.md
+- Decision made → log in DECISIONS.md
+
+### Step 5: Confirm
+
+```
+✅ Done: {what was done}
+
+{result or output}
+
+Back to your main project whenever you're ready.
+```
+
+## Context
+
+`/quick` does NOT change the active project or STATE.md unless the task is directly related to it.

package/workflows/requirements.md

@@ -0,0 +1,85 @@
+---
+command: "/requirements"
+description: "Selects and locks the tech stack. Run after /brainstorm."
+phase: "2"
+agents: ["requirements-expert"]
+skills: ["requirements-lock"]
+outputs: ["Locked REQUIREMENTS.md", "Updated STATE.md", "DECISIONS.md entry"]
+---
+
+# /requirements — Define & Lock Tech Stack
+
+## When to Use
+
+After `/brainstorm` is complete and the idea is validated.
+
+## Steps
+
+### Step 1: Verify Phase
+
+Read `projects/{name}/STATE.md`. Confirm Phase 1 is complete.
+
+### Step 2: Spawn Requirements Expert Agent
+
+Read `agents/requirements-expert.md` and spawn the agent.
+
+The agent:
+1. Reads the idea summary from the session
+2. Evaluates the best tech stack based on:
+   - Platform target (web, mobile, game, backend)
+   - Scale expectations
+   - Deployment requirements
+   - User's stated preferences (if any)
+3. Proposes a full stack with reasoning
+4. Uses Context7 MCP to verify library compatibility if needed
+
+### Step 3: Present Stack to User
+
+```
+## Proposed Tech Stack for {project}
+
+| Category | Technology | Why |
+|----------|-----------|-----|
+| Framework | ... | ... |
+| Database | ... | ... |
+| Auth | ... | ... |
+| UI | ... | ... |
+| Deploy | ... | ... |
+```
+
+Ask: "Does this stack work for you? Once confirmed, it cannot be changed without formal review."
+
+### Step 4: Lock REQUIREMENTS.md
+
+Use the `requirements-lock` skill:
+- Fill in `projects/{name}/REQUIREMENTS.md` completely
+- Set status to **LOCKED ✅**
+- Include all versions
+
+### Step 5: Log Decision
+
+Append to `projects/{name}/DECISIONS.md`:
+```
+## {date} — Tech Stack Locked
+- Selected: {framework, DB, etc.}
+- Reason: {brief rationale}
+```
+
+### Step 6: Update STATE.md
+
+Mark Phase 2 complete. Set next task to `/design`.
+
+### Step 7: Confirm to User
+
+```
+✅ Tech stack locked!
+
+REQUIREMENTS.md is now frozen. If you want to change anything later,
+we'll need to formally review and potentially refactor.
+
+Next: `/design` — let's define the app structure and visual style.
+```
+
+## Next Step
+
+`/design`

package/workflows/resume.md

@@ -0,0 +1,55 @@
+---
+command: "/resume"
+description: "Restores context from the last saved session. Use when returning to a project."
+phase: "any"
+agents: []
+skills: ["context-management"]
+outputs: ["Context restored", "3-line status summary"]
+---
+
+# /resume — Resume Where You Left Off
+
+## When to Use
+
+- When returning to a project after a break
+- After switching from another AI platform
+- After running `/save` on a different device
+
+## Steps
+
+### Step 1: Read ACTIVE-PROJECT.md
+
+Check `.state/ACTIVE-PROJECT.md`:
+- If no active project → ask "Which project? List available in `projects/`"
+- If active project found → proceed
+
+### Step 2: Read Context Chain
+
+Read in order:
+1. `.state/ACTIVE_CONTEXT.md` → current project snapshot
+2. `projects/{name}/STATE.md` → live progress
+3. `projects/{name}/PLAN.md` → task list
+
+### Step 3: Read Latest Session File
+
+Find the most recent `projects/{name}/sessions/session-NNN.md`.
+Extract what was done last and what was planned next.
+
+### Step 4: Report to User
+
+```
+✅ Context restored!
+
+📁 Project: {name}
+📋 Phase: {N}/6 — {phase name}
+✅ Last done: {last completed task}
+➡️ Next up: {next task}
+
+Ready to continue? Run `/build` or `/next`.
+```
+
+### Step 5: Ask to Continue
+
+"Want to pick up where we left off?"
+- Yes → auto-detect the right command (see `/next`)
+- No → wait for user instruction

package/workflows/save.md

@@ -0,0 +1,111 @@
+---
+command: "/save"
+description: "Saves current context for cross-platform continuation. Run before switching AI tools."
+phase: "any"
+agents: []
+skills: ["context-management"]
+outputs: ["ACTIVE_CONTEXT.md", "sessions/session-NNN.md", "MEMORY.md updated"]
+---
+
+# /save — Save Context
+
+## When to Use
+
+- Before ending a session
+- Before switching from Claude Code to Antigravity (or vice versa)
+- When context window is getting full (DEGRADING zone)
+
+## Steps
+
+### Step 1: Read Current State
+
+Read:
+- `.state/ACTIVE-PROJECT.md`
+- `projects/{name}/STATE.md`
+- `projects/{name}/PLAN.md`
+
+### Step 2: Determine Session Number
+
+Check `projects/{name}/sessions/` → count existing files → next is session-{NNN}.md
+
+### Step 3: Write Session File
+
+Create `projects/{name}/sessions/session-{NNN}.md`:
+
+```markdown
+# Session {NNN} — {date}
+
+## What was done this session
+{bullet list of tasks completed}
+
+## Current state
+- Phase: {N}/6
+- Last completed task: {task}
+- Next task: {task}
+- Files changed: {file list}
+
+## Context notes
+{any important decisions or context that isn't in STATE.md}
+
+## Blockers (if any)
+{list or "None"}
+```
+
+### Step 4: Compress to ACTIVE_CONTEXT.md
+
+Write to `.state/ACTIVE_CONTEXT.md` — a 1-page summary:
+
+```markdown
+# Active Context — {date}
+
+**Project**: {name}
+**Phase**: {N}/6
+**Status**: {brief description}
+
+## What's done
+{3-5 bullet points}
+
+## What's next
+{next task}
+
+## Key decisions made
+{brief list}
+
+## Where to find things
+- Main code: projects/{name}/src/
+- Requirements: projects/{name}/REQUIREMENTS.md
+- Design system: projects/{name}/DESIGN.md
+```
+
+### Step 5: Update MEMORY.md
+
+Update the Claude memory file (found via memory path detection):
+- Add a link to the latest session file
+- Update the "Current state" section
+
+### Step 6: Update SESSION-LOG.md
+
+Append to `.state/SESSION-LOG.md`:
+```
+## {date} — {name}
+- **Done**: {what was completed}
+- **Status**: Phase {N}, {current task}
+- **Next**: {next task}
+```
+
+### Step 7: Confirm to User
+
+```
+✅ Context saved!
+
+📄 Session log: projects/{name}/sessions/session-{NNN}.md
+🧠 Active context: .state/ACTIVE_CONTEXT.md
+
+To continue on another platform:
+1. Open this directory in the new AI tool
+2. Type `/resume`
+```
+
+## Next Step
+
+`/resume` (on any platform to continue)