mia-code 0.2.0 → 0.3.0

package/rispecs/README.md

@@ -0,0 +1,164 @@
+# mia-code RISE Specifications Index
+
+> RISE Framework Specification Index v1.0
+> Document: mia-code/rispecs/README.md
+> Generated: 2026-01-30
+
+## Overview
+
+This directory contains RISE Framework specifications for the **mia-code** terminal coding agent. These specifications follow the RISE methodology (Reverse-engineer → Intent-extract → Specify → Export) and are designed to be:
+
+- **Codebase-Agnostic:** Complete enough to re-implement the system from scratch
+- **Creative-Oriented:** Focus on what users create, not problems solved
+- **Structural Tension Driven:** Document movement from current reality to desired outcomes
+
+## Specification Files
+
+### Core Specifications
+
+| File | Description | Status |
+|------|-------------|--------|
+| [`core.rispecs.md`](./core.rispecs.md) | Core CLI architecture, dual-session flow, main components | ✅ Complete |
+| [`engines.rispecs.md`](./engines.rispecs.md) | Multi-engine support (Gemini/Claude/Copilot), argument translation | ✅ Complete |
+| [`unifier.rispecs.md`](./unifier.rispecs.md) | Ceremonial interpretation layer, 🧠 Mia + 🌸 Miette | ✅ Complete |
+| [`session.rispecs.md`](./session.rispecs.md) | Session persistence, auto-resume, project association | ✅ Complete |
+| [`formatting.rispecs.md`](./formatting.rispecs.md) | Terminal output styling, visual hierarchy | ✅ Complete |
+| [`mcp.rispecs.md`](./mcp.rispecs.md) | MCP server architecture (miaco/miatel/miawa as JSON-RPC stdio servers) | ✅ Complete |
+| [`stc.rispecs.md`](./stc.rispecs.md) | PDE → Structural Tension Chart conversion pipeline | ✅ Complete |
+
+### Future Enhancements
+
+| File | Description | Status |
+|------|-------------|--------|
+| [`pde.rispecs.md`](./pde.rispecs.md) | Prompt Decomposition Engine integration | 📝 DRAFT |
+
+## Application Summary
+
+**mia-code** is a terminal coding agent that wraps Gemini CLI, Claude CLI, and Copilot CLI in headless mode, providing:
+
+1. **Dual-Session Architecture:** Primary agent performs work → Unifier interprets essence
+2. **Multi-Engine Support:** Configurable between Gemini (default), Claude, and Copilot
+3. **Session Management:** Per-project persistence with automatic resume
+4. **Ceremonial Output:** 🧠 Mia (structure) + 🌸 Miette (echo) dual-perspective summaries
+5. **MCP Servers:** Three domain sub-CLIs (miaco/miatel/miawa) as JSON-RPC stdio servers for external agent integration
+
+## Structural Architecture
+
+```
+┌──────────────────────────────────────────────────────┐
+│  INTERACTIVE MODE                                    │
+│                                                      │
+│  User Prompt                                         │
+│      ↓                                               │
+│  mia-code CLI (index.ts / cli.ts)                    │
+│      ↓                                               │
+│  Engine Selection (config.ts)                        │
+│      ↓                                               │
+│  Primary Agent Session (geminiHeadless.ts)            │
+│      → Gemini CLI / Claude CLI / Copilot CLI         │
+│      → Tool calls, code changes, analysis            │
+│      → GeminiJsonEvent[] stream                      │
+│      ↓                                               │
+│  Unifier Session (unifier.ts)                        │
+│      → Claude CLI with --system-prompt               │
+│      → Ceremonial interpretation                     │
+│      ↓                                               │
+│  Formatted Output (formatting.ts)                    │
+│      → 🧠 mia (structure) + 🌸 miette (echo)         │
+│      ↓                                               │
+│  Session Persistence (sessionStore.ts)               │
+│      → ~/.mia-code-sessions.json                     │
+└──────────────────────────────────────────────────────┘
+
+┌──────────────────────────────────────────────────────┐
+│  MCP SERVER MODE (external agent integration)        │
+│                                                      │
+│  Claude Code / any MCP host                          │
+│      │                                               │
+│      ├── stdio → miaco-server.js  (8 tools)          │
+│      │     → charts, PDE decomposition               │
+│      │                                               │
+│      ├── stdio → miatel-server.js (4 tools)          │
+│      │     → story beats, analysis, enrichment       │
+│      │                                               │
+│      └── stdio → miawa-server.js  (6 tools)          │
+│            → ceremonies, wisdom, Four Movements      │
+│                                                      │
+│  Config: .mcp.mia-code.json                          │
+│  Protocol: JSON-RPC 2.0 over stdio                   │
+│  SDK: @modelcontextprotocol/sdk                      │
+└──────────────────────────────────────────────────────┘
+```
+
+## RISE Principles Applied
+
+Each specification follows RISE creative orientation:
+
+### ✅ Creative Orientation (Applied)
+- Focuses on what users create through the system
+- Emphasizes desired outcomes over reactive elimination
+- Uses advancing pattern language throughout
+
+### ✅ Structural Tension Dynamics (Applied)
+- Each spec begins with Current Reality → Desired State analysis
+- Documents natural progression toward outcomes
+- Identifies structural forces enabling advancement
+
+### ✅ Specification Autonomy (Applied)
+- Each spec is complete without reference to source code
+- Another LLM could implement from specs alone
+- Cross-references are conceptual, not file paths
+
+### ✅ Creative Advancement Scenarios (Applied)
+- Replace traditional BDD with outcome-focused scenarios
+- Document desired outcome, current reality, natural progression
+- Show achieved outcome with concrete examples
+
+## Usage
+
+### For Developers
+
+These specs serve as the source of truth for mia-code behavior. When implementing:
+
+1. Read relevant spec for component being modified
+2. Ensure changes align with documented Creative Intent
+3. Verify Structural Tension resolution is maintained
+4. Update specs if behavior changes
+
+### For LLMs
+
+When asked to modify or extend mia-code:
+
+1. Read `core.rispecs.md` for overall architecture understanding
+2. Consult specific component specs for detailed behavior
+3. Follow Creative Advancement Scenarios as test cases
+4. Maintain RISE principles in any spec updates
+
+### For Future PDE Integration
+
+The `pde.rispecs.md` draft documents planned Prompt Decomposition Engine integration. When implementing:
+
+1. Review academic literature in `/src/IAIP/prototypes/artefacts/PDE-generalization--*/`
+2. Follow five-layer decomposition pipeline
+3. Integrate Medicine Wheel direction assignment for ceremony-aware processing
+
+## Related Resources
+
+- **RISE Framework:** `/src/llms/llms-rise-framework.txt`
+- **PDE Literature:** `/src/IAIP/prototypes/artefacts/PDE-generalization--caefee82-efb1-4dbb-8733-691b01581464--260130/`
+- **Phase 2 Documentation:** `/a/src/mia-code/PHASE_2.md`
+- **README:** `/a/src/mia-code/README.md`
+
+## Specification Evolution
+
+These specs should evolve with the codebase using the Git-Log-Driven Upgrade Methodology (from RISE framework):
+
+1. **Temporal Gap Analysis:** Compare spec dates to git log
+2. **Commit Message Mining:** Extract feature additions from commits
+3. **Differential Analysis:** Map changed files to affected specs
+4. **Specification Update:** Document discovered features with RISE principles
+5. **Validation:** Ensure all commits are reflected in specs
+
+---
+
+*Generated following RISE Framework v1.2 principles*

package/rispecs/_sync_/miadi-code/SPEC.md

@@ -0,0 +1,313 @@
+# Miadi-Code RISE Specification
+
+**Version**: 1.2
+**Document ID**: miadi-code-rise-spec-v1.2
+**Date**: 2026-01-31
+
+---
+
+## Core Creative Intent
+
+Miadi-Code is a **Three-Universe Terminal Agent** that enables users to create code, manage structural tension charts, and maintain narrative continuity through an interpretive lens. Every interaction passes through Engineer (technical), Ceremony (relational), and Story Engine (narrative) perspectives before action.
+
+---
+
+## Related Specifications
+
+| Specification | Path | Description |
+|--------------|------|-------------|
+| **Dashboard TUI** | `./dashboard/SPEC.md` | Interactive terminal dashboard pattern |
+| **Multiline Input** | `./multiline-input/SPEC.md` | Rich multiline input with Ctrl+J |
+| **PDE** | `./pde/SPEC.md` | Prompt Decomposition Engine |
+| **Structural Tension Charting** | `./stc/SPEC.md` | Multi-chart hierarchical context management |
+
+---
+
+## Phase 1: Reverse-Engineering
+
+### A. Core Creative Intent
+
+**What does this application empower users to create?**
+- Interactive development sessions with narrative memory
+- Structural tension charts tracking desired outcomes vs current reality
+- Three-universe interpretations of coding tasks
+- STC file management (STC.md, STCGOAL.md, STCISSUE.md, STCMASTERY.md) in local workspaces
+- Interactive terminal dashboards for visual progress tracking
+
+**What desired outcomes does it facilitate?**
+- Coherent multi-session development with context preservation
+- Creative orientation (what to create) over reactive problem-solving
+- Skill mastery tracking through STCMASTERY.md
+- Goal clarification through STCGOAL.md
+- Visual progress monitoring via interactive TUI
+
+### B. User Creation Flows
+
+1. **Interactive Chat Flow**
+   - User launches `miadi chat`
+   - Prompt analyzed through three universes
+   - Engine (Claude/Gemini/Ollama) executes
+   - Session state preserved
+   - Story beat created
+
+2. **STC Workspace Flow** ✅ IMPLEMENTED
+   - User runs `/stc config add` to map repo to local path
+   - Local workspace mapped to GitHub repo
+   - STC files (STC.md, STCGOAL.md, etc.) loaded via `/stc load`
+   - Actions tracked as chart observations via `/stc observe`
+   - Webhooks update chart automatically
+
+3. **Chart Management Flow**
+   - User runs `/charts` to list active charts
+   - `/web` launches visual chart editor
+   - Action steps added/completed via CLI
+   - Narrative beats created from chart activity
+
+4. **Dashboard Flow** ✅ IMPLEMENTED
+   - User runs `/dashboard` or `/ui`
+   - Full-screen TUI renders with progress visualization
+   - Interactive menu for adding observations, actions
+   - Sync with Miadi Platform API
+   - See `./dashboard/SPEC.md` for full specification
+
+5. **Prompt Decomposition Flow** ✅ IMPLEMENTED
+   - User runs `/pde decompose "complex prompt"`
+   - 5-layer decomposition extracts intents
+   - Medicine Wheel mapping for ceremonial awareness
+   - Workflow generation with execution plan
+   - See `./pde/SPEC.md` for full specification
+
+### C. Feature Inventory
+
+**Vision-Supporting Features** (enable users to clarify desired outcomes):
+- `/charts` - View active structural tension charts
+- `/dashboard` - Interactive TUI for visual progress
+- `STCGOAL.md` - Define desired creative outcomes
+- Three-universe analysis before action
+- `/pde wheel` - Medicine Wheel direction mapping
+
+**Tension-Resolving Features** (facilitate progression toward goals):
+- `STCISSUE.md` - Track current reality issues
+- Action step management (add, complete, telescope)
+- Chart progress visualization (progress bars, action lists)
+- `/pde deps` - Dependency analysis for complex tasks
+
+**Manifestation Features** (support actual creation):
+- Engine execution (Claude, Gemini, Ollama)
+- Session memory persistence
+- Narrative beat creation
+- `/pde plan` - Execution plans with success criteria
+
+### D. Structural Patterns Worth Preserving
+
+1. **MCP Architecture**: Direct stdio connection to coaia-narrative for JSONL chart operations
+2. **Engine Feature Gating**: NoOpClient pattern for unsupported engines
+3. **Registry Pattern**: ChartRegistry tracks active chart sessions
+4. **Three-Universe Processor**: Every event analyzed through engineer/ceremony/story lenses
+5. **Prompt Intelligence Layer**: Validation, decomposition, routing
+6. **TUI Pattern**: Full-screen dashboard with readline isolation (see `./dashboard/SPEC.md`)
+7. **Data Adapter Pattern**: Server→UI transformation for flexible rendering
+
+---
+
+## Phase 2: Intent Refinement - STC Workspace Commands
+
+### Desired Outcome Definition
+
+Users want to:
+1. Configure which GitHub repos map to which local workspace paths
+2. Automatically load STC files when entering a workspace
+3. Have webhook events update their local charts
+4. Manage goals, issues, and mastery observations from CLI
+
+### Structural Tension Analysis
+
+**Current Reality** (as of 2026-01-30):
+- ✅ Miadi platform has `/api/stc/workspaces` CRUD API
+- ✅ Miadi platform has `/api/stc/charts` API for chart operations
+- ✅ miadi-code has `/charts` command via coaia-narrative MCP
+- ❌ miadi-code lacks `/stc` command family for workspace management
+- ❌ miadi-code cannot configure workspaces via CLI
+- ❌ No integration between miadi-code and Miadi platform STC APIs
+
+**Desired Structural State**:
+- miadi-code CLI can manage STC workspaces (`/stc config add`, `/stc config list`)
+- miadi-code can load STC files from local path (`/stc load`)
+- miadi-code can add observations, action steps (`/stc observe`, `/stc action`)
+- Webhook → Miadi Platform → Chart Update → miadi-code can query updated state
+
+### Creative Advancement Scenarios
+
+```
+**Creative Advancement Scenario**: Configure Workspace Mapping
+
+**Desired Outcome**: User wants jgwill/jgtsrc webhook events to update charts in /b/trading
+**Current Reality**: User has repos cloned but no mapping configured
+**Natural Progression**:
+  1. User runs: /stc config add jgwill/jgtsrc /b/trading
+  2. miadi-code calls POST /api/stc/workspaces with mapping
+  3. Confirmation displayed with STC file status
+  4. Future webhooks automatically resolve to this path
+**Achieved Outcome**: Workspace configured, STC bots can activate locally
+**Supporting Features**: /stc config add, Miadi API integration
+```
+
+```
+**Creative Advancement Scenario**: Add Goal Observation
+
+**Desired Outcome**: User wants to record a new goal in their structural tension chart
+**Current Reality**: User is in an interactive session
+**Natural Progression**:
+  1. User runs: /stc observe "Completed API integration for charts"
+  2. miadi-code resolves current workspace → chart
+  3. Observation added to current reality via /api/stc/charts
+  4. If auto-commit enabled, changes pushed to repo
+**Achieved Outcome**: Current reality updated, chart reflects progress
+**Supporting Features**: /stc observe, chart-manager integration
+```
+
+---
+
+## Phase 3: Export Optimization - Implementation Specification
+
+### New Files to Create
+
+```
+miadi-code/src/stc/
+├── workspace-client.ts    # HTTP client for Miadi /api/stc/* endpoints
+├── stc-commands.ts        # /stc command handlers
+└── stc-types.ts           # TypeScript interfaces for STC data
+```
+
+### API Endpoints to Integrate
+
+| Endpoint | Method | Purpose |
+|----------|--------|---------|
+| `/api/stc/workspaces` | GET | List configured workspaces |
+| `/api/stc/workspaces` | POST | Add/update workspace mapping |
+| `/api/stc/workspaces?repository=owner/repo` | GET | Get specific workspace |
+| `/api/stc/charts` | GET | List charts for workspace |
+| `/api/stc/charts` | POST | Add observation, action, beat |
+| `/api/stc/files/:owner/:repo/:filename` | GET/POST | Read/write STC files |
+
+### CLI Commands to Implement
+
+```bash
+# Workspace Configuration
+/stc config list                          # List all workspace mappings
+/stc config add <owner/repo> <localPath>  # Add mapping
+/stc config remove <owner/repo>           # Remove mapping
+
+# STC File Operations
+/stc load [repository]                    # Load STC files from workspace
+/stc status                               # Show current workspace status
+
+# Chart Operations (integrates with existing /charts)
+/stc observe "<observation>"              # Add observation to current reality
+/stc action add "<action>" [due]          # Add action step
+/stc action complete "<action>"           # Mark action complete
+/stc goal                                 # Display STCGOAL.md contents
+/stc issue                                # Display STCISSUE.md contents
+/stc mastery                              # Display STCMASTERY.md contents
+
+# Sync Operations
+/stc sync                                 # Sync STC files with chart
+/stc commit                               # Git commit and push .coaia/ changes
+```
+
+### TypeScript Interfaces
+
+```typescript
+interface STCWorkspace {
+  id: string;
+  repository: string;  // owner/repo
+  localPath: string;
+  stcFiles: {
+    stc: boolean;
+    stcgoal: boolean;
+    stcissue: boolean;
+    stcmastery: boolean;
+  };
+  chartId?: string;
+  lastSync?: string;
+}
+
+interface STCFileContent {
+  filename: 'STC.md' | 'STCGOAL.md' | 'STCISSUE.md' | 'STCMASTERY.md';
+  content: string;
+  lastModified: string;
+}
+
+interface AddObservationRequest {
+  repository: string;
+  observation: string;
+  autoCommit?: boolean;
+}
+
+interface AddActionRequest {
+  repository: string;
+  actionDescription: string;
+  currentReality?: string;
+  dueDate?: string;
+  autoCommit?: boolean;
+}
+```
+
+### Integration Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                     miadi-code CLI                               │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐  │
+│  │ /stc        │  │ /charts     │  │ prompt processing       │  │
+│  │ commands    │  │ (coaia-MCP) │  │ (three-universe)        │  │
+│  └──────┬──────┘  └──────┬──────┘  └─────────────────────────┘  │
+│         │                │                                       │
+└─────────┼────────────────┼───────────────────────────────────────┘
+          │                │
+          │HTTP            │MCP stdio
+          ▼                ▼
+┌─────────────────┐  ┌─────────────────┐
+│ Miadi Platform  │  │ coaia-narrative │
+│ /api/stc/*      │  │ (JSONL charts)  │
+│ Next.js 15      │  │                 │
+└────────┬────────┘  └────────┬────────┘
+         │                    │
+         └────────┬───────────┘
+                  │
+                  ▼
+         ┌───────────────┐
+         │ Local .coaia/ │
+         │ workspace     │
+         └───────────────┘
+```
+
+---
+
+## Success Criteria
+
+1. ✅ `/stc config` commands work from miadi-code CLI
+2. ✅ Workspaces persist via Miadi Platform API
+3. ✅ `/stc observe` adds observations to workspace chart
+4. ✅ `/stc load` displays STC file contents
+5. ✅ Integration tested with existing webhook flow
+6. ✅ Documentation updated in miadi-code/README.md
+
+---
+
+## Dependencies
+
+- Miadi Platform running on localhost:3335
+- `/api/stc/workspaces` API (already implemented)
+- `/api/stc/charts` API (already implemented)
+- coaia-narrative npm package
+
+---
+
+## Anti-Patterns Avoided
+
+- ❌ No forced gap-bridging language
+- ❌ No reactive "fixing problems" framing
+- ❌ No oscillating back-and-forth patterns
+- ✅ Focus on what users create (goals, mastery, clarity)
+- ✅ Structural tension drives natural progression

package/rispecs/_sync_/miadi-code/STATUS.md

@@ -0,0 +1,177 @@
+# Miadi-Code - Feature Parity STATUS
+
+**Version**: 1.2
+**Date**: 2026-01-31
+**Status**: ✅ IMPLEMENTED (All Core Features)
+
+---
+
+## Feature Parity Summary
+
+| Feature | Implementation | Rispecs | Status |
+|---------|---------------|---------|--------|
+| STC Workspace Commands | `src/stc/` | `SPEC.md` | ✅ Complete |
+| Interactive Dashboard | `src/dashboard.ts` | `dashboard/SPEC.md` | ✅ Complete |
+| Multiline Input | `src/multiline-input.ts` | `multiline-input/SPEC.md` | ✅ Complete |
+| PDE (Prompt Decomposition) | `src/pde/` | `PDE_SPEC.md` | ✅ Complete |
+| Hierarchical Charting | `src/context/` | `hierarchical-charting.rispecs.md` | 📝 Documented |
+| Three-Universe Processor | `src/universes/` | `SPEC.md` (referenced) | ✅ Complete |
+| Multi-Engine Support | `src/engines/` | `SPEC.md` (referenced) | ✅ Complete |
+
+---
+
+## Implementation Checklist
+
+### ✅ Phase 1: Analysis (COMPLETE)
+- [x] Analyzed SESSION_INPUT.md requirements
+- [x] Reviewed existing miadi-code implementation
+- [x] Reviewed Miadi platform STC APIs
+- [x] Created RISE specification
+
+### ✅ Phase 2: STC Core Implementation (COMPLETE)
+- [x] Create `src/stc/stc-types.ts` - TypeScript interfaces
+- [x] Create `src/stc/workspace-client.ts` - HTTP client for Miadi APIs
+- [x] Create `src/stc/stc-commands.ts` - Command handlers
+- [x] Create `src/stc/index.ts` - Module exports
+
+### ✅ Phase 3: CLI Integration (COMPLETE)
+- [x] Add `/stc` command routing in `cli.ts`
+- [x] Implement `/stc config list/add/remove`
+- [x] Implement `/stc observe`
+- [x] Implement `/stc action add/complete`
+- [x] Implement `/stc load`
+- [x] Implement `/stc status`
+- [x] Implement `/stc goal`, `/stc issue`, `/stc mastery`
+- [x] Implement `/stc sync`, `/stc commit`
+- [x] Update help text in `formatting.ts`
+- [x] Build passes
+
+### ✅ Phase 4: Dashboard TUI (COMPLETE)
+- [x] Create `src/dashboard.ts` - Interactive TUI class
+- [x] Implement TTY detection with fallback
+- [x] Implement full-screen rendering
+- [x] Implement interactive menu (Enquirer)
+- [x] Implement readline isolation
+- [x] Create `dashboard/SPEC.md` rispecs
+- [x] Create `dashboard/STATUS.md` rispecs
+
+### ✅ Phase 5: PDE Implementation (COMPLETE)
+- [x] Create `src/pde/` module with 5-layer pipeline
+- [x] Implement intent extraction
+- [x] Implement dependency analysis
+- [x] Implement Medicine Wheel mapping
+- [x] Implement workflow generation
+- [x] Implement execution planning
+- [x] Create `PDE_SPEC.md` rispecs
+
+### ✅ Phase 6: Multiline Input (COMPLETE)
+- [x] Create `src/multiline-input.ts` - Raw mode handler
+- [x] Implement Ctrl+J for new line, Enter for submit
+- [x] Implement paste detection and collection
+- [x] Implement cursor navigation and editing
+- [x] Update `src/cli.ts` with multiline integration
+- [x] Implement TTY fallback to readline
+- [x] Create `multiline-input/SPEC.md` rispecs
+- [x] Create `multiline-input/STATUS.md` rispecs
+
+### ✅ Phase 7: Testing (COMPLETE)
+- [x] STC workspace client tests (14 tests)
+- [x] STC command parsing tests (16 tests)
+- [x] Dashboard adapter tests (19 tests)
+- [x] Integration tests (13 tests)
+- [x] Engine feature tests (12 tests)
+- [x] PDE decomposition tests (26 tests)
+- [x] Multiline input tests (16 tests)
+- [x] **Total: 119 tests passing**
+
+---
+
+## Files Structure
+
+### Implementation Files
+```
+miadi-code/src/
+├── dashboard.ts              # Interactive TUI
+├── dashboard.test.ts         # Dashboard tests
+├── multiline-input.ts        # Multiline input handler
+├── multiline-input.test.ts   # Multiline tests
+├── cli.ts                    # Main CLI with command routing
+├── formatting.ts             # Help text and display
+├── stc/
+│   ├── stc-types.ts          # TypeScript interfaces
+│   ├── workspace-client.ts   # HTTP client
+│   ├── stc-commands.ts       # Command handlers
+│   └── index.ts              # Module exports
+├── pde/
+│   ├── pde-types.ts          # PDE interfaces
+│   ├── decomposer.ts         # Main orchestrator
+│   ├── intent-extractor.ts   # Layer 1
+│   ├── dependency-analyzer.ts # Layer 2
+│   ├── medicine-wheel-mapper.ts # Layer 3
+│   ├── workflow-generator.ts # Layer 4
+│   ├── execution-planner.ts  # Layer 5
+│   ├── pde-commands.ts       # CLI commands
+│   └── index.ts              # Module exports
+└── ...
+```
+
+### Rispecs Files
+```
+rispecs/miadi-code/
+├── SPEC.md                   # Main RISE specification
+├── STATUS.md                 # This file
+├── PDE_SPEC.md               # Prompt Decomposition Engine
+├── hierarchical-charting.rispecs.md  # Multi-chart management
+├── dashboard/
+│   ├── SPEC.md               # TUI pattern specification
+│   └── STATUS.md             # Dashboard implementation status
+└── multiline-input/
+    ├── SPEC.md               # Multiline input specification
+    └── STATUS.md             # Multiline input status
+```
+
+---
+
+## CLI Commands Implemented
+
+### STC Workspace Commands
+```bash
+/stc config list                    - List all workspace mappings
+/stc config add <owner/repo> <path> - Add a workspace mapping
+/stc config remove <owner/repo>     - Remove a workspace mapping
+/stc load [repo]                    - Load STC files from workspace
+/stc status [repo]                  - Show workspace status
+/stc goal [repo]                    - Show STCGOAL.md contents
+/stc issue [repo]                   - Show STCISSUE.md contents
+/stc mastery [repo]                 - Show STCMASTERY.md contents
+/stc observe "<observation>"        - Add observation to current reality
+/stc action add "<description>"     - Add action step
+/stc action complete "<name>"       - Mark action as complete
+/stc sync                           - Sync STC files with chart
+/stc commit                         - Git commit and push chart changes
+```
+
+### Dashboard Commands
+```bash
+/dashboard                          - Launch interactive TUI
+/ui                                 - Alias for /dashboard
+```
+
+### PDE Commands
+```bash
+/pde decompose "<prompt>"           - Full 5-layer decomposition
+/pde quick "<prompt>"               - Quick summary view
+/pde intents "<prompt>"             - Layer 1: Intent extraction
+/pde deps "<prompt>"                - Layer 2: Dependency graph
+/pde wheel "<prompt>"               - Layer 3: Medicine Wheel mapping
+/pde workflow "<prompt>"            - Layer 4: Workflow template
+/pde plan "<prompt>"                - Layer 5: Execution plan
+/pde check "<prompt>"               - Check prompt complexity
+/pde ceremony [type]                - Show ceremony requirements
+/pde export [format]                - Export last result (json/yaml/md)
+/pde last                           - Show last decomposition
+```
+
+---
+
+**Last Updated**: 2026-01-31T20:00:00Z