project-iris 0.0.1

package/src/iris_bundle/frameworks/iris-core/memory-bank/intents/003-memory-bank-system/units/context-loader/unit-brief.md

@@ -0,0 +1,245 @@
+# Unit Brief: Context Loader
+
+## Overview
+
+The Context Loader unit handles reading the memory-bank.yaml configuration and loading relevant artifacts when an agent activates. This provides agents with the context they need to understand project state.
+
+---
+
+## Scope
+
+### In Scope
+
+- Reading memory-bank.yaml on agent activation
+- Resolving path templates
+- Loading phase-relevant artifacts
+- Providing context to agent skills
+- Determining project state (phase, progress)
+
+### Out of Scope
+
+- Schema definition (handled by configuration-schema)
+- Actual file I/O (handled by artifact-storage)
+
+---
+
+## Technical Context
+
+### Activation Point
+
+Every agent reads context at activation before executing any skill.
+
+### Agent Activation Pattern
+
+```text
+User invokes /irismd-{agent}
+         │
+         ▼
+Agent activates
+         │
+         ▼
+Context Loader reads memory-bank.yaml
+         │
+         ▼
+Context Loader loads relevant artifacts
+         │
+         ▼
+Agent receives context object
+         │
+         ▼
+Agent executes skill with context
+```
+
+---
+
+## Implementation Details
+
+### Context Object Structure
+
+```javascript
+{
+  // Configuration
+  config: {
+    schema: { /* from memory-bank.yaml */ },
+    structure: [ /* from memory-bank.yaml */ ],
+    ownership: { /* from memory-bank.yaml */ }
+  },
+
+  // Project State
+  project: {
+    hasIntents: boolean,
+    hasUnits: boolean,
+    hasBolts: boolean,
+    hasStandards: boolean,
+    phase: "none" | "inception" | "construction" | "operations"
+  },
+
+  // Loaded Artifacts (varies by agent)
+  artifacts: {
+    intents: [ /* list of intent objects */ ],
+    currentIntent: { /* if working on specific intent */ },
+    currentUnit: { /* if working on specific unit */ },
+    standards: { /* loaded standards */ },
+    // ... more as needed
+  }
+}
+```
+
+### Phase Determination Logic
+
+```text
+function determinePhase(memoryBank):
+    IF no intents exist:
+        return "none"  // Need to start inception
+
+    IF intents exist but no units with stories:
+        return "inception"  // Still in inception
+
+    IF stories exist but no completed bolts:
+        return "construction"  // Ready for construction
+
+    IF completed bolts exist:
+        return "operations"  // Ready for deployment
+```
+
+### Agent-Specific Loading
+
+Each agent loads different context based on its phase:
+
+**Master Agent**:
+
+- All intents (names, status)
+- All bolts (status)
+- Standards (if exist)
+- Determines overall project phase
+
+**Inception Agent**:
+
+- All intents with details
+- Current intent's requirements, context, units
+- Story status per unit
+
+**Construction Agent**:
+
+- Current unit brief
+- Stories for current unit
+- Active bolts
+- Standards (tech-stack, coding-standards)
+
+**Operations Agent**:
+
+- Completed bolts
+- Deployment context
+- Standards
+
+### Context Loading Algorithm
+
+```text
+function loadContext(agentType):
+    // 1. Read config
+    config = readYAML(".irismd/memory-bank.yaml")
+
+    // 2. Determine project state
+    project = analyzeProjectState(config)
+
+    // 3. Load agent-specific artifacts
+    artifacts = {}
+
+    IF agentType == "master":
+        artifacts.intents = listAllIntents()
+        artifacts.standards = loadStandards()
+
+    ELSE IF agentType == "inception":
+        artifacts.intents = listAllIntents()
+        artifacts.currentIntent = loadCurrentIntent()
+
+    ELSE IF agentType == "construction":
+        artifacts.currentUnit = loadCurrentUnit()
+        artifacts.standards = loadStandards()
+        artifacts.bolts = listActiveBolts()
+
+    ELSE IF agentType == "operations":
+        artifacts.completedBolts = listCompletedBolts()
+        artifacts.deploymentContext = loadDeploymentContext()
+
+    // 4. Return context
+    return { config, project, artifacts }
+```
+
+### Artifact Loading Functions
+
+```javascript
+function listAllIntents():
+    // List directories in memory-bank/intents/
+    // For each, load requirements.md header
+    // Return array of { name, status, path }
+
+function loadCurrentIntent(intentName):
+    // Load from memory-bank/intents/{intentName}/
+    // Include: requirements.md, system-context.md, units.md
+    // Return structured object
+
+function loadStandards():
+    // Load from memory-bank/standards/
+    // Return { techStack, codingStandards, architecture }
+
+function listActiveBolts():
+    // List files in memory-bank/bolts/
+    // Filter by status != "completed"
+    // Return array of bolt summaries
+```
+
+---
+
+## Caching Policy
+
+**No caching between sessions**. Agents are stateless, so context is loaded fresh each time.
+
+Rationale:
+
+- Memory bank may change between invocations
+- User may have manually edited files
+- Fresh state ensures accuracy
+
+---
+
+## Error Handling
+
+| Error Case | Handling |
+|------------|----------|
+| memory-bank.yaml missing | Create default config |
+| memory-bank/ empty | Return phase="none" |
+| Corrupt YAML | Surface error, suggest fix |
+| Missing artifact | Skip, note in context |
+
+---
+
+## Acceptance Criteria
+
+### AC-1: Fresh Context on Activation
+
+- GIVEN agent was invoked 5 minutes ago
+- WHEN agent is invoked again
+- THEN fresh context is loaded from disk
+- AND changes made since last invocation are reflected
+
+### AC-2: Phase Detection
+
+- GIVEN memory bank with intents but no bolts
+- WHEN Master Agent loads context
+- THEN project.phase equals "inception" or "construction"
+- AND routing recommendations match phase
+
+### AC-3: Agent-Specific Loading
+
+- GIVEN Construction Agent activates
+- WHEN context is loaded
+- THEN standards are included (for code generation)
+- AND only construction-relevant artifacts loaded
+
+### AC-4: Graceful Degradation
+
+- GIVEN partially populated memory bank
+- WHEN context is loaded
+- THEN missing sections are null/empty
+- AND agent can still function

package/src/iris_bundle/frameworks/iris-core/memory-bank/intents/003-memory-bank-system/units.md

@@ -0,0 +1,97 @@
+# Unit Decomposition: 003-memory-bank-system
+
+## Overview
+
+The Memory Bank System intent is decomposed into units for configuration, storage, and context management.
+
+---
+
+## Units Created
+
+| Unit | Purpose | Dependencies |
+|------|---------|--------------|
+| `configuration-schema` | YAML config definition and parsing | None |
+| `artifact-storage` | File-based artifact persistence | `configuration-schema` |
+| `context-loader` | Memory Bank reading on agent activation | `configuration-schema`, `artifact-storage` |
+
+---
+
+## Dependency Graph
+
+```text
+┌─────────────────────┐
+│ configuration-schema│
+└──────────┬──────────┘
+           │
+           ▼
+┌─────────────────────┐
+│   artifact-storage  │
+└──────────┬──────────┘
+           │
+           ▼
+┌─────────────────────┐
+│    context-loader   │
+└─────────────────────┘
+```
+
+---
+
+## Unit Details
+
+### Unit: configuration-schema
+
+**Purpose**: Define and manage the `memory-bank.yaml` configuration that all agents read.
+
+**Responsibility**:
+
+- Provide schema definition for artifact paths
+- Define structure and schema sections
+- Define agent ownership boundaries
+- Support path template resolution with variables
+
+**Dependencies**: None
+
+**Interface**: `.irismd/memory-bank.yaml` configuration file
+
+---
+
+### Unit: artifact-storage
+
+**Purpose**: Store and retrieve markdown artifacts in the filesystem.
+
+**Responsibility**:
+
+- Write artifacts following schema paths
+- Read artifacts from resolved paths
+- Create directories on-demand
+- Maintain git-friendly file structure
+
+**Dependencies**: `configuration-schema` (for path templates)
+
+**Interface**: File system operations
+
+---
+
+### Unit: context-loader
+
+**Purpose**: Load relevant context from Memory Bank when agents activate.
+
+**Responsibility**:
+
+- Read `memory-bank.yaml` on agent activation
+- Resolve path templates to actual paths
+- Load phase-relevant artifacts
+- Provide context to agent skills
+
+**Dependencies**: `configuration-schema`, `artifact-storage`
+
+**Interface**: Context object provided to agents
+
+---
+
+## Artifacts Created
+
+- `003-memory-bank-system/units.md` (this file)
+- `003-memory-bank-system/units/configuration-schema/unit-brief.md`
+- `003-memory-bank-system/units/artifact-storage/unit-brief.md`
+- `003-memory-bank-system/units/context-loader/unit-brief.md`

package/src/iris_bundle/frameworks/iris-core/memory-bank/intents/004-standards-system/requirements.md

@@ -0,0 +1,125 @@
+---
+status: complete
+completed: 2025-12-25
+note: "Implemented before irismd dogfooding. Stories not tracked in AI-DLC."
+---
+
+# Intent: Standards System
+
+## Overview
+
+Provide a catalog-driven system for establishing and managing project standards that guide AI code generation and ensure consistency across all agents.
+
+---
+
+## Functional Requirements
+
+### FR-1: Standards Catalog
+
+- FR-1.1: System SHALL define available standards in `catalog.yaml`
+- FR-1.2: Catalog SHALL specify standard dependencies (e.g., coding-standards depends on tech-stack)
+- FR-1.3: Catalog SHALL define decisions within each standard
+- FR-1.4: Catalog SHALL mark standards as critical or optional
+
+### FR-2: Standard Types
+
+- FR-2.1: System SHALL support Tech Stack standard (languages, frameworks, databases)
+- FR-2.2: System SHALL support Coding Standards (formatting, linting, naming, testing)
+- FR-2.3: System SHALL support System Architecture standard (patterns, API design)
+- FR-2.4: System SHALL support UX Guide standard (design system, accessibility)
+- FR-2.5: System SHALL support API Conventions standard (versioning, response formats)
+
+### FR-3: Facilitation Guides
+
+- FR-3.1: Each standard SHALL have a facilitation guide
+- FR-3.2: Guides SHALL provide conversation prompts for eliciting decisions
+- FR-3.3: Guides SHALL adapt to project type (full-stack, API, CLI, library)
+- FR-3.4: Guides SHALL adapt to user expertise level
+
+### FR-4: Project Initialization
+
+- FR-4.1: Master Agent `project-init` skill SHALL facilitate standards creation
+- FR-4.2: System SHALL process standards in dependency order
+- FR-4.3: System SHALL generate standard files in `standards/` directory
+
+### FR-5: Project Type Presets
+
+- FR-5.1: System SHALL support full-stack-web preset
+- FR-5.2: System SHALL support backend-api preset
+- FR-5.3: System SHALL support frontend-app preset
+- FR-5.4: System SHALL support cli-tool preset
+- FR-5.5: System SHALL support library preset
+- FR-5.6: Presets SHALL define required and recommended standards
+
+### FR-6: Construction Agent Integration
+
+- FR-6.1: Construction Agent SHALL load tech-stack.md before code generation
+- FR-6.2: Construction Agent SHALL load coding-standards.md for style enforcement
+- FR-6.3: Standards SHALL influence AI-generated code patterns
+
+---
+
+## Non-Functional Requirements
+
+### NFR-1: Usability
+
+- Facilitation guides SHALL use conversational, non-technical language where possible
+- Standard files SHALL be human-readable markdown
+- Decisions SHALL be captured with rationale
+
+### NFR-2: Extensibility
+
+- New standards SHALL be addable via catalog.yaml
+- Custom facilitation guides SHALL be creatable
+
+---
+
+## Catalog Structure
+
+```yaml
+standards:
+  tech-stack:
+    description: Technology choices for the project
+    facilitation: templates/standards/tech-stack.guide.md
+    output_path: standards/tech-stack.md
+    importance: critical
+    decisions:
+      - id: languages
+      - id: framework
+      - id: database
+      - id: orm
+      - id: authentication
+      - id: infrastructure
+      - id: package_manager
+
+  coding-standards:
+    depends_on_standards: [tech-stack]
+    # ... decisions for formatting, linting, naming, etc.
+
+project_types:
+  full-stack-web:
+    required_standards: [tech-stack, coding-standards]
+    recommended_standards: [system-architecture, ux-guide, api-conventions]
+```
+
+---
+
+## Acceptance Criteria
+
+### AC-1: Project Init
+
+- GIVEN a new project with no standards
+- WHEN user invokes `/irismd-master-agent` (auto-redirected to project-init for uninitialized projects)
+- THEN Master Agent guides through tech-stack decisions first
+
+### AC-2: Dependency Order
+
+- GIVEN tech-stack is incomplete
+- WHEN user tries to create coding-standards
+- THEN system prompts to complete tech-stack first
+
+### AC-3: Construction Integration
+
+- GIVEN standards are defined
+- WHEN Construction Agent generates code
+- THEN generated code follows tech-stack and coding-standards

package/src/iris_bundle/frameworks/iris-core/memory-bank/intents/004-standards-system/system-context.md

@@ -0,0 +1,158 @@
+# System Context: Standards System
+
+## Overview
+
+This document defines the boundaries and integration points for the Standards System.
+
+---
+
+## System Boundary
+
+```text
+┌────────────────────────────────────────────────────────────────────┐
+│                         Agent Layer                                 │
+│  ┌────────────────────────────────────────────────────────────┐    │
+│  │                    Master Agent                             │    │
+│  │              (project-init skill creates standards)         │    │
+│  └─────────────────────────┬──────────────────────────────────┘    │
+│                            │                                        │
+│  ┌────────────┐  ┌─────────▼────────┐  ┌──────────────────────┐   │
+│  │ Inception  │  │  Construction    │  │    Operations        │   │
+│  │   Agent    │  │     Agent        │  │      Agent           │   │
+│  │            │  │ (reads standards)│  │  (reads standards)   │   │
+│  └────────────┘  └──────────────────┘  └──────────────────────┘   │
+└────────────────────────────────────────────────────────────────────┘
+                                │
+                    Reads/Writes│
+                                ▼
+┌────────────────────────────────────────────────────────────────────┐
+│                      Standards System                               │
+│  ┌─────────────────────────────────────────────────────────────┐   │
+│  │                memory-bank/standards/                        │   │
+│  │  ┌──────────────┐  ┌──────────────────┐  ┌───────────────┐  │   │
+│  │  │ tech-stack.md│  │coding-standards.md│  │system-arch.md│  │   │
+│  │  └──────────────┘  └──────────────────┘  └───────────────┘  │   │
+│  └─────────────────────────────────────────────────────────────┘   │
+│                                                                     │
+│  ┌─────────────────────────────────────────────────────────────┐   │
+│  │               .irismd/standards-catalog.yaml                │   │
+│  │                 (Available standards definitions)            │   │
+│  └─────────────────────────────────────────────────────────────┘   │
+│                                                                     │
+│  ┌─────────────────────────────────────────────────────────────┐   │
+│  │               .irismd/aidlc/templates/standards/                  │   │
+│  │                 (Templates for each standard)                │   │
+│  └─────────────────────────────────────────────────────────────┘   │
+└────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## External Systems
+
+### Project Codebase
+
+- **Type**: User's software project
+- **Interface**: File system
+- **Constraint**: Standards must be compatible with existing project
+
+---
+
+## Internal Components
+
+### Standards Catalog
+
+- **Location**: `.irismd/standards-catalog.yaml`
+- **Purpose**: Define available standards and their metadata
+- **Format**:
+
+```yaml
+standards:
+  - id: tech-stack
+    name: Technology Stack
+    description: Document technology choices
+    required: true
+  - id: coding-standards
+    name: Coding Standards
+    description: Code style and quality conventions
+    required: true
+  - id: system-architecture
+    name: System Architecture
+    description: Architectural patterns and decisions
+    required: true
+```
+
+### Standard Files
+
+- **Location**: `memory-bank/standards/`
+- **Purpose**: Project-specific standard documentation
+- **Format**: Markdown files following templates
+
+### Standard Templates
+
+- **Location**: `.irismd/aidlc/templates/standards/`
+- **Purpose**: Boilerplate for creating standard files
+- **Examples**: `tech-stack-template.md`, `coding-standards-template.md`
+
+---
+
+## Data Flow
+
+### Project Initialization
+
+```text
+User runs project-init
+    │
+    ▼
+Master Agent reads standards-catalog.yaml
+    │
+    ▼
+For each required standard:
+    │
+    ├─▶ Read template from .irismd/aidlc/templates/standards/
+    │
+    └─▶ Create standard file in memory-bank/standards/
+    │
+    ▼
+Standards ready for agents to consume
+```
+
+### Agent Standards Consumption
+
+```text
+Construction Agent starts bolt
+    │
+    ▼
+Read memory-bank/standards/tech-stack.md
+    │
+    ▼
+Read memory-bank/standards/coding-standards.md
+    │
+    ▼
+Apply standards during implementation
+```
+
+---
+
+## Integration Contracts
+
+### Standard File Format
+
+- Markdown with clear sections
+- Human-readable and editable
+- No required frontmatter (optional YAML frontmatter allowed)
+
+### Catalog Format
+
+- YAML format
+- Each standard has: id, name, description, required flag
+- Templates referenced by convention: `{id}-template.md`
+
+---
+
+## Constraints
+
+- Standards must be human-readable
+- Standards must be editable by project team
+- Standards must be git-safe
+- Standards apply project-wide (not per-intent or per-unit)