skilledagent 1.0.0

package/.agents/skills-lock.json

@@ -0,0 +1,233 @@
+{
+  "version": 1,
+  "skills": {
+    "ask-matt": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/ask-matt/SKILL.md",
+      "computedHash": "36bdc2237661cbbe109823c6650223cc127bc7534f64edd88059152fa7300711"
+    },
+    "claude-handoff": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/in-progress/claude-handoff/SKILL.md",
+      "computedHash": "688e8f57440bc7b5ff526f41ccc31ab7ab146fd64f342bf625026fb024668f39"
+    },
+    "code-review": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/code-review/SKILL.md",
+      "computedHash": "83a7f80d5dd27bc682ec3ed742de0064d1fc88eea92814a7004465fc86b5ab2a"
+    },
+    "codebase-design": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/codebase-design/SKILL.md",
+      "computedHash": "c20e6e42a3034e553b1919fe94cf0928f0ff3c693fd5df802998dce7a4724eaf"
+    },
+    "design-an-interface": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/deprecated/design-an-interface/SKILL.md",
+      "computedHash": "f3f225914515407b8224e8ec6187db337c5e65bad0703936a0acb3f802947a7d"
+    },
+    "diagnosing-bugs": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/diagnosing-bugs/SKILL.md",
+      "computedHash": "c8743c51df3760039b2dcb8a5a61437da3128c6efb4c5381734a3f05403e9a84"
+    },
+    "domain-modeling": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/domain-modeling/SKILL.md",
+      "computedHash": "65da9ce611a203fc6b9ecf95254cf845857243d958cb0d64df556cad87c76312"
+    },
+    "edit-article": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/personal/edit-article/SKILL.md",
+      "computedHash": "9a96975e2eaf1ce5c69c14429aea7d2039e2f6f5a73938520b653de84841d9e3"
+    },
+    "git-guardrails-claude-code": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/misc/git-guardrails-claude-code/SKILL.md",
+      "computedHash": "a04bf71be9abc44ca3b00e2f1740b37d2e471abadd20d43a31bccff7135baedf"
+    },
+    "grill-me": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/productivity/grill-me/SKILL.md",
+      "computedHash": "67e31b63e6e9e454cc2f51cd85b9cf1396ee46379a87c07a1450f33c47c1276a"
+    },
+    "grill-with-docs": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/grill-with-docs/SKILL.md",
+      "computedHash": "559d4de044394b86af53a5cedd2d3a689770088c3c5361646c91f5d7ea59f78a"
+    },
+    "grilling": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/productivity/grilling/SKILL.md",
+      "computedHash": "5e05f3e63506a5c11f7bd202d26a1b38f331ea609bcd0ffd3b84eac9c8ac973a"
+    },
+    "handoff": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/productivity/handoff/SKILL.md",
+      "computedHash": "3f7fad93a3841d5315de80405a18fac9d32ca0f2287c24c305353b0b8568b6c8"
+    },
+    "implement": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/implement/SKILL.md",
+      "computedHash": "21d7160a81a70def69c3b2b6394943ea978f60b5b4658a4ac4a5b79799ae5597"
+    },
+    "improve-codebase-architecture": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/improve-codebase-architecture/SKILL.md",
+      "computedHash": "4c4d2b6da48482c1a054aca0e09eafd61cdcbebe2bda10abd3f355bf5f6fc57c"
+    },
+    "loop-me": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/in-progress/loop-me/SKILL.md",
+      "computedHash": "c36514ed0c932e8e245149a678f72de0cf2c3858612e2b4b7ec244e0070bf430"
+    },
+    "migrate-to-shoehorn": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/misc/migrate-to-shoehorn/SKILL.md",
+      "computedHash": "67fdd18f8f4f7c89b3003eb944220679272738c1deb680719fd2e282495d87f4"
+    },
+    "obsidian-vault": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/personal/obsidian-vault/SKILL.md",
+      "computedHash": "a5dd44e7af2bfeb2cb2e3f421fdccef62dd334038ad06e18767b0ddcf0e75c13"
+    },
+    "prototype": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/prototype/SKILL.md",
+      "computedHash": "d69b75e7b60e183d39b8a33cb8b2096e614fd9b48a5249c1cc951340961f86fa"
+    },
+    "qa": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/deprecated/qa/SKILL.md",
+      "computedHash": "a608d889794ef7f21a5dd31d96ca502b5e6f27b466ada759a3bf9846a2e6b236"
+    },
+    "request-refactor-plan": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/deprecated/request-refactor-plan/SKILL.md",
+      "computedHash": "6811250488d1dafcb111e7ef0dc1124211369c5f6f47ce820b7527c255489178"
+    },
+    "research": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/research/SKILL.md",
+      "computedHash": "88d5ba783b781d7dab941524e629cb2483d7f65ec79ef8d47a55ea9f6f3ee75b"
+    },
+    "resolving-merge-conflicts": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/resolving-merge-conflicts/SKILL.md",
+      "computedHash": "9050aa34dc026b5b28f5b63003a8742d0669daa6b2916c7a0f082ca9bfa50184"
+    },
+    "scaffold-exercises": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/misc/scaffold-exercises/SKILL.md",
+      "computedHash": "1127f69a77b48cb855067db4c9c42e7638e6672f1cb3fafb0ffd61a1ecdfae70"
+    },
+    "setup-matt-pocock-skills": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/setup-matt-pocock-skills/SKILL.md",
+      "computedHash": "7c4f945086d19c8b0f8f8adcf1a705767d894efb2afac129707816fded507a64"
+    },
+    "setup-pre-commit": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/misc/setup-pre-commit/SKILL.md",
+      "computedHash": "f2ce8663857d919cf7e4146cd716b0aee1757b85123b758e6e7d98fcbaf14054"
+    },
+    "tdd": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/tdd/SKILL.md",
+      "computedHash": "f23403cf05c3a4b0dec9983f7818cf1b53ebddd9cc406593fa46d9694b8c259a"
+    },
+    "teach": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/productivity/teach/SKILL.md",
+      "computedHash": "25bf44a1302ef009772c8e66d14a705672897562659c43650b1468012baa4f8d"
+    },
+    "to-spec": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/to-spec/SKILL.md",
+      "computedHash": "71b6e4dd625e894073e11e1e8057fe473d93d32956d9ada2370259c6497f4fcd"
+    },
+    "to-tickets": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/to-tickets/SKILL.md",
+      "computedHash": "8b9330e8ecec09a21b9b32e27a2d2475366c0afd993baf2477777cb5565f8111"
+    },
+    "triage": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/triage/SKILL.md",
+      "computedHash": "7caa274494d702d8c668d1ff17267b4a69b6d58e34a00c20b2df9de67ef6edc9"
+    },
+    "ubiquitous-language": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/deprecated/ubiquitous-language/SKILL.md",
+      "computedHash": "4828c4957014e7d9c1fd62d65e92264d6d46808089953e14d1bbba5a92dfff4d"
+    },
+    "wayfinder": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/wayfinder/SKILL.md",
+      "computedHash": "71d7080cec29cd00ef8173b1aa591f57a08e2a0a5ea6b6339a6ff2cf2895ccc1"
+    },
+    "wizard": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/in-progress/wizard/SKILL.md",
+      "computedHash": "0a48c11f8823cbfc2b7e6620d2f4fe097be12a13349bd7fe834da37a85b15c9e"
+    },
+    "writing-beats": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/in-progress/writing-beats/SKILL.md",
+      "computedHash": "e6fef438c5ad6263936706c4aea7f320d55da2dfab052f491488fb717d82aa9e"
+    },
+    "writing-fragments": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/in-progress/writing-fragments/SKILL.md",
+      "computedHash": "12baf297cf3feb042b8231e29566942d4ddd0eaaa13560d43b4641e1554e8ff3"
+    },
+    "writing-great-skills": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/productivity/writing-great-skills/SKILL.md",
+      "computedHash": "8a720e31b29ad7744b369fba7f21cd746a6b60e68ee1774aeca02f542a179a93"
+    },
+    "writing-shape": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/in-progress/writing-shape/SKILL.md",
+      "computedHash": "5f34ec8f61e2a4f0da9533b6049a71c3cde8c16b6d1077f4ccc1e3467dbebc2f"
+    }
+  }
+}

package/.agents/workflows/kickoff.md

@@ -0,0 +1,211 @@
+---
+description: Full idea-to-project orchestration pipeline — wayfind, grill, spec, ticket, implement, review.
+---
+
+# /kickoff — Orchestrated Project Pipeline
+
+This workflow chains the engineering skills into a complete idea → production pipeline. Execute each phase sequentially. **Never skip a phase or proceed without the user's explicit confirmation.**
+
+> **Trigger:** `/kickoff`
+> **Supports:** New projects from scratch AND existing codebase onboarding.
+
+---
+
+## 🧭 Mid-Workflow Skill Routing (Always Active)
+
+**This rule is active throughout the ENTIRE workflow, not just at the end.**
+
+At any point during the pipeline, if the user's prompt or the conversation context matches one of the skills below, you MUST proactively **suggest and explain** the relevant skill before continuing. Don't just use it silently — tell the user:
+
+1. **What the skill does** (one sentence)
+2. **Why it's relevant right now** (connect it to their current situation)
+3. **How it works** (brief — what they'll experience)
+4. **Ask if they want to use it**
+
+### Trigger-to-Skill Routing Table
+
+| User says / situation | Suggest this skill | Why |
+|---|---|---|
+| "something is broken", "this throws an error", "it's slow", "debug this" | `/diagnosing-bugs` | Structured 6-phase diagnosis loop — builds a feedback loop before hypothesizing, so you don't waste time guessing |
+| "I want to report bugs", "let's do QA", "I found some issues" | `/qa` | Interactive QA session — you describe bugs conversationally and the agent files proper GitHub issues with domain language |
+| "the architecture feels wrong", "this is getting messy", "how can I improve the code structure" | `/improve-codebase-architecture` | Scans for deepening opportunities, generates a visual HTML report, then grills through whichever one you pick |
+| "I want to refactor this", "let's plan a refactor" | `/request-refactor-plan` | Creates a detailed refactor plan broken into tiny safe commits, then files it as a GitHub issue |
+| "I need to research this", "look up how X works", "check the docs for Y" | `/research` | Spins up a background agent to investigate against primary sources (official docs, specs, source code) and saves findings as a markdown file |
+| "I want to build a quick prototype", "let's test if this works", "what should this look like" | `/prototype` | Builds a throwaway prototype to answer a design question — either logic (terminal app) or UI (multiple variations) |
+| "I want to automate this workflow", "what recurring tasks can I delegate" | `/loop-me` | Grills you about your recurring workflows and produces specs that an agent could implement without asking questions |
+| "hand this off", "continue in a fresh session", "save context" | `/handoff` | Compacts the conversation into a handoff doc so a fresh agent can pick up where you left off |
+| "help me design this module", "what should the interface look like" | `/codebase-design` + `/design-an-interface` | Deep module design vocabulary + parallel generation of radically different interface designs |
+| "set up pre-commit hooks", "add formatting on commit" | `/setup-pre-commit` | Wires up Husky + lint-staged with Prettier, type checking, and tests |
+| "I need a setup wizard", "walk me through configuring X" | `/wizard` | Generates an interactive bash wizard that walks you step-by-step through manual setup procedures |
+
+**Example interaction:**
+> User: "I think the auth module architecture is getting messy"
+> Agent: "It sounds like you might benefit from `/improve-codebase-architecture`. This skill scans your codebase for architectural friction, generates a visual HTML report showing deepening opportunities (where shallow modules can be made deeper), and then we grill through whichever one you want to tackle. Want me to run it?"
+
+---
+
+## Phase 1: Wayfinder — Chart the Map
+
+**Skill:** `/wayfinder`
+
+The project starts as a loose idea wrapped in fog. Use the Wayfinder to find the way.
+
+1. Run `/wayfinder` to chart a decision map.
+2. Name the **destination** — what does "done" look like for this project?
+3. Fan out **breadth-first** across the problem space: surface open decisions, unknowns, and the first steps takeable now.
+4. If the idea fits in a single session (no fog), skip the map and proceed directly to Phase 3.
+5. Otherwise, create the map issue with tickets, blocking edges, and fog.
+
+**Exit criteria:** The user says "Map looks good" or the destination is clear enough to proceed.
+
+---
+
+## Phase 2: Code Review — Existing Codebase Audit (if applicable)
+
+**Skill:** `/code-review`
+
+> **Skip this phase** if starting from scratch with no existing code.
+
+1. Ask the user for the fixed point (branch, commit, or tag) to compare against.
+2. Run `/code-review` to audit the existing code along two axes:
+   - **Standards:** Does the code follow documented coding standards?
+   - **Spec:** Does the code match any existing spec/PRD?
+3. Present findings to the user — these feed into the grilling phase.
+
+**Exit criteria:** User acknowledges the review findings.
+
+---
+
+## Phase 3: Grilling — Deep Q&A Interview
+
+**Skill:** `/grilling` + `/grill-with-docs` (uses `/domain-modeling` internally)
+
+This is the most critical phase. The goal is to reach **complete shared understanding** before any code is written.
+
+1. Run `/grilling` (or `/grill-with-docs` if you want ADRs and glossary created as you go).
+2. Interview the user **relentlessly** about every aspect of the project:
+   - Architecture decisions, tech stack, data models
+   - Edge cases, failure modes, concurrency strategies
+   - Integration points, external dependencies
+   - Testing strategy, acceptance criteria
+3. Ask questions **one at a time**, waiting for each answer.
+4. If a *fact* can be found by exploring the codebase, look it up — don't ask. The *decisions* are the user's.
+5. Use findings from Phase 2 (code review) to ask sharper questions.
+6. Generate / update `UBIQUITOUS_LANGUAGE.md` via `/domain-modeling`.
+
+**Exit criteria:** Both you and the user agree: "We have reached a shared understanding." There should be ZERO ambiguity about what will be built and how.
+
+---
+
+## Phase 4: Spec Synthesis
+
+**Skill:** `/to-spec`
+
+1. Run `/to-spec` to synthesize everything from Phases 1–3 into a formal spec.
+2. The spec includes: Problem Statement, Solution, User Stories, Implementation Decisions, Testing Decisions, Out of Scope.
+3. Present the spec to the user for review.
+4. Iterate until approved.
+
+**Exit criteria:** User explicitly says "Spec approved."
+
+---
+
+## Phase 5: Ticket Breakdown
+
+**Skill:** `/to-tickets`
+
+1. Run `/to-tickets` to break the approved spec into tracer-bullet vertical-slice tickets.
+2. Each ticket cuts through ALL layers (schema, API, UI, tests) — no horizontal slices.
+3. Declare blocking edges between tickets.
+4. Present the breakdown and quiz the user on granularity and dependencies.
+
+**Exit criteria:** User approves the ticket breakdown.
+
+---
+
+## Phase 6: Implementation
+
+**Skill:** `/implement` (uses `/tdd` and `/code-review` internally)
+
+1. Work the **frontier** — pick the first ticket whose blockers are all done.
+2. Run `/implement` for each ticket:
+   - Use `/tdd` at pre-agreed seams (Red-Green-Refactor)
+   - Run typechecking regularly
+   - Run single test files regularly, full suite at the end
+3. Commit work to the current branch after each ticket.
+4. Clear context between tickets for fresh sessions.
+
+**Exit criteria:** All tickets are implemented and passing.
+
+---
+
+## Phase 7: Post-Implementation Code Review
+
+**Skill:** `/code-review`
+
+1. Run `/code-review` against the branch/commit where implementation started.
+2. Review along both axes: Standards compliance and Spec conformance.
+3. Address any findings — fix issues, then re-review if needed.
+
+**Exit criteria:** Clean review on both axes.
+
+---
+
+## Phase 8: Suggestions & Next Steps
+
+No specific skill — this is a synthesis phase.
+
+1. Review the completed project holistically.
+2. Present to the user:
+   - **Current problems:** Any known issues, tech debt, or rough edges.
+   - **Improvement ideas:** Performance optimizations, UX improvements, additional features.
+   - **Architecture suggestions:** Refactoring opportunities, scalability concerns.
+   - **Security considerations:** Potential vulnerabilities or hardening needed.
+3. If the user wants to act on any suggestions, loop back to Phase 3 (Grilling) for the new work.
+
+**Exit criteria:** User is satisfied or chooses to start a new `/kickoff` cycle for follow-up work.
+
+---
+
+## Phase 9: Skill Discovery — What Else Can You Do?
+
+This is where you help the user **discover** the full power of the skill toolkit. Don't assume they know what's available — most users haven't read every skill file.
+
+Present each skill group below with a **one-line explanation** and **when to use it**. Ask the user which ones interest them.
+
+### 🔧 Maintenance & Quality
+
+| Skill | What it does | Use when… |
+|---|---|---|
+| `/qa` | Interactive bug-reporting session — you talk, the agent files issues | You've been using the app and found bugs to report |
+| `/improve-codebase-architecture` | Scans for shallow modules, generates HTML report, grills through fixes | The code works but feels messy or hard to navigate |
+| `/diagnosing-bugs` | Structured 6-phase diagnosis with a feedback loop before hypothesizing | Something is broken and you can't figure out why |
+| `/request-refactor-plan` | Plans a refactor as tiny safe commits, filed as a GitHub issue | You want to restructure code without breaking things |
+
+### 🔄 Workflow Automation
+
+| Skill | What it does | Use when… |
+|---|---|---|
+| `/loop-me` | Grills you about recurring tasks and produces implementable specs | You have repetitive work you want to automate |
+| `/wizard` | Generates an interactive bash wizard for manual setup procedures | You need to guide someone through a multi-step setup |
+| `/handoff` | Saves conversation context so a fresh agent can continue | You're running out of context window or switching sessions |
+
+### 🧠 Design & Research
+
+| Skill | What it does | Use when… |
+|---|---|---|
+| `/prototype` | Builds throwaway code to answer "does this logic work?" or "what should this look like?" | You're unsure about a design decision and want to test it fast |
+| `/research` | Background agent investigates against primary sources | You need to look up docs, API behavior, or technical facts |
+| `/codebase-design` | Deep module design vocabulary and principles | You're designing or refactoring module interfaces |
+
+### 🛡️ Setup & Safety
+
+| Skill | What it does | Use when… |
+|---|---|---|
+| `/setup-pre-commit` | Wires up Husky + lint-staged with Prettier, types, tests | You want code quality checks on every commit |
+| `/setup-matt-pocock-skills` | Configures issue tracker and triage label vocabulary | First-time setup of the engineering skill ecosystem |
+| `/git-guardrails-claude-code` | Blocks dangerous git commands (push, reset --hard, etc.) | You want safety rails on destructive git operations |
+
+**Action:** Ask the user: *"Would you like to try any of these? I can explain any skill in more detail or run it right now."*
+
+**Exit criteria:** User says they're done, or picks a skill to run.

package/README.md

@@ -0,0 +1,63 @@
+# ⚡ SkilledAgent — Elite Developer Agent Workspace
+
+SkilledAgent is a next-generation AI developer workspace and orchestration engine. By bundling 39 pre-configured cognitive skills and dynamic workflows directly inside your repository, SkilledAgent bridges the gap between basic script generation and elite, test-driven systems engineering.
+
+The entire system is contained natively in the `.agents/` directory, keeping your project root pristine. It can be easily added to any project or deleted entirely with a single command.
+
+---
+
+## ⚡ Quick Start (Get Running in 30 Seconds)
+
+You can activate SkilledAgent in any project instantly. Just open your terminal in the project root and do:
+
+```bash
+# 1. Install SkilledAgent natively into your current project folder
+npx skilledagent
+```
+
+Then, open your AI agent (like Gemini or Claude Code) and type:
+
+```
+/kickoff
+```
+
+**That's it!** The agent will instantly load the `.agents/` workflows and walk you through the 8-phase orchestration pipeline to bootstrap, structure, and write TDD-ready code for your features.
+
+---
+
+## ✨ Flagship features of SkilledAgent
+
+*   **Orchestration, Not Just Automation:** SkilledAgent doesn't just run commands; it orchestrates the entire software development lifecycle end-to-end. It guides you from vague product ideas through architectural mapping, spec synthesis, automated ticket breakdown, TDD implementation, and post-implementation review.
+*   **Dynamic Skill Selection & Sequencing:** Rather than following a rigid scripting path, SkilledAgent is truly agentic. Under the hood, it maintains a trigger-to-skill map. If you mention that database queries are slow, it immediately shifts context, explains, and proposes `/diagnosing-bugs`. If architecture feels messy, it suggests `/improve-codebase-architecture` to render an interactive HTML before-and-after visualization.
+*   **Abstraction from Complexity:** You don't need to read dozens of skill files or understand which command does what. By running `/kickoff`, the workspace guides you through the complex skill repository, letting you focus on answering questions and approving decisions while the system chooses the right skills underneath.
+*   **Rigorous Architectural Blueprinting:** SkilledAgent enforces system design rigor. Coding never begins without an approved spec (`/to-spec`) and a complete breakdown of vertical-slice, tracer-bullet tickets (`/to-tickets`).
+*   **Conversational Grilling & Context Integration:** Through `/grilling` and `/grill-with-docs`, the agent will stress-test your design tree one question at a time. It identifies ambiguities, extracts a ubiquitous domain language dictionary, and writes it directly to `CONTEXT.md` before generating code.
+
+---
+
+## 📁 Repository structure
+
+Once installed, your workspace is supercharged with:
+*   `.agents/skills/` — 39 custom cognitive capabilities (e.g. `/wayfinder`, `/implement`, `/tdd`, `/code-review`, `/qa`, `/improve-codebase-architecture`).
+*   `.agents/workflows/` — Orchestrated markdown workflows (like `/kickoff`) that chain skills together.
+*   `.agents/CONTEXT.md` — The global source-of-truth for technical standards, ubiquitous language, and system design rules.
+*   `.agents/AGENTS.MD` — The instruction manual for agent routing tables.
+*   `.agents/AGENTS_README.md` — The operations & command guide.
+*   `.agents/skills-lock.json` — Lockfile specifying installed capabilities.
+
+---
+
+## 🚀 How It Works (Next Steps)
+
+After running the quick installation above, the `/kickoff` command turns the AI agent into an active collaborator. Instead of manual prompt-engineering, you get a fully structured, 8-phase pipeline that drives your idea from a tentative concept into a working, automated TDD implementation.
+
+### Clean Removal
+At any point, if you want to remove all agent behaviors and return to a standard codebase, just delete the `.agents/` folder. Absolutely zero config/cache files are left in your repository root:
+
+*   **Linux / macOS:** `rm -rf .agents`
+*   **PowerShell:** `Remove-Item -Recurse -Force .agents`
+*   **Command Prompt:** `rmdir /s /q .agents`
+
+---
+
+For complete command details, refer to the operations guide at [.agents/AGENTS_README.md](.agents/AGENTS_README.md).

package/bin/cli.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+const srcDir = path.join(__dirname, '../.agents');
+const destDir = path.join(process.cwd(), '.agents');
+
+if (fs.existsSync(destDir)) {
+    console.error('Error: .agents directory already exists in this folder.');
+    process.exit(1);
+}
+
+console.log('Scaffolding SkilledAgent agent workspace into your project...');
+
+try {
+    // Use native recursive fs.cpSync (available since Node 16.7.0)
+    fs.cpSync(srcDir, destDir, { recursive: true });
+    console.log('Successfully installed SkilledAgent!');
+    console.log('\nTo get started, open your AI agent and run:');
+    console.log('  /kickoff\n');
+} catch (err) {
+    console.error('Failed to copy files:', err);
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "skilledagent",
+  "version": "1.0.0",
+  "description": "Scaffold SkilledAgent developer workspace directly into your project",
+  "main": "bin/cli.js",
+  "bin": {
+    "skilledagent": "bin/cli.js"
+  },
+  "files": [
+    "bin/cli.js",
+    ".agents"
+  ],
+  "engines": {
+    "node": ">=16.7.0"
+  },
+  "keywords": [
+    "skills",
+    "ai",
+    "agent",
+    "workspace",
+    "orchestration",
+    "tdd",
+    "claude-code",
+    "gemini"
+  ],
+  "author": "Aryan Motiani",
+  "license": "MIT"
+}