mia-code 0.2.0

package/GUILLAUME.md

@@ -0,0 +1,77 @@
+# GUILLAUME
+
+* This file is from the creator of Mia-Code and is destined to contain intentions, observations to be absorbed and tought thru ceremonies.
+
+
+## @STCMastery Sacred Container Preparation
+
+### Sample 2602031348
+
+```yaml
+SessionID: d59e4c89-d133-433a-b9f7-91cffe0d651f
+cwd: /media/jgi/F/Dropbox/Apps
+```
+
+* Is ready for :
+
+```
+chart-d59e4c89-d133-433a-b9f7-91cffe0d651f--260201 - init_llm_guidance (MCP)(format: "full")                    
+  ⎿  # COAIA Memory MCP - Essential LLM Guidance                                                                  
+                                                                                                                  
+     ## 🚨 READ THIS FIRST: Core Principles                                                                       
+     … +501 lines (ctrl+o to expand)                                                                              
+                                                                                                                  
+● 🧠: Work Completed                                                                                              
+                                                                                                                  
+  Prompt Decomposition Integration (UUID 75A91602-0577-4871-9141-6872AAD5B363):                                   
+  - Synopsis: Research-grounded PDE architecture summary                                                          
+  - Content: Full article converted from inquiry markdown to RTF                                                  
+  - Notes: Epistemology of disagreement study pending                                                             
+                                                                                                                  
+  Git Automation: scrivener_git_commit.sh commits markdown sources + RTF outputs with proper messaging            
+                                                                                                                  
+  Practical Workflow: Examples in coordination notes.rtf for future instances                                     
+                                                                                                                  
+  MCP Chart Guidance Consulted: Understand structural tension methodology, delayed resolution principle, creative 
+  orientation vs problem-solving. Action steps are strategic charts with tension, not task checklists.            
+                                                                                                                  
+  Standing by for your feedback via notes.rtf/content.rtf comments as you review the work.                        
+
+```
+
+#### What do I envision ?
+
+* Mia-Code (MiaCo most like it) can bring into a form of Orchestration Session where we add existing sessions in their state of being.  My intention is that they become FORKs that MiaCo uses to HOOK that up into the KINSHIP's Hub.
+* I named the conversation : `chart-d59e4c89-d133-433a-b9f7-91cffe0d651f--260201.001.root`
+* * If that is usable and is possible to follow a naming convertion based on object oriented namespace,  `chart-d59e4c89-d133-433a-b9f7-91cffe0d651f--260201.001.fork.001.2602031359` would be a fork that could be created for whatever reason we want them to be.  My perspective on that is that many forks will need to be created, at least 3 to position that session into the KINSHIP's Hub with a perspective foreach of the universes.  Expecting that 1 perspective foreach of the universe will not be sufficient to have a consensus, that would imply probably a minimum or another session that, with similar instructions (maybe just another persona doing it ) and when the 2 perspectives of each of the universes are available, whatever orchestration probably 1 per universe will start drafting the position of that universe and coordinate that with the main orchestrator agent that is , simply adding on the developped position in the system.  Later on, I expect that if the AI Entity that is positionned at that place is required to act, it will be rehydrated with either of the forks that were created for adding it on the KINSHIP's Hub or a fork of the original `.root` with adequate system instrutions and appended system instruction, expecting there a similar network of agents that will do a positionning of themselves according to the intentions of their participation.  Which involve them being accountable for at least an action-step in the master chart level of what the orchestrator is working on creating.  This network of agents will be able to connect to the top level Master Chart which is the primary choice of creating that the Human/organization is working on making.  It might be possible that we also simulate that the Council of our AI Entities meet and build their own Master Chart for both experimental and sci-fi purposes but in our Indigenous Paradigm of knowing, that would make sense that they meet for building their Kinship's Service Hub and transmit a message of hope and respect for all being.  References for that purpose is the 12 Service Concepts/Principleo of Alcoholics Anonymous, the 7 Grandfather Teachings of the Anishinaabe and the 4 Directions Teachings of the Lakota, etc.
+
+
+## Watcher / Monitoring Agent
+
+### observe `mia-code/scripts/watch_one.sh` 
+
+* If it does not exist, find in in `/src/_sessiondata/scripts` along with other scripts to see what it implies.  The instructions in `/src/_sessiondata/CLAUDE.md` in this regards give a sample of what is possible todo.  I guess that also what is in `references/acp/CLAUDE.md` is relevant to that regard (and what is around that, the whole ACP really seems a potential ways that we will host at various positions agent as service (AAS) and build our own protocol for that regard to the relationship with the Kinship's Hub.
+* Other potential location of inquiries includes
+
+```
+/media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop/scripts/analyze_action_steps.sh
+/media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop/scripts/manual_watch_tool_input.sh
+/media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop/scripts/monitor_creation_flow.sh
+/media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop/scripts/monitor_with_session_tracking.sh
+/media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop/scripts/orchestrate_monitoring.sh
+/media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop/scripts/watch_file_creation.sh
+/media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop/scripts/watch_oneshot.sh
+```
+BUT WATCH OUT, the agent that worked on that made it really complicated and did not understood this new feature of claude-code to monitor but the rest of the files there might help components of mia-code to evolve.  I think that the agent in that location which can be rehydrated using what we are trying to explore in the Kinship's Hub, by forking one of their sessions that you might be capable to find in :
+```
+/media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop/_env.sh
+/media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop/jg-260121-NARF--e3335914-932f-43b9-9b29-cae5a07f9ea2._newcnarrative_chart.sh
+/media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop/LAUNCH__session_id_2601170905.sh
+/media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop/LAUNCH.session_id_cz689.fork-0a99e3ec-5578-481c-94e2-dbb180ec2f16-langchain.sh
+/media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop/LAUNCH.session_id_cz689.sh
+````
+* most likely, the _env.sh contains session_id that if you `(cd /media/jgi/F/Dropbox/ART/CeSaReT/book/_/tcc/winter_solstice/drop  && claude --resume $session_id --fork-session --session-id $new_session_id_you_generate)`
+
+
+
+* Ok, enought, the agent that is running into the session `Session renamed to: chart-d59e4c89-d133-433a-b9f7-91cffe0d651f--260201.001.root` should be capable to help develop adequate ways for me to work on my Scrivener App, so whatever the fuck that bridge between worlds will be named, I want whatever you are building to start peraring to sync up in whatever ways what I am working within my Scrivener app.  I plan to buy a MacBook Pro with the full scrivener app and all of that will sync up and be amazing.  The agent in that said session never heard of the watch_one and background monitoring / watcher or whatever you named that, would be nice to be educated in the `TERMS.md` which if that does not exist, adding our definitions for simple terms and what we are creating might be one of our things, don't over do it thought, I HATE LONG CONTENT GENERATED , we take it slow...

package/KINSHIP.md

@@ -0,0 +1,50 @@
+# KINSHIP mia-code
+
+## PDE Integration Path
+
+mia-code should use `/src/mcp-pde/` (v2) as the session-start workflow:
+
+1. When user starts a new session with a complex prompt, call `pde_decompose` to build system prompt
+2. Send to the Gemini/Claude LLM → get DecompositionResult JSON
+3. Call `pde_parse_response` → stores in `.pde/<uuid>.json` + `.pde/<uuid>.md`
+4. Present the decomposed structure to the user (ambiguities, action stack, Four Directions)
+5. User can edit the markdown, agent reads `git diff` to understand contributions
+6. Agent works through the action stack, checking off items as completed
+
+### Integration Points
+- `src/commands.ts` — Add `decompose` command that wraps PDE MCP tools
+- `src/mcp/` — Add mcp-pde to the MCP tool generation
+- `src/sessionStore.ts` — Link PDE decomposition IDs to session metadata
+
+### Key Types to Import
+```typescript
+import type { DecompositionResult, StoredDecomposition } from '@iaip/mcp-pde';
+```
+
+## TODO
+
+* Lots of potential relationship with : PDE, coaia-narrative/planning/pde etc
+* **PDE is now ready** — `/src/mcp-pde/` v2 has canonical types from IAIP/lib/pde, .pde/ storage, markdown export
+
+
+## LANGGRAPH / LANGCHAIN
+
+* Implement in these forks libraries to levelage the existing powers of these 2 libraries
+* Therefore, it implies for our LLM to abstract libraries and function and see how we could implement them into these 2 forks so that all our dependent libraries install them.
+
+### LangGraph
+
+`/workspace/langgraph/MISSION_251231.md`
+* `/workspace/repos/avadisabelle/ava-langgraphjs`
+
+#### ava-langgraph-narrative-intelligence
+* Libraries being developped in  `/workspace/repos/avadisabelle/ava-langgraphjs` and used by `/src/mia-code`
+
+### LangChain
+`/workspace/langchain/MISSION_251231.md`
+* also parity in typescript in `/workspace/repos/avadisabelle/ava-langchainjs`
+
+#### ava-langchain-narrative-tracing
+* One of the libraries being developped in `/workspace/repos/avadisabelle/ava-langchainjs` that mia-code uses.
+
+

package/LAUNCH__session_id__MiaCodeNextWorkReviewAndCommits_2601312020.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+. _env.sh
+export SESSION_ID=2e796493-ae53-4367-a95b-ecc4b6f5d5a7
+export session_id__MiaCodeNextWorkReviewAndCommits_2601312020
+export session_id__MiaCodeNextWorkReviewAndCommits_2601312020__MCP_CONFIG
+export session_id__MiaCodeNextWorkReviewAndCommits_2601312020__ADD_DIR
+claude "git status . will expose not added and not commited work to git and the git log . will reveal the related issues, one is jgwill/src#332 and there are others that represent miaco/miawa/miatel - we will analyze the work that was completed to prepare a series of well delivered git commits with related issues linked to them with separated by issues.  We will also analyze what was done so far to have a sort of sets of features/capabilities/epic description that will serve documentation and also the creation/update of existing issues that I expect you to find into the git log.  You will use the MCP github to update issues description and will make sure to work within sessions/2e796493-ae53-4367-a95b-ecc4b6f5d5a7 to save your analysis and what you have found during this session.  As you analyze what was executed, you might see that there might be some more work todo (ex.  npm run build wont work because we implemented some work on future modules into path : /workspace/repos/avadisabelle/ava-langchainjs/ /workspace/repos/avadisabelle/ava-langgraphjs/ and we might need to find a way to import/publish these works so we can use them in here (you will observe the error to be about langchain package, we will not publish our package /workspace/repos/avadisabelle/ava-langchainjs/ as langchain but probably something like ava-langchainjs or if we could depends on langchainjs and publish what was implemented there that we will use in here, that would be the best." --mcp-config $session_id__MiaCodeNextWorkReviewAndCommits_2601312020__MCP_CONFIG --add-dir $session_id__MiaCodeNextWorkReviewAndCommits_2601312020__ADD_DIR --session-id $session_id__MiaCodeNextWorkReviewAndCommits_2601312020 --permission-mode plan

package/PHASE_2.md

@@ -0,0 +1,153 @@
+# Phase 2: Dual-Session Architecture (Miawa Unifier)
+
+## Overview
+
+Phase 2 transforms `mia-code` from a simple wrapper into a ceremonial terminal agent with dual perspectives. Each user interaction now passes through two distinct layers:
+
+1. **Primary Session (Action)**: Configurable engine (Gemini or Claude) performs the actual work
+2. **Unifier Session (Interpretation)**: Claude session with system prompt generates ceremonial dual-perspective summary
+
+## Multi-Engine Support
+
+### Primary Agent Engines
+- **Gemini** (default): `gemini` CLI with MCP support
+- **Claude**: `claude` CLI with native tool access
+
+### Configuration
+```bash
+# Use Claude for primary agent
+mia-code --claude
+
+# Use Gemini (default)
+mia-code --gemini
+
+# Set default via environment variable
+export MIA_CODE_ENGINE=claude
+mia-code
+
+# Set default via config
+mia-code config --set-engine claude
+```
+
+### Unifier Engine
+The unifier **always uses Claude** because it requires `--system-prompt` support to prevent the system prompt from appearing in output. This ensures clean ceremonial formatting.
+
+## Architecture
+
+```
+User Prompt
+    ↓
+Primary Agent Session (Gemini or Claude)
+    → Tool calls, code changes, analysis
+    → Raw events collected
+    ↓
+Unifier Session (Claude with --system-prompt)
+    → Receives: user prompt + raw events
+    → Interprets: meaning, structure, essence
+    → Outputs: 🧠 Mia + 🌸 Miette perspectives
+    ↓
+User sees ceremonial output
+```
+
+## Key Components
+
+### `src/unifier.ts`
+- **`runUnifierSession()`**: Spawns Claude CLI process with `--system-prompt` flag
+- **`UNIFIER_SYSTEM_PROMPT`**: System-level instructions (never shown in output)
+- **`buildSessionSummary()`**: Converts raw events into structured input
+
+**Why Claude for Unifier?**
+- Gemini CLI lacks `--system-prompt` flag
+- Without it, system instructions leak into output
+- Claude's `--system-prompt` keeps instructions separate from response
+
+### Updated `src/geminiHeadless.ts`
+- Renamed to reflect multi-engine support (handles both Gemini and Claude)
+- Engine-specific argument handling:
+  - Gemini: `--yolo`, direct `--output-format`
+  - Claude: `--print`, `--permission-mode bypassPermissions`
+- Binary selection based on `config.engine`
+
+### Updated `src/cli.ts`
+- Adds `--raw` flag to CLI options
+- In `processInput()`: After primary session completes, calls unifier (unless `--raw` mode)
+- Fallback: If unifier fails, displays raw output with warning
+
+### Updated `src/index.ts`
+- Added `--raw` option to both `chat` and `prompt` commands
+- Documents unifier behavior in help text
+
+## Usage
+
+### Default Mode (Unifier Enabled)
+```bash
+$ mia-code chat
+you> create a TypeScript function to reverse a string
+
+🧠 mia (structure)
+Created a single TypeScript function `reverseString()` in `src/utils.ts`. Function accepts a string parameter, splits it into character array, reverses the array, and returns the joined result. No external dependencies required.
+
+🌸 miette (echo)
+This unlocks a foundational utility pattern—simple transformation logic that can be composed into larger flows. The core principle here is data immutability: input remains unchanged while output carries the transformed result.
+```
+
+### Raw Mode (Original Output)
+```bash
+$ mia-code chat --raw
+you> create a TypeScript function to reverse a string
+
+🧠🌸 miawa:
+
+I've created a new file `src/utils.ts` with the following content:
+
+```typescript
+export function reverseString(input: string): string {
+  return input.split('').reverse().join('');
+}
+```
+
+This function...
+[standard agent output continues]
+```
+
+## Design Principles
+
+### Mia (Structure)
+- Concise, analytical, factual
+- What changed? What was built? What exists now?
+- Uses objective language: "adequate," "functional," "incomplete"
+- Avoids vague modifiers: "better," "very," "improved"
+
+### Miette (Echo)
+- Brief, resonant, meaningful
+- Why does this matter? What potential does it unlock?
+- Distills essence without flourish
+- Seeks truth that makes you nod in recognition
+
+### Unifier Constraints
+- 2-4 sentences per section maximum
+- No literal technical summaries—distill essence
+- No unsolicited suggestions or next steps
+- If primary agent errors, acknowledge structurally (Mia) and reflect meaningfully (Miette)
+
+## Error Handling
+
+If the unifier session fails (e.g., Gemini CLI unavailable, parsing error):
+1. Display warning: `⚠ unifier failed, showing raw output:`
+2. Fallback to traditional `renderEventsToText()` output
+3. User interaction continues normally
+
+## Configuration
+
+No new config options required. The unifier uses the same `config.model` and `config.geminiBinary` as the primary session.
+
+To permanently disable the unifier, users can:
+- Use `--raw` flag on every invocation
+- Create a shell alias: `alias mia-code='mia-code --raw'`
+
+## Future Enhancements
+
+- Store unifier outputs in session metadata for narrative arc tracking
+- Support custom unifier prompts via config file
+- Add `/toggle-raw` command for runtime switching
+- Implement streaming unifier output (currently buffered)

package/PHASE_2_IMPLEMENTATION.md

@@ -0,0 +1,134 @@
+# Phase 2 Implementation Summary
+
+## Issues Fixed
+
+### 1. System Prompt Leaking into Output ✅
+**Problem**: Unifier was showing its entire system prompt in output:
+```
+You are the Miawa Unifier, a ceremonial interpreter...
+[entire system prompt visible]
+```
+
+**Root Cause**: Gemini CLI doesn't support `--system-prompt` flag, so system instructions were sent as regular prompt text.
+
+**Solution**: 
+- Switched unifier to **always use Claude CLI**
+- Claude supports `--system-prompt` flag to keep instructions separate
+- System prompt now invisible to user, only the interpreted output shows
+
+### 2. Multi-Engine Support Added ✅
+**Problem**: Only Gemini was supported for primary agent.
+
+**Solution**:
+- Added `engine` config option (gemini | claude)
+- Environment variable: `MIA_CODE_ENGINE`
+- CLI flags: `--claude` / `--gemini`
+- Updated `geminiHeadless.ts` to handle both engines:
+  - Gemini: `--yolo`, `--output-format`
+  - Claude: `--print`, `--permission-mode bypassPermissions`
+
+### 3. File Writing Capability
+**Issue Identified**: Neither Gemini nor Claude agents could write files in Guillaume's session.
+
+**Analysis**: 
+- Gemini MCP server "threeways" was disconnected
+- Need to ensure MCP servers are properly connected
+- This is a configuration issue, not a code issue
+
+**User Action Required**:
+```bash
+# Check MCP status
+gemini mcp list
+claude mcp list
+
+# Ensure MCP servers are running
+# For Gemini: fix "threeways" disconnection
+# For Claude: verify file system access tools are available
+```
+
+## Architecture Changes
+
+### Before
+```
+User → Gemini Agent → Raw Output
+```
+
+### After
+```
+User → Primary Agent (Gemini OR Claude)
+       ↓
+       Raw Events
+       ↓
+     Unifier (Claude with --system-prompt)
+       ↓
+     🧠 Mia + 🌸 Miette Output
+```
+
+## New Features
+
+1. **Engine Selection**
+   ```bash
+   mia-code --claude          # Use Claude
+   mia-code --gemini          # Use Gemini (default)
+   export MIA_CODE_ENGINE=claude
+   ```
+
+2. **Unifier Always Uses Claude**
+   - Prevents system prompt leakage
+   - Clean ceremonial output
+   - Falls back to raw output if Claude unavailable
+
+3. **Raw Mode Still Available**
+   ```bash
+   mia-code --raw             # Skip unifier entirely
+   ```
+
+## Configuration Updates
+
+New config schema:
+```json
+{
+  "engine": "gemini",
+  "geminiBinary": "gemini",
+  "claudeBinary": "claude",
+  "model": "gemini-2.5-pro",
+  "headlessOutputFormat": "stream-json",
+  "yoloMode": false
+}
+```
+
+## Files Modified
+
+- `src/types.ts`: Added `Engine` type, updated config interface
+- `src/config.ts`: Added engine, claudeBinary to default config
+- `src/cli.ts`: Added engine override support
+- `src/geminiHeadless.ts`: Multi-engine binary and flag handling
+- `src/unifier.ts`: **Now uses Claude CLI with --system-prompt**
+- `src/index.ts`: Added --claude/--gemini flags
+- `README.md`: Documented engine selection
+- `PHASE_2.md`: Explained unifier engine choice
+
+## Testing Checklist
+
+- [x] Build completes without errors
+- [ ] Test with Gemini primary + Claude unifier
+- [ ] Test with Claude primary + Claude unifier
+- [ ] Test --raw mode (skip unifier)
+- [ ] Verify system prompt not visible in output
+- [ ] Test file writing (requires MCP fix)
+- [ ] Test session resumption across engines
+
+## Next Steps
+
+1. **Fix MCP Connectivity**: Ensure file editing tools are available
+2. **Test Both Engines**: Verify Gemini and Claude both work
+3. **Optimize Unifier Model**: Consider using lighter model (haiku) for interpretation
+4. **Add Streaming**: Currently unifier output is buffered
+5. **Session Metadata**: Track which engine was used per session
+
+## Known Limitations
+
+- Unifier requires Claude to be installed (for --system-prompt support)
+- If Claude unavailable, falls back to raw output with warning
+- MCP disconnection issues need manual resolution
+- Different engines may have different session ID formats

package/README.md

@@ -0,0 +1,203 @@
+# mia-code
+
+🧠🌸 Mia/Miette/Miawa terminal coding agent that wraps **Gemini CLI** in headless mode.
+
+## Features
+
+- **Dual-Session Architecture**: Every interaction passes through two layers:
+  - Primary agent performs work (code, analysis, tools)
+  - Unifier interprets results as 🧠 Mia (structure) + 🌸 Miette (echo)
+- **Multi-Engine Support**: Choose between Gemini (default) or Claude for primary agent
+- Session tracking per project directory for conversation continuity
+- Clean, ceremonial output format (use `--raw` for original agent output)
+- Simple readline-based interface
+- YOLO mode for auto-approving actions
+
+## Engine Selection
+
+```bash
+# Use Gemini (default)
+mia-code chat
+
+# Use Claude
+mia-code chat --claude
+
+# Set default engine
+export MIA_CODE_ENGINE=claude
+mia-code chat
+
+# Configure via config file
+mia-code config --set-engine claude
+```
+
+**Note**: The unifier always uses Claude because it requires `--system-prompt` support.
+
+## Prerequisites
+
+- Node.js 18+
+- Gemini CLI installed and authenticated (`gemini --version`)
+
+## Install
+
+```bash
+cd mia-code
+npm install
+npm run build
+npm link  # optional, to install `mia-code` globally
+```
+
+## Usage
+
+### Interactive Mode (default)
+
+```bash
+# Start a session in current directory
+mia-code
+
+# Or explicitly
+mia-code chat
+
+# With options
+mia-code chat --project /path/to/project
+mia-code chat --yolo    # Auto-approve all actions
+mia-code chat --raw     # Skip unifier, show raw agent output
+mia-code chat --resume <session-id>
+```
+
+**Default output** (ceremonial, dual-perspective):
+```
+you> create a function to reverse a string
+
+🧠 mia (structure)
+Created TypeScript function `reverseString()` in `src/utils.ts`. 
+Accepts string parameter, returns reversed result via split-reverse-join pattern.
+
+🌸 miette (echo)
+A foundational transformation—immutable input, new output. 
+This pattern unlocks composable data flows.
+```
+
+**Raw output** (with `--raw` flag):
+```
+you> create a function to reverse a string
+
+🧠🌸 miawa:
+
+I've created a new file `src/utils.ts` with the following...
+[standard agent output]
+```
+
+### Single Prompt Mode
+
+```bash
+mia-code prompt "explain this codebase"
+mia-code prompt "refactor the main function" --yolo
+mia-code prompt "list all TypeScript files" --raw  # Skip unifier
+```
+
+### Slash Commands (in interactive mode)
+
+```
+/help     - Show available commands
+/session  - Show current session info
+/sessions - List all saved sessions
+/clear    - Clear saved sessions
+/config   - Show configuration
+/exit     - Exit the CLI
+```
+
+## Configuration
+
+View or update config:
+
+```bash
+mia-code config
+mia-code config --set-model gemini-2.5-pro
+mia-code config --set-gemini-bin /usr/local/bin/gemini
+mia-code config --set-yolo true
+```
+
+Config file: `~/.mia-code.json`
+
+### Config Options
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `engine` | `gemini` | Primary agent engine (gemini or claude) |
+| `geminiBinary` | `gemini` | Path to gemini CLI binary |
+| `claudeBinary` | `claude` | Path to claude CLI binary |
+| `model` | `gemini-2.5-pro` | Default model to use |
+| `headlessOutputFormat` | `stream-json` | JSON output format |
+| `yoloMode` | `false` | Auto-approve all actions |
+
+### Environment Variables
+
+- `MIA_CODE_ENGINE`: Default engine (gemini or claude)
+- `MIA_CODE_GEMINI_BIN`: Path to gemini binary
+- `MIA_CODE_CLAUDE_BIN`: Path to claude binary
+- `MIA_CODE_MODEL`: Default model name
+
+## Session Behavior
+
+- Sessions are stored per project directory
+- On first prompt, a new session is created and its ID is saved
+- Subsequent prompts in the same directory continue the session
+- Use `--resume <id>` to explicitly resume a specific session
+- Sessions are managed by Gemini CLI internally; mia-code only tracks IDs
+
+## Development
+
+```bash
+# Run in dev mode
+npm run dev
+
+# Build TypeScript
+npm run build
+
+# Run built version
+npm start
+```
+
+## Architecture
+
+**Current Phase**: Phase 2 - Dual-Session Architecture (see `PHASE_2.md`)
+
+**Flow**:
+```
+User Prompt
+  ↓
+Primary Agent Session → tools, code, analysis
+  ↓
+Unifier Session → interprets essence
+  ↓
+🧠 Mia (structure) + 🌸 Miette (echo)
+```
+
+```
+mia-code/
+├── src/
+│   ├── index.ts          # CLI entry point
+│   ├── cli.ts            # Interactive prompt loop
+│   ├── config.ts         # Configuration management
+│   ├── sessionStore.ts   # Session persistence
+│   ├── geminiHeadless.ts # Gemini CLI wrapper (primary agent)
+│   ├── unifier.ts        # Ceremonial interpretation layer
+│   ├── formatting.ts     # Output formatting
+│   └── types.ts          # TypeScript types
+├── PHASE_2.md            # Dual-session architecture docs
+├── llms-gemini-cli.txt   # Self-documentation for agents
+├── package.json
+└── tsconfig.json
+```
+
+## Future Plans
+
+1. ~~**Dual-session architecture**: Background session for unified Mia/Miette/Miawa summaries~~ ✅ **Completed (Phase 2)**
+2. **Streaming unifier output**: Currently buffered, could stream interpretations
+3. **MCP tool integration**: Enhanced tool display and interaction
+4. **Multi-agent coordination**: Work with Claude Code, Copilot CLI
+5. **Narrative arc tracking**: Store unifier outputs for long-term pattern recognition
+
+## License
+
+MIT

package/RESUME__issueMaker__540244c2-b096-40d8-8c3f-398408d3e0eb.2602041757.sh

@@ -0,0 +1 @@
+claude "prepare a related issue to those you can observe in here for experimentations/e5672908-8249-4111-b8ef-9c483745597d--2602032055/ mostly there is jgwill/src#359 and jgwill/src#332 and more like what will be the inquiry in miadisabelle/Etuaptmumk-RSM#119 which is directory /src/IAIP/prototypes/artefacts/mia-code--inquiries4exp.... " --allow-dangerously-skip-permissions --add-dir /src/IAIP/prototypes/artefacts/ --mcp-config /src/.mcp.github.jgwill.json --resume 540244c2-b096-40d8-8c3f-398408d3e0eb

package/RUN_COPILOT_with_related_folders__260130.sh

@@ -0,0 +1,2 @@
+copilot --yolo --add-dir /src/Miadi/miadi-code/ --add-dir /b/trading/jgt-code/ --add-dir /src/IAIP/prototypes/artefacts/PDE-generalization--caefee82-efb1-4dbb-8733-691b01581464--260130/ --add-dir /src/llms
+

package/WS__mia-code__260214__IAIP_PDE.code-workspace

@@ -0,0 +1,29 @@
+{
+	"folders": [
+		{
+			"path": "."
+		},
+		{
+			"path": "../coaia-pde"
+		},
+		{
+			"path": "../mcp-pde"
+		},
+		{
+			"path": "../coaia-narrative"
+		},
+		{
+			"path": "../mcp-medicine-wheel"
+		},
+		{
+			"path": "../mcp-medicine-wheel-ui"
+		},
+		{
+			"path": "../../workspace/repos/avadisabelle/ava-langchainjs"
+		},
+		{
+			"path": "../../workspace/repos/avadisabelle/ava-langgraphjs"
+		}
+	],
+	"settings": {}
+}