aigroup-workflow 1.0.0

package/skills/jarvis/claude-simone/README.md

@@ -0,0 +1,41 @@
+# Simone for Claude Code
+
+<img src="https://github.com/Helmi/claude-simone/raw/master/documentation/static/img/simone-logo-dark.png" width="300" />
+
+## Task & Project Manager for Claude Code
+
+Simone is a comprehensive project and task management system designed specifically for AI-assisted development workflows. It provides structured prompts and tools to help AI assistants understand and work with your projects effectively.
+
+[![Mentioned in Awesome Claude Code](https://awesome.re/mentioned-badge.svg)](https://github.com/hesreallyhim/awesome-claude-code)
+
+## Choose Your Version
+
+This repository contains two implementations of Simone:
+
+### 🏗️ Legacy System (Original)
+
+The initial implementation of Simone. A directory-based task management system that provides a more complete feature set and has been used in real projects.
+
+**[→ Get started with Legacy Simone](/legacy/README.md)**
+
+### 🚀 MCP Server (Early Access)
+
+A new implementation using the Model Context Protocol (MCP). This version offers structured prompts, activity tracking, and more in the future.
+
+⚠️ **Early Access**: The MCP version is in active development and best suited for early adopters.
+
+**[→ Get started with MCP Simone](/mcp-server/README.md)**
+
+## Repository Structure
+
+- [`/legacy`](/legacy) - The original directory-based Simone system
+- [`/mcp-server`](/mcp-server) - The new MCP implementation (early access)
+- [`/hello-simone`](/hello-simone) - Universal installer for both versions
+
+## Contributing
+
+As we're in a transition period, please open an issue before contributing to discuss whether changes should target the legacy system or the new MCP implementation.
+
+## License
+
+MIT License - see LICENSE file for details.

package/skills/jarvis/claude-simone/docs/docs/Principles/context-engineering.md

@@ -0,0 +1,41 @@
+---
+sidebar_position: 2
+---
+
+# Context Engineering
+
+Large language models have a fundamental limitation: a finite context window. Meanwhile, modern software projects are vast, complex, and spread across thousands of files. You can't simply paste an entire codebase into a prompt and expect a good result. So, how do you provide an AI with the right information to perform a meaningful engineering task?
+
+This is the core problem that Context Engineering solves. Instead of flooding the AI with irrelevant data or providing too little information for it to be effective, Context Engineering is the discipline of designing, managing, and delivering the precise, relevant context an AI needs to perform a specific task. It is the foundational practice upon which the Simone framework is built.
+
+## Core Principles of Context Engineering
+
+Simone is built on several key principles of context engineering:
+
+### 1. Structured Knowledge
+
+Instead of treating project information as a single, monolithic block, it is organized into logical, queryable components. This includes high-level vision, architectural documentation, specific requirements, and the breakdown of work into tasks. This separation allows for the precise retrieval of information relevant to any given task.
+
+### 2. Layered Context
+
+The AI is provided with layers of context, moving from the general to the specific. When executing a task, it can be given access to the overarching project goals, relevant architectural patterns, and the fine-grained details of the specific work item, ensuring it has a multi-faceted understanding of its objective.
+
+### 3. Just-in-Time Context
+
+Information is provided precisely when needed. By tying context retrieval to specific commands or prompts, we ensure the information provided is always relevant to the job at hand. This minimizes noise and maximizes the signal of the information presented to the model.
+
+### 4. AI-Friendly Format
+
+All project artifacts are stored in simple, machine-readable formats (primarily Markdown and YAML). This design choice makes it effortless for the AI to parse, understand, and reason about the project's state.
+
+## Context Engineering in Practice
+
+Simone provides concrete mechanisms to implement these principles, ensuring that the AI always operates with the most relevant and up-to-date information.
+
+*   **Structured Knowledge Base:** At its core, Simone maintains a structured repository of all project-related information. This includes everything from high-level architectural guides to specific task requirements, ensuring all context is organized and accessible.
+
+*   **Intelligent Context Loading:** Commands in both the legacy system (e.g., `/simone:do_task`) and the MCP server (e.g., `/do_task`) act as powerful, context-aware triggers. When executed, they intelligently gather and load the precise information required for the specific task at hand.
+
+*   **On-Demand Context for Fresh Sessions:** This approach enables a powerful workflow where a developer can start a fresh session with a minimal context. By executing a single command, such as one to begin work on an open issue, Simone instantly assembles and provides all the necessary background, specifications, and file context. This allows the AI to focus directly on the task, avoiding the noise of irrelevant information and preventing it from becoming overwhelmed.
+
+By mastering context engineering, Simone transforms the AI from a simple code generator into a true engineering partner that understands the *why* behind the *what*.

package/skills/jarvis/claude-simone/docs/docs/Principles/specs-driven-development.md

@@ -0,0 +1,43 @@
+---
+sidebar_position: 3
+---
+
+# Specs-Driven Development
+
+Imagine building a house without a blueprint. The foundation might be wrong, the walls might not align, and the final result would be chaotic and unpredictable. In software, writing code without a clear plan can lead to the same problems.
+
+**Specs-Driven Development (SDD)** is the practice of creating that blueprint before any code is written. It is a methodology where a formal, detailed **specification** (or "spec") is the central driver for the entire development lifecycle. This spec acts as the single source of truth for both the human developer and, crucially, the AI partner.
+
+:::note What Problem Does SDD Solve for AI?
+Large Language Models are incredibly powerful, but they lack human intuition and deep business context. If you give an AI a vague request, you'll get a vague or incorrect result.
+
+Specs-Driven Development bridges this gap. By providing the AI with a clear, structured, and unambiguous spec, you transform it from an unpredictable generator into a reliable engineering partner. The developer's role evolves from a **coder** to an **architect**—designing the blueprint that the AI can then execute with precision.
+:::
+
+## The Core Workflow in Simone
+
+In the Simone ecosystem, Specs-Driven Development follows a clear, three-step process that emphasizes planning and precision.
+
+### 1. Define the Spec
+The developer's first and most important job is to analyze a problem and create a detailed task specification. This isn't a quick note; it's a formal piece of documentation that leaves no room for ambiguity.
+
+A good spec should include:
+- **A Clear Goal:** What is the user story or objective?
+- **Acceptance Criteria:** How do we know when the task is done and correct?
+- **Constraints & Edge Cases:** What are the boundaries and potential pitfalls?
+- **Implementation Notes:** Are there specific patterns, libraries, or functions that must be used?
+
+### 2. AI Implementation
+With a clear spec in hand, the developer delegates the implementation to the AI using a simple command, like `/do_task`. Simone loads the spec as the primary context, allowing the AI to focus entirely on translating the well-defined requirements into code.
+
+### 3. Review and Refine
+The developer reviews the AI-generated code against the spec. If the output is incorrect or incomplete, the first instinct shouldn't be to fix the code directly. Instead, the developer should ask: **"Is the spec clear enough?"**
+
+By refining the spec and having the AI regenerate the code, the spec remains the true source of truth, ensuring that the documentation and implementation never drift apart.
+
+:::tip The Benefits of a Spec-First Approach
+- **Predictable AI:** Dramatically improves the reliability and consistency of the AI's output.
+- **Enhanced Developer Focus:** Frees developers from tedious coding to focus on higher-level architecture and problem-solving.
+- **Living Documentation:** Your spec library becomes a rich, detailed, and always up-to-date history of your project's functionality.
+- **Superior Testability:** Clear acceptance criteria in a spec are the perfect foundation for writing robust unit and integration tests.
+:::

package/skills/jarvis/claude-simone/docs/src/css/custom.css

@@ -0,0 +1,43 @@
+/**
+ * Any CSS included here will be global.
+ *
+ * Such CSS is imported from `src/pages/_app.js`.
+ */
+
+/* You can override the default Infima variables here. */
+:root {
+  --ifm-color-primary: #855ebb;
+  --ifm-color-primary-dark: #7653a8;
+  --ifm-color-primary-darker: #6c4c99;
+  --ifm-color-primary-darkest: #593f7d;
+  --ifm-color-primary-light: #9469d0;
+  --ifm-color-primary-lighter: #9e76d8;
+  --ifm-color-primary-lightest: #b292e4;
+}
+
+/* For readability concerns, you should choose a lighter palette in dark mode. */
+[data-theme='dark'] {
+  --ifm-color-primary: #9e76d8;
+  --ifm-color-primary-dark: #8f67c7;
+  --ifm-color-primary-darker: #855ebb;
+  --ifm-color-primary-darkest: #6c4c99;
+  --ifm-color-primary-light: #ad85e9;
+  --ifm-color-primary-lighter: #b292e4;
+  --ifm-color-primary-lightest: #c6aef0;
+}
+
+.header-github-link:hover {
+  opacity: 0.6;
+}
+
+.header-github-link:before {
+  content: '';
+  width: 24px;
+  height: 24px;
+  display: flex;
+  background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12'/%3E%3C/svg%3E");
+}
+
+[data-theme='dark'] .header-github-link:before {
+    background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath fill='white' d='M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12'/%3E%3C/svg%3E");
+}

package/skills/jarvis/claude-simone/documentation/Principles/context-engineering.md

@@ -0,0 +1,41 @@
+---
+sidebar_position: 2
+---
+
+# Context Engineering
+
+Large language models have a fundamental limitation: a finite context window. Meanwhile, modern software projects are vast, complex, and spread across thousands of files. You can't simply paste an entire codebase into a prompt and expect a good result. So, how do you provide an AI with the right information to perform a meaningful engineering task?
+
+This is the core problem that Context Engineering solves. Instead of flooding the AI with irrelevant data or providing too little information for it to be effective, Context Engineering is the discipline of designing, managing, and delivering the precise, relevant context an AI needs to perform a specific task. It is the foundational practice upon which the Simone framework is built.
+
+## Core Principles of Context Engineering
+
+Simone is built on several key principles of context engineering:
+
+### 1. Structured Knowledge
+
+Instead of treating project information as a single, monolithic block, it is organized into logical, queryable components. This includes high-level vision, architectural documentation, specific requirements, and the breakdown of work into tasks. This separation allows for the precise retrieval of information relevant to any given task.
+
+### 2. Layered Context
+
+The AI is provided with layers of context, moving from the general to the specific. When executing a task, it can be given access to the overarching project goals, relevant architectural patterns, and the fine-grained details of the specific work item, ensuring it has a multi-faceted understanding of its objective.
+
+### 3. Just-in-Time Context
+
+Information is provided precisely when needed. By tying context retrieval to specific commands or prompts, we ensure the information provided is always relevant to the job at hand. This minimizes noise and maximizes the signal of the information presented to the model.
+
+### 4. AI-Friendly Format
+
+All project artifacts are stored in simple, machine-readable formats (primarily Markdown and YAML). This design choice makes it effortless for the AI to parse, understand, and reason about the project's state.
+
+## Context Engineering in Practice
+
+Simone provides concrete mechanisms to implement these principles, ensuring that the AI always operates with the most relevant and up-to-date information.
+
+*   **Structured Knowledge Base:** At its core, Simone maintains a structured repository of all project-related information. This includes everything from high-level architectural guides to specific task requirements, ensuring all context is organized and accessible.
+
+*   **Intelligent Context Loading:** Commands in both the legacy system (e.g., `/simone:do_task`) and the MCP server (e.g., `/do_task`) act as powerful, context-aware triggers. When executed, they intelligently gather and load the precise information required for the specific task at hand.
+
+*   **On-Demand Context for Fresh Sessions:** This approach enables a powerful workflow where a developer can start a fresh session with a minimal context. By executing a single command, such as one to begin work on an open issue, Simone instantly assembles and provides all the necessary background, specifications, and file context. This allows the AI to focus directly on the task, avoiding the noise of irrelevant information and preventing it from becoming overwhelmed.
+
+By mastering context engineering, Simone transforms the AI from a simple code generator into a true engineering partner that understands the *why* behind the *what*.

package/skills/jarvis/claude-simone/documentation/Principles/specs-driven-development.md

@@ -0,0 +1,43 @@
+---
+sidebar_position: 3
+---
+
+# Specs-Driven Development
+
+Imagine building a house without a blueprint. The foundation might be wrong, the walls might not align, and the final result would be chaotic and unpredictable. In software, writing code without a clear plan can lead to the same problems.
+
+**Specs-Driven Development (SDD)** is the practice of creating that blueprint before any code is written. It is a methodology where a formal, detailed **specification** (or "spec") is the central driver for the entire development lifecycle. This spec acts as the single source of truth for both the human developer and, crucially, the AI partner.
+
+:::note What Problem Does SDD Solve for AI?
+Large Language Models are incredibly powerful, but they lack human intuition and deep business context. If you give an AI a vague request, you'll get a vague or incorrect result.
+
+Specs-Driven Development bridges this gap. By providing the AI with a clear, structured, and unambiguous spec, you transform it from an unpredictable generator into a reliable engineering partner. The developer's role evolves from a **coder** to an **architect**—designing the blueprint that the AI can then execute with precision.
+:::
+
+## The Core Workflow in Simone
+
+In the Simone ecosystem, Specs-Driven Development follows a clear, three-step process that emphasizes planning and precision.
+
+### 1. Define the Spec
+The developer's first and most important job is to analyze a problem and create a detailed task specification. This isn't a quick note; it's a formal piece of documentation that leaves no room for ambiguity.
+
+A good spec should include:
+- **A Clear Goal:** What is the user story or objective?
+- **Acceptance Criteria:** How do we know when the task is done and correct?
+- **Constraints & Edge Cases:** What are the boundaries and potential pitfalls?
+- **Implementation Notes:** Are there specific patterns, libraries, or functions that must be used?
+
+### 2. AI Implementation
+With a clear spec in hand, the developer delegates the implementation to the AI using a simple command, like `/do_task`. Simone loads the spec as the primary context, allowing the AI to focus entirely on translating the well-defined requirements into code.
+
+### 3. Review and Refine
+The developer reviews the AI-generated code against the spec. If the output is incorrect or incomplete, the first instinct shouldn't be to fix the code directly. Instead, the developer should ask: **"Is the spec clear enough?"**
+
+By refining the spec and having the AI regenerate the code, the spec remains the true source of truth, ensuring that the documentation and implementation never drift apart.
+
+:::tip The Benefits of a Spec-First Approach
+- **Predictable AI:** Dramatically improves the reliability and consistency of the AI's output.
+- **Enhanced Developer Focus:** Frees developers from tedious coding to focus on higher-level architecture and problem-solving.
+- **Living Documentation:** Your spec library becomes a rich, detailed, and always up-to-date history of your project's functionality.
+- **Superior Testability:** Clear acceptance criteria in a spec are the perfect foundation for writing robust unit and integration tests.
+:::

package/skills/jarvis/claude-simone/documentation/README.md

@@ -0,0 +1,41 @@
+# Website
+
+This website is built using [Docusaurus](https://docusaurus.io/), a modern static website generator.
+
+## Installation
+
+```bash
+yarn
+```
+
+## Local Development
+
+```bash
+yarn start
+```
+
+This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
+
+## Build
+
+```bash
+yarn build
+```
+
+This command generates static content into the `build` directory and can be served using any static contents hosting service.
+
+## Deployment
+
+Using SSH:
+
+```bash
+USE_SSH=true yarn deploy
+```
+
+Not using SSH:
+
+```bash
+GIT_USER=<Your GitHub username> yarn deploy
+```
+
+If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.

package/skills/jarvis/claude-simone/documentation/_category_.json

@@ -0,0 +1,4 @@
+{
+  "label": "Command Reference",
+  "position": 4
+}

package/skills/jarvis/claude-simone/documentation/do_task.md

@@ -0,0 +1,52 @@
+---
+sidebar_position: 2
+---
+
+# do_task
+
+The `do_task` command is the primary command for executing development work. It instructs the AI to pick up a specific task and implement it.
+
+## Usage
+
+To let the AI select the next available task:
+```
+/simone:do_task
+```
+
+To specify a task directly:
+```
+/simone:do_task T01_S01
+```
+
+## Arguments
+
+*   **`task_id`** (optional): The ID of the task to execute (e.g., `T01_S01`, `T003`). If not provided, the AI will select the next open task from the current sprint or the general task list.
+
+## Description: The Core Development Loop
+
+This command orchestrates the core development loop, ensuring the AI works with full context and performs necessary quality checks:
+
+### 1. Task Identification & Analysis
+
+*   **Identifies Task:** It finds the specified task file (or the next available one) in the `.simone/03_SPRINTS/` or `.simone/04_GENERAL_TASKS/` directories.
+*   **Analyzes Task:** It reads the task description, goals, acceptance criteria, and any technical guidance provided within the task file.
+
+### 2. Context Validation
+
+*   **Validates Context:** Before starting, it performs a critical context validation to ensure the task belongs to the current sprint, its dependencies are met, and it aligns with the project's overall requirements.
+
+### 3. Execution & Status Update
+
+*   **Sets Status:** It updates the task's status to `in_progress` in both the task file and the project manifest.
+*   **Executes Work:** It follows the implementation plan outlined in the task file, iterating through the subtasks and making the required code changes in the project codebase.
+
+### 4. Quality Assurance & Finalization
+
+*   **Performs Quality Checks:** After the implementation is complete, it automatically runs a code review and the project's test suite to ensure the changes are high-quality and don't introduce regressions.
+*   **Finalizes Status:** Upon successful review and testing, it marks the task as `completed` and renames the task file to reflect this (e.g., `TX01_S01...`).
+
+## When to Use
+
+:::info
+Use this command whenever you are ready to start development work on a planned and detailed task.
+:::

package/skills/jarvis/claude-simone/documentation/docusaurus.config.ts

@@ -0,0 +1,126 @@
+import {themes as prismThemes} from 'prism-react-renderer';
+import type {Config} from '@docusaurus/types';
+import type * as Preset from '@docusaurus/preset-classic';
+
+// This runs in Node.js - Don't use client-side code here (browser APIs, JSX...)
+
+const config: Config = {
+  title: 'Simone - AI Project Management',
+  tagline: 'A framework for AI-assisted software development',
+  favicon: 'img/favicon.ico',
+
+  // Future flags, see https://docusaurus.io/docs/api/docusaurus-config#future
+  future: {
+    v4: true, // Improve compatibility with the upcoming Docusaurus v4
+  },
+
+  // Set the production url of your site here
+  url: 'https://helmi.github.io',
+  // Set the /<baseUrl>/ pathname under which your site is served
+  // For GitHub pages deployment, it is often '/<projectName>/'
+  baseUrl: '/claude-simone/',
+
+  // GitHub pages deployment config.
+  // If you aren't using GitHub pages, you don't need these.
+  organizationName: 'helmi', // Usually your GitHub org/user name.
+  projectName: 'claude-simone', // Usually your repo name.
+
+  onBrokenLinks: 'throw',
+  onBrokenMarkdownLinks: 'warn',
+
+  // Even if you don't use internationalization, you can use this field to set
+  // useful metadata like html lang. For example, if your site is Chinese, you
+  // may want to replace "en" with "zh-Hans".
+  i18n: {
+    defaultLocale: 'en',
+    locales: ['en'],
+  },
+
+  presets: [
+    [
+      'classic',
+      {
+        docs: {
+          path: './',
+          routeBasePath: '/',
+          sidebarPath: './sidebars.ts',
+          exclude: [
+            '**/node_modules/**',
+            '**/.docusaurus/**',
+            '**/build/**',
+          ],
+          // Please change this to your repo.
+          // Remove this to remove the "edit this page" links.
+          editUrl:
+            'https://github.com/helmi/claude-simone/tree/main/',
+          
+        },
+        blog: false, // Disable the blog plugin
+        pages: false, // Disable the pages plugin
+        theme: {
+          customCss: './src/css/custom.css',
+        },
+      } satisfies Preset.Options,
+    ],
+  ],
+
+  
+
+  themeConfig: {
+    announcementBar: {
+      id: 'work_in_progress',
+      content:
+        '🚧 **This documentation is a work in progress.** Information may be incomplete or inaccurate. For feedback, please visit the <a target="_blank" rel="noopener noreferrer" href="https://github.com/helmi/claude-simone">GitHub repository</a>. 🚧',
+      backgroundColor: '#fffbdd',
+      textColor: '#665400',
+      isCloseable: true,
+    },
+    // Replace with your project's social card
+    image: 'img/docusaurus-social-card.jpg',
+    navbar: {
+      title: 'Simone',
+      logo: {
+        alt: 'Simone Logo',
+        src: 'img/simone-icon-only.svg',
+      },
+      items: [
+        {
+          href: 'https://github.com/helmi/claude-simone',
+          position: 'right',
+          className: 'header-github-link',
+          'aria-label': 'GitHub repository',
+        },
+      ],
+    },
+    footer: {
+      style: 'dark',
+      links: [
+        {
+          title: 'Docs',
+          items: [
+            {
+              label: 'Introduction',
+              to: '/',
+            },
+          ],
+        },
+        {
+          title: 'Community',
+          items: [
+            {
+              label: 'GitHub Issues',
+              href: 'https://github.com/helmi/claude-simone/issues',
+            },
+          ],
+        },
+      ],
+      copyright: `Copyright © ${new Date().getFullYear()} Helmi. Built with Docusaurus.`,
+    },
+    prism: {
+      theme: prismThemes.github,
+      darkTheme: prismThemes.dracula,
+    },
+  } satisfies Preset.ThemeConfig,
+};
+
+export default config;

package/skills/jarvis/claude-simone/documentation/initialize.md

@@ -0,0 +1,38 @@
+---
+sidebar_position: 1
+---
+
+# initialize
+
+The `initialize` command sets up the Simone framework in a new or existing project.
+
+## Usage
+
+```
+/simone:initialize
+```
+
+## Description
+
+This is the first command you should run when setting up Simone. It performs the following actions through an interactive, conversational process:
+
+### 1. Project Analysis
+
+*   **Scans and Analyzes:** It inspects your project to detect its characteristics, such as the programming language (Node.js, Python, etc.) and existing documentation.
+*   **Confirms with User:** It presents its findings and asks for your confirmation before proceeding.
+
+### 2. Document Handling
+
+*   **Handles Existing Documents:** It checks for any existing Simone documents. If found, it will ask whether to use them or start fresh. It can also help you import your own existing project documentation into the Simone structure.
+*   **Guides Document Creation:** If you are starting fresh, it will perform a deeper analysis of your codebase to create draft versions of key documents, like an `ARCHITECTURE.md`.
+
+### 3. Initial Project Setup
+
+*   **Creates First Milestone:** It helps you define and create your first milestone, ensuring it is realistic and well-scoped for the current state of your project.
+*   **Generates Manifest:** Finally, it generates the `00_PROJECT_MANIFEST.md` file based on all the information gathered.
+
+## When to Use
+
+:::info
+This command should typically only be run **once** at the very beginning of integrating a project with Simone.
+:::

package/skills/jarvis/claude-simone/documentation/introduction.md

@@ -0,0 +1,83 @@
+---
+sidebar_position: 1
+---
+
+import FeatureCard from '@site/src/components/FeatureCard';
+import styles from '@site/src/components/FeatureCard.module.css';
+
+# Welcome to Simone Documentation
+
+<div class="lead-paragraph">
+Simone is a specialized framework designed to empower AI agents, particularly those like Claude Code, to operate effectively within complex software engineering projects. It offers a suite of features that enable a context-aware environment, ensuring the AI always has the precise information needed to perform its tasks.
+</div>
+
+:::tip
+Looking for the project files? Find them on the [GitHub Repository](https://github.com/helmi/claude-simone).
+:::
+
+## The Core Challenge: Context Management in AI Development
+
+Large language models are powerful tools, yet they face a significant limitation: a finite context window. In dynamic coding sessions, critical project details—architectural decisions, evolving requirements, and past implementations—can be lost as the AI's conversational memory cycles. This "context decay" leads to inconsistencies, rework, and a diminished ability for the AI to act as a truly informed partner.
+
+## Simone's Solution: Engineered Context for Every Task
+
+Simone addresses this challenge by shifting the paradigm from continuous, memory-reliant sessions to a structured, task-based approach. Our core philosophy is simple:
+
+> **Every task begins with a fresh, complete, and precisely relevant context.**
+
+Instead of expecting the AI to retain all project knowledge across long interactions, Simone systematically primes the AI with the project's authoritative "ground truth"—its meticulously organized documentation, requirements, and architectural blueprints—at the outset of each distinct task. This empowers the AI to work with the same level of awareness and confidence as a human developer who consults project specifications before writing code.
+
+## Explore Simone
+
+### Legacy System: Stable & Ready
+
+<div class={styles.featureGrid}>
+  <FeatureCard
+    title="File-Based Context"
+    description="Organizes project knowledge in a structured directory of Markdown files for transparent context management."
+    icon="📁"
+    to="/legacy-overview"
+  />
+  <FeatureCard
+    title="AI-Guided Commands"
+    description="Utilizes human-readable Markdown files as detailed instructions for AI agents to execute complex tasks."
+    icon="🤖"
+    to="/initialize"
+  />
+  <FeatureCard
+    title="Iterative Workflow"
+    description="Supports a structured development cycle from planning milestones to executing and committing individual tasks."
+    icon="🔄"
+    to="/legacy-workflow"
+  />
+</div>
+
+### MCP Server: The Future of AI Development
+
+<div class={styles.featureGrid}>
+  <FeatureCard
+    title="Protocol-Driven Interaction"
+    description="Communicates with AI agents via the Model Context Protocol (MCP) for robust and standardized interactions."
+    icon="⚡"
+    to="/mcp-overview"
+  />
+  <FeatureCard
+    title="Activity Logging"
+    description="Features a built-in SQLite database to persistently log all AI-assisted development activities for analysis."
+    icon="📊"
+    to="/mcp-workflow"
+  />
+  <FeatureCard
+    title="Dynamic Prompts"
+    description="Leverages Handlebars templating to create highly configurable and context-aware prompts for AI agents."
+    icon="✨"
+    to="/prompt-reference"
+  />
+</div>
+
+## Getting Started
+
+Ready to enhance your AI-assisted development? Choose your path:
+
+*   [**Legacy System Installation**](/legacy-installation) - Start with the stable, production-ready version.
+*   [**MCP Server Installation**](/mcp-installation) - Explore the cutting-edge, in-development future of Simone.

package/skills/jarvis/claude-simone/documentation/legacy-architecture.md

@@ -0,0 +1,7 @@
+---
+sidebar_position: 2
+---
+
+# Legacy System Architecture
+
+This document will describe the architecture of the legacy Simone system.