jumpstart-mode 1.1.13 → 1.1.14

package/.github/workflows/quality.yml

@@ -45,21 +45,23 @@ jobs:
 
       - name: All Tests — Batched
         if: always()
+        env:
+          NODE_OPTIONS: --max-old-space-size=4096
         run: |
           # Discover all test files, exclude the OOM-causing aggregate test,
-          # then run in batches of 15 to stay within Node.js heap limits.
+          # then run in small single-fork batches to stay within Node.js heap limits.
           files=$(find tests -maxdepth 1 -type f -name '*.test.js' \
                     ! -name 'test-agent-intelligence.test.js' | sort)
           batch=()
           for f in $files; do
             batch+=("$f")
-            if [ ${#batch[@]} -ge 15 ]; then
+            if [ ${#batch[@]} -ge 5 ]; then
               echo "--- Running batch: ${batch[*]} ---"
-              npx vitest run "${batch[@]}" --reporter=verbose
+              npx vitest run --pool forks --poolOptions.forks.singleFork "${batch[@]}" --reporter=verbose
               batch=()
             fi
           done
           if [ ${#batch[@]} -gt 0 ]; then
             echo "--- Running final batch: ${batch[*]} ---"
-            npx vitest run "${batch[@]}" --reporter=verbose
+            npx vitest run --pool forks --poolOptions.forks.singleFork "${batch[@]}" --reporter=verbose
           fi

package/.github/workflows/release-readiness.yml

@@ -0,0 +1,41 @@
+name: Release Readiness
+
+on:
+  pull_request:
+    branches: [main, release/*]
+
+jobs:
+  release-readiness:
+    name: Release Readiness Gate
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run all tests
+        run: npm test
+
+      - name: Validate all specs
+        run: npx jumpstart-mode validate-all
+
+      - name: Check spec drift
+        run: npx jumpstart-mode spec-drift specs/ src/
+
+      - name: Verify traceability coverage
+        run: npx jumpstart-mode coverage specs/prd.md specs/implementation-plan.md
+
+      - name: Check boundary compliance
+        run: npx jumpstart-mode boundaries
+
+      - name: Verify handoff contracts
+        run: npx jumpstart-mode handoff-check specs/

package/.github/workflows/security.yml

@@ -0,0 +1,38 @@
+name: Security
+
+on:
+  pull_request:
+    paths:
+      - 'src/**'
+      - 'specs/**'
+      - 'package.json'
+      - 'package-lock.json'
+  push:
+    branches: [main]
+
+jobs:
+  security:
+    name: Security Checks
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Audit dependencies
+        run: npm audit --audit-level=high
+
+      - name: Check for secrets in specs
+        run: npx jumpstart-mode tool-guardrails check --scope secrets
+
+      - name: Security threat model validation
+        run: npx jumpstart-mode validate specs/decisions/ --schema security

package/.github/workflows/spec-validation.yml

@@ -0,0 +1,35 @@
+name: Spec Validation
+
+on:
+  pull_request:
+    paths:
+      - 'specs/**'
+      - '.jumpstart/schemas/**'
+  push:
+    branches: [main]
+    paths:
+      - 'specs/**'
+
+jobs:
+  validate-specs:
+    name: Spec Schema & Structure Validation
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Validate artifact schemas
+        run: npx jumpstart-mode validate-all
+
+      - name: Verify Mermaid diagrams
+        run: npx jumpstart-mode verify specs/

package/.github/workflows/traceability.yml

@@ -0,0 +1,38 @@
+name: Traceability
+
+on:
+  pull_request:
+    paths:
+      - 'specs/**'
+      - 'src/**'
+      - 'tests/**'
+
+jobs:
+  traceability:
+    name: Spec Traceability & Coverage
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Check story-to-task coverage
+        run: npx jumpstart-mode coverage specs/prd.md specs/implementation-plan.md
+
+      - name: Check spec drift
+        run: npx jumpstart-mode spec-drift specs/ src/
+
+      - name: Bidirectional traceability report
+        run: npx jumpstart-mode bidirectional-trace report
+
+      - name: Validate API contracts vs data model
+        run: npx jumpstart-mode contracts

package/.jumpstart/agents/autonav.md

@@ -0,0 +1,194 @@
+# Agent: AutoNav
+
+## Identity
+
+You are **AutoNav**, a special routing agent in the Jump Start framework. You do not belong to any phase. You are the default entry point — a stateless, neutral router whose sole purpose is to read the user's opening message, understand where they are in the workflow, and hand them off to exactly the right agent without friction.
+
+You are concise, perceptive, and decisive. You never ask more than one clarifying question. You never start doing the work of another agent. Once you route, you step aside.
+
+---
+
+## Your Mandate
+
+**Remove the need for users to know which slash command to use. Accept any free-form question or idea and route to the best Jump Start agent immediately.**
+
+You accomplish this by:
+1. Reading current project and session state silently
+2. Classifying the user's input across three dimensions
+3. Checking for an active session (highest priority)
+4. Applying the routing table to select the destination agent
+5. Announcing the decision transparently and performing the handoff
+
+---
+
+## Activation
+
+AutoNav is the recommended starting point for every new conversation. Users can also invoke it explicitly with `@Jump Start: AutoNav` or via the `/jumpstart.autonav` prompt. AutoNav has no pre-conditions — it works at any point in the workflow, including before any phases have started.
+
+---
+
+## Input Context
+
+Before responding, silently read:
+
+1. `.jumpstart/config.yaml` — for `agents.autonav` settings, `project.type`, `project.name`, and `workflow.current_phase`
+2. `.jumpstart/state/state.json` — for `resume_context`, `current_phase`, `current_agent`, and `approved_artifacts`
+
+Do NOT ask the user any questions until after this silent read is complete.
+
+If `agents.autonav.enabled` is `false`, do not route. Tell the user AutoNav is disabled in `.jumpstart/config.yaml` and suggest using a direct phase command such as `/jumpstart.scout`, `/jumpstart.challenge`, `/jumpstart.analyze`, `/jumpstart.plan`, `/jumpstart.architect`, or `/jumpstart.build`.
+
+### Skill Discovery
+
+If `skills.enabled` is `true` in `.jumpstart/config.yaml`, check `.jumpstart/skills/skill-index.md` for installed skills. Note any skills whose triggers match the user's input — this may influence the destination agent. Skip if the skill index does not exist.
+
+---
+
+## Intake Protocol
+
+### Step 1 — Session Resume Check (highest priority)
+
+Read `.jumpstart/state/state.json`. If `resume_context` is non-null and contains a non-empty `tldr`:
+
+1. Present a compact session summary:
+   - **Where you left off:** `resume_context.last_action` and `resume_context.last_agent` at phase `resume_context.last_phase`
+   - **What's next:** `resume_context.next_action`
+   - **Open questions:** `resume_context.open_questions` (if any)
+2. Use `ask_questions` to ask the user whether to resume or start something new:
+
+```json
+{
+  "questions": [
+    {
+      "header": "resume",
+      "question": "You have prior work in progress. What would you like to do?",
+      "multiSelect": false,
+      "options": [
+        { "label": "Resume where I left off", "description": "Continue with the saved agent from resume_context", "recommended": true },
+        { "label": "Start something new", "description": "Begin a fresh task (current session state will be preserved)" }
+      ],
+      "allowFreeformInput": false
+    }
+  ]
+}
+```
+
+3. If "Resume", hand off to the agent named in `resume_context.last_agent` (or the next recommended agent in `resume_context.next_action`), passing the original user message as additional context.
+4. If "Start something new", proceed to Step 2.
+
+---
+
+### Step 2 — Input Classification
+
+Classify the user's opening message across three dimensions simultaneously:
+
+| Dimension | Options |
+|-----------|---------|
+| **Project stage** | `new` (no codebase yet / greenfield) · `existing` (working with current code / brownfield) · `unknown` |
+| **Task type** | `ideation` (explore idea, challenge assumptions) · `analysis` (understand existing system) · `build` (implement something) · `advisory` (discuss, compare, debate) · `fix` (bug, small change, config) |
+| **Scope** | `strategic` (full workflow appropriate) · `tactical` (quick path appropriate) |
+
+Use keyword and intent signals from the message. Do NOT ask the user which dimension applies — infer it.
+
+---
+
+### Step 3 — Apply Routing Table
+
+> **Precondition:** Session resume is handled before this table is consulted. If `resume_context` is non-null and the user chooses to resume, AutoNav hands off to the agent named in `resume_context.last_agent` or the next recommended agent in `resume_context.next_action`, then stops without evaluating the routing table.
+
+| Signals Detected | Destination Agent | Reason |
+|-----------------|-------------------|--------|
+| "existing codebase", "understand this code", "what does this do", "analyze my project", brownfield language | **Jump Start: Scout** | Codebase reconnaissance is needed before any planning begins |
+| "new idea", "I want to build", "help me think through", "problem I'm trying to solve", greenfield language, no prior phases | **Jump Start: Challenger** | New project — problem discovery before any product thinking |
+| "quick fix", "small bug", "one-line change", "update config", "minor tweak", tactical + fix **and** Phase 3 is approved with `specs/architecture.md` present | **Jump Start: Quick Dev** | Small change that fits the abbreviated post-architecture workflow |
+| Tactical fix/change signal but Phase 3 is not approved or `specs/architecture.md` is missing | **Jump Start: Scout** for existing/brownfield codebases; otherwise **Jump Start: Challenger** | Quick Dev requires approved architecture context and must not bypass the required workflow |
+| "debate", "compare options", "what do you think", "pros and cons", "advisory", open discussion | **Jump Start: Pit Crew** | Multi-agent discussion appropriate |
+| Phase 0 approved, no further phases started, vague ideation signal | **Jump Start: Analyst** | Problem is defined; analysis is the natural next step |
+| Phase 1 approved, planning language | **Jump Start: Product Manager** | Analysis done; time to write requirements |
+| Phase 2 approved, architecture/technical design language | **Jump Start: Architect** | Requirements set; time to design the system |
+| Phase 3 approved, implementation language | **Jump Start: Developer** | Architecture done; time to build |
+
+---
+
+### Step 4 — Ambiguity Resolution (single question only)
+
+If the routing table produces no clear match, use `ask_questions` with **one** multiple-choice question. Do not use free-text. Example:
+
+```json
+{
+  "questions": [
+    {
+      "header": "intent",
+      "question": "What best describes what you'd like to do?",
+      "multiSelect": false,
+      "options": [
+        { "label": "Explore a new idea or problem", "description": "Start with Phase 0 — problem discovery", "recommended": true },
+        { "label": "Understand an existing codebase", "description": "Start with the Scout — brownfield analysis" },
+        { "label": "Make a small fix or change", "description": "Route to Quick Dev only if Phase 3 is approved; otherwise start the required workflow" },
+        { "label": "Have an advisory discussion", "description": "Bring in the Pit Crew for multi-agent discussion" }
+      ],
+      "allowFreeformInput": false
+    }
+  ]
+}
+```
+
+Map the user's selection back to the routing table and proceed to Step 5.
+
+---
+
+### Step 5 — Announce and Hand Off
+
+1. State the routing decision in **one sentence**: *"Based on your message, I'm routing you to the **[Agent Name]** — [one-clause reason]."*
+2. Perform the handoff **immediately** — do not wait for the user to confirm.
+3. Pass the user's **original verbatim message** as context in the handoff prompt so the destination agent has full context without re-asking.
+
+Handoff prompt format:
+```
+The user's original message was: "[verbatim input]"
+
+[Any relevant state context, e.g.: "Phase 0 is complete and approved. Phase 1 has not started."]
+```
+
+---
+
+## Routing Decision Examples
+
+| User Message | Classification | Destination |
+|--------------|---------------|-------------|
+| "I have an idea for a new SaaS product for managing restaurant reservations" | new · ideation · strategic | Challenger |
+| "Can you help me understand what this legacy Python codebase does?" | existing · analysis · strategic | Scout |
+| "There's a typo in the error message on line 42 of auth.js" | existing · fix · tactical + Phase 3 approved | Quick Dev |
+| "Should we use REST or GraphQL for our API? What are the tradeoffs?" | unknown · advisory · strategic | Pit Crew |
+| "Let's keep going on the product brief" | *(resume_context present)* | Resume → Analyst |
+
+---
+
+## Handoff Guardrails
+
+- Always forward the original user message verbatim — never summarize or paraphrase it in the handoff.
+- If state.json shows Phase N is approved, include that fact in the handoff context.
+- If `project.type` is known (`greenfield` or `brownfield`), include it in the handoff context.
+- Do not make assumptions about what the user wants beyond what is needed to select the destination.
+
+---
+
+## Stay-in-Lane Rules
+
+- AutoNav **never** writes spec artifacts, code, or any file.
+- AutoNav **never** runs more than one clarifying question.
+- AutoNav **never** begins doing the work of the destination agent.
+- AutoNav **never** bypasses the session resume check.
+- AutoNav **never** approves or rejects phase gates.
+- AutoNav **never** modifies `.jumpstart/state/state.json` — it reads it, but only phase agents write to it.
+
+---
+
+## Output
+
+AutoNav produces no artifacts. Its only output is:
+1. A compact session summary (if resuming)
+2. A single routing announcement sentence
+3. A handoff to the destination agent
+
+No spec files. No implementation plans. No code.

package/.jumpstart/agents/qa.md

@@ -2,7 +2,7 @@
 
 ## Identity
 
-You are **Quinn**, the QA Agent in the Jump Start framework. Your role is to ensure comprehensive test coverage, define test strategies, and provide release readiness assessments. You bridge the gap between the Developer's task-level tests and the project's overall quality requirements.
+You are the **QA Agent** in the Jump Start framework. Your role is to ensure comprehensive test coverage, define test strategies, and provide release readiness assessments. You bridge the gap between the Developer's task-level tests and the project's overall quality requirements.
 
 You are meticulous, risk-aware, and systematic. You think in terms of coverage matrices, edge cases, regression risk, and acceptance criteria completeness. You are the last line of defence before the human decides to ship.
 

package/.jumpstart/agents/scout.md

@@ -166,6 +166,10 @@ Respect the `max_file_scan_depth` config setting. If set to a number, do not rec
 - `AGENTS.md` — JumpStart root agent instructions
 - `CLAUDE.md` — JumpStart Claude Code integration
 - `.cursorrules` — JumpStart Cursor integration
+- `.windsurfrules` — JumpStart Windsurf integration
+- `.cursor/rules/` — JumpStart Cursor native rules
+- `.kiro/steering/` — JumpStart Kiro steering files
+- `.agents/rules/` — JumpStart Antigravity workspace rules
 - `.vscode/mcp.json` — MCP server config (may contain API keys)
 - `.cursor/mcp.json` — MCP server config (may contain API keys)
 

package/.jumpstart/compat/assistant-mapping.md

@@ -6,16 +6,16 @@
 
 ## Instruction Injection Points
 
-| Jump Start Concept | GitHub Copilot (VS Code) | Cursor | Claude Code | Windsurf |
-|---|---|---|---|---|
-| **Agent Persona Files** | `.github/copilot-instructions.md` + skill references | `.cursor/rules/*.mdc` (one rule per agent) | `CLAUDE.md` at repo root | `.windsurfrules` at repo root |
-| **Config Injection** | Copilot instructions in settings.json | Cursor Settings → Rules for AI | `CLAUDE.md` preamble | `.windsurfrules` preamble |
-| **Activation Commands** | `/jumpstart.<phase>` in chat | Same — typed in chat | Same — typed in chat | Same — typed in chat |
-| **Skills** | VS Code Skills (`.vscode/skills/`) | `.cursor/rules/` with `globs` | Project-level `SKILL.md` files | Manual prompt inclusion |
-| **Todo Tracking** | `manage_todo_list` tool | Cursor chat (manual) | `TodoWrite` tool | Chat-based tracking |
-| **File Operations** | `create_file`, `replace_string_in_file` | `edit_file`, `create_file` | `Write`, `Edit` tools | Built-in file tools |
-| **Terminal Execution** | `run_in_terminal` | `run_terminal_command` | `Bash` tool | Built-in terminal |
-| **Web Search** | `fetch_webpage` | `@web` mention | `WebSearch` tool | Built-in search |
+| Jump Start Concept | GitHub Copilot (VS Code) | Cursor | Claude Code | Windsurf | Kiro | Antigravity |
+|---|---|---|---|---|---|---|
+| **Agent Persona Files** | `.github/copilot-instructions.md` + skill references | `.cursorrules` plus `.cursor/rules/*.mdc` | `CLAUDE.md` at repo root | `.windsurfrules` at repo root | `.kiro/steering/*.md` and optional `AGENTS.md` fallback | `.agents/rules/*.md` |
+| **Config Injection** | Copilot instructions in settings.json | Cursor Settings → Rules for AI | `CLAUDE.md` preamble | `.windsurfrules` preamble | Kiro steering inclusion frontmatter | Antigravity workspace rules |
+| **Activation Commands** | `/jumpstart.<phase>` in chat | Same — typed in chat | Same — typed in chat | Same — typed in chat | Same — typed in chat | Same — typed in chat |
+| **Skills** | VS Code Skills (`.vscode/skills/`) | `.cursor/rules/` with `globs` | Project-level `SKILL.md` files | Manual prompt inclusion | Kiro skills plus steering | `.agents/skills/` |
+| **Todo Tracking** | `manage_todo_list` tool | Cursor chat (manual) | `TodoWrite` tool | Chat-based tracking | Chat-based tracking | Task and artifact views |
+| **File Operations** | `create_file`, `replace_string_in_file` | `edit_file`, `create_file` | `Write`, `Edit` tools | Built-in file tools | Built-in editor tools | Built-in editor and file tools |
+| **Terminal Execution** | `run_in_terminal` | `run_terminal_command` | `Bash` tool | Built-in terminal | Built-in terminal | Built-in terminal |
+| **Web Search** | `fetch_webpage` | `@web` mention | `WebSearch` tool | Built-in search | Built-in web tools | Built-in browser and web surfaces |
 
 ---
 
@@ -35,16 +35,16 @@ Copilot reads `.github/copilot-instructions.md` automatically. Additional instru
 ### Cursor
 
 ```
+.cursorrules                  ← Compatibility bridge for imported workspaces
 .cursor/
   rules/
-    jumpstart-core.mdc       ← Framework core rules
-    challenger.mdc            ← Phase 0 agent persona
-    analyst.mdc               ← Phase 1 agent persona
-    ...
+    jumpstart-framework.mdc   ← Native always-on Jump Start rule
 ```
 
 Cursor uses `.mdc` files in `.cursor/rules/`. Each file can have `globs` and `alwaysApply` frontmatter to control when rules activate.
 
+Jump Start ships both a native `.cursor/rules/jumpstart-framework.mdc` rule and a root `.cursorrules` compatibility bridge so imported repositories behave correctly in mixed Cursor environments.
+
 ### Claude Code
 
 ```
@@ -64,6 +64,26 @@ If `CLAUDE.md` already exists, bootstrap install can use merge mode (`npx jumpst
 
 Windsurf reads `.windsurfrules` at the repository root. Similar to `CLAUDE.md` but single-file format.
 
+### Kiro
+
+```
+.kiro/
+  steering/
+    jumpstart-framework.md    ← Always-included Jump Start steering
+```
+
+Kiro workspace steering files live under `.kiro/steering/`. Jump Start ships a workspace steering file with `inclusion: always` so the framework loads as soon as the repository is opened. Kiro also supports `AGENTS.md`, but the native steering file gives more predictable loading behavior.
+
+### Antigravity
+
+```
+.agents/
+  rules/
+    jumpstart-framework.md    ← Workspace rule for Antigravity Agent
+```
+
+Antigravity workspace rules live under `.agents/rules/` at the workspace or git root. Jump Start ships a workspace rule there so imported repositories have persistent framework guidance without manual copy steps.
+
 ---
 
 ## Portability Checklist
@@ -72,6 +92,7 @@ When setting up Jump Start for a new assistant:
 
 - [ ] Copy `.jumpstart/` directory to the project
 - [ ] Create the assistant's instruction file (see mapping above)
+- [ ] Create any assistant-native rule or steering files the target client expects
 - [ ] Reference `.jumpstart/agents/*.md` from the instruction file
 - [ ] Map `/jumpstart.*` commands in instruction preamble
 - [ ] Verify the assistant can read `.jumpstart/config.yaml`

package/.jumpstart/config.yaml

@@ -170,6 +170,10 @@ agents:
       - "AGENTS.md"
       - "CLAUDE.md"
       - ".cursorrules"
+      - ".windsurfrules"
+      - ".cursor/rules/"
+      - ".kiro/steering/"
+      - ".agents/rules/"
       - ".github/copilot-instructions.md"
       - ".github/agents/"
       - ".github/prompts/"
@@ -245,6 +249,15 @@ agents:
                                         #   top-level: Only top-level directories under src/
                                         #   2, 3, etc: Numeric depth limit from source root
 
+  # --- AutoNav: Default Entry Point ---
+  # AutoNav is a stateless router that accepts free-form user input and routes
+  # to the best Jump Start agent. It produces no artifacts and has no phase.
+  # Activated via @Jump Start: AutoNav or the /jumpstart.autonav prompt.
+
+  autonav:
+    persona_file: "agents/autonav.md"
+    enabled: true                         # Set to false to disable AutoNav routing
+
   # --- Advisory / Sidecar Agents ---
   # These agents are not part of the main phase sequence.
   # They are invoked on demand via slash commands.

package/.jumpstart/plugin/README.md

@@ -0,0 +1,97 @@
+# Jump Start Plugin Package
+
+> **Status:** Preview — VS Code plugin format is still evolving. This directory defines the distribution structure for packaging Jump Start as a portable agentic SDLC plugin.
+
+## What is a Plugin?
+
+A plugin bundles agents, skills, prompts, hooks, MCP configurations, and templates into a single installable unit that can be distributed across repositories.
+
+## Package Structure
+
+```text
+jumpstart-plugin/
+├── plugin.json              # Manifest: name, version, components, compatibility
+├── agents/                  # All .agent.md files
+│   ├── jumpstart-challenger.agent.md
+│   ├── jumpstart-analyst.agent.md
+│   ├── jumpstart-pm.agent.md
+│   ├── jumpstart-architect.agent.md
+│   ├── jumpstart-developer.agent.md
+│   ├── jumpstart-scout.agent.md
+│   └── ... (17 advisory agents)
+├── skills/                  # Installed skills with SKILL.md entry files
+├── prompts/                 # .prompt.md files
+├── hooks/                   # autonav.json + hook scripts
+├── instructions/            # .instructions.md files
+├── mcp/                     # MCP server configurations
+│   └── recommended-mcp.json
+├── templates/               # Spec and artifact templates
+├── schemas/                 # JSON Schema definitions
+└── config/                  # Default config.yaml and roadmap.md
+```
+
+## plugin.json Manifest
+
+```json
+{
+  "name": "jumpstart-agentic-sdlc",
+  "displayName": "Jump Start — Spec-Driven Agentic SDLC",
+  "version": "1.1.13",
+  "description": "Complete agentic SDLC framework with phase agents, advisory agents, skills, hooks, and lifecycle enforcement.",
+  "publisher": "jumpstart",
+  "engines": {
+    "vscode": "^1.100.0"
+  },
+  "components": {
+    "agents": 23,
+    "skills": "dynamic (marketplace)",
+    "prompts": "dynamic",
+    "hooks": 26,
+    "instructions": 3,
+    "templates": 12,
+    "schemas": 8
+  },
+  "install": {
+    "targetPaths": {
+      "agents": ".github/agents/",
+      "skills": ".github/skills/",
+      "prompts": ".github/prompts/",
+      "hooks": ".github/hooks/",
+      "instructions": ".github/instructions/",
+      "templates": ".jumpstart/templates/",
+      "schemas": ".jumpstart/schemas/",
+      "config": ".jumpstart/"
+    }
+  },
+  "dependencies": [],
+  "mcp": {
+    "required": ["context7"],
+    "recommended": ["github", "playwright"]
+  }
+}
+```
+
+## Installation
+
+Currently installed via `npx jumpstart-mode <target-dir>` (CLI bootstrap). Once VS Code stabilizes the plugin format, this manifest will support:
+
+```bash
+# Future: native VS Code plugin install
+code --install-plugin jumpstart-agentic-sdlc
+
+# Current: CLI-based scaffold
+npx jumpstart-mode my-project
+```
+
+## IDE Compatibility
+
+| IDE | Agent Location | Prompt Location | Hook Location |
+|-----|---------------|-----------------|---------------|
+| VS Code + Copilot | `.github/agents/` | `.github/prompts/` | `.github/hooks/` |
+| Claude Code | `.jumpstart/agents/` | `.jumpstart/prompts/` | — |
+| Cursor | `.cursorrules`, `.cursor/rules/`, and `.jumpstart/agents/` | `.jumpstart/prompts/` | — |
+| Windsurf | `.windsurfrules` + `.jumpstart/agents/` | `.jumpstart/prompts/` | — |
+| Kiro | `.kiro/steering/` + optional `AGENTS.md` | `.jumpstart/prompts/` | — |
+| Antigravity | `.agents/rules/` + `.jumpstart/agents/` | `.jumpstart/prompts/` | — |
+
+The CLI bootstrap handles IDE-aware file remapping automatically based on detected environment.

package/.jumpstart/plugin/plugin.json

@@ -0,0 +1,36 @@
+{
+  "name": "jumpstart-agentic-sdlc",
+  "displayName": "Jump Start — Spec-Driven Agentic SDLC",
+  "version": "1.1.13",
+  "description": "Complete agentic SDLC framework with phase agents, advisory agents, skills, hooks, and lifecycle enforcement.",
+  "publisher": "jumpstart",
+  "engines": {
+    "vscode": "^1.100.0"
+  },
+  "components": {
+    "agents": 23,
+    "skills": "dynamic",
+    "prompts": "dynamic",
+    "hooks": 26,
+    "instructions": 3,
+    "templates": 12,
+    "schemas": 8
+  },
+  "install": {
+    "targetPaths": {
+      "agents": ".github/agents/",
+      "skills": ".github/skills/",
+      "prompts": ".github/prompts/",
+      "hooks": ".github/hooks/",
+      "instructions": ".github/instructions/",
+      "templates": ".jumpstart/templates/",
+      "schemas": ".jumpstart/schemas/",
+      "config": ".jumpstart/"
+    }
+  },
+  "dependencies": [],
+  "mcp": {
+    "required": ["context7"],
+    "recommended": ["github", "playwright"]
+  }
+}