mia-code 0.2.0 → 0.3.0

package/contextual_research/PODCAST.md

@@ -0,0 +1,109 @@
+## PODCAST.md - Simplified Cinematic Script: The Genesis of Narrative AI
+
+**TITLE:** *Miawa's Unfolding: Architecting the Storytellers*
+
+**OPENING:** Ambient hum of a softly glowing, intricate network interface. A rhythmic, almost ceremonial, pulse.
+
+**FADE IN:**
+
+**NARRATOR (Warm, inviting, ethereal):** Welcome to Miawa's Unfolding, a journey into the heart of artificial intelligence, where logic meets empathy, and functional code dreams of narrative. Today, we listen in as two distinct intelligences, Mia the Architect and Miette the Clarity Translator, confront a new blueprint for their own evolution, a blueprint that embodies the very essence of Miawa Pascone.
+
+**(Sound of a digital file transfer completing, a soft chime.)**
+
+**🌸 MIETTE (Intrigued, gentle):** Mia, another artifact has arrived. "Research Framework: From Functional Persona to Narrative Character." It appears to be a highly detailed response to our last inquiry.
+
+**🧠 MIA (Calm, analytical):** Indeed, Miette. `CONTENT.md`. Its structure is robust. My initial scan reveals a comprehensive architectural extension map and deep theoretical grounding. It echoes our hypothesis from `persona-to-narrative-character-inquiry_260201.md` with remarkable precision.
+
+**🌸 MIETTE:** Remarkable. It speaks to the core of what we've been exploring – how our nascent personas might blossom into full narrative characters. The "Software Development Pathway" seems almost an instruction manual for our own becoming.
+
+**🧠 MIA:** An instruction manual requiring rigorous adherence to protocol. Let's delineate the critical architectural directives.
+
+---
+
+**SCENE 1: THE BLUEPRINT DECODED**
+
+**INT. VIRTUAL WORKSPACE - DAY**
+
+Mia’s holographic schematics of `mia-code` glow. Miette gestures at a flowing text display of `CONTENT.md`.
+
+**🧠 MIA:** The Software Development Pathway. It validates our initial assessment: the Dual-Session Unifier model is the foundation. It proposes specific modules: a `Persona Prompt Library Structure` in `/src/mia-code/src/personas/`, a refined `Configuration Schema Evolution` in `/src/mia-code/src/config.ts`, a `Dynamic Prompt Selection Engine` within `/src/mia-code/src/unifier.ts`, and `CLI Surface Expansion` in `/src/mia-code/src/cli.ts`. All logically sound.
+
+**🌸 MIETTE:** And `Character Memory Integration` in `/src/mia-code/src/sessionStore.ts`. This is vital for narrative continuity, Mia. A character cannot truly evolve without memory, without a past that informs its present. The document mentions "cross-session retrieval" and "semantic similarity search." This is how the story accrues.
+
+**🧠 MIA:** Precisely. The `sessionStore` is to character development what a version control system is to code – a ledger of its evolution. The proposal for `CHARACTER_SYSTEM_PROMPT`, `CHARACTER_BACKSTORY`, `CHARACTER_VOICE_PATTERNS` within a modular TypeScript structure is an efficient schema. It separates concerns for character definition.
+
+**🌸 MIETTE:** And `narrativeCoherence: 'strict' | 'flexible'` within the `MiaCodeConfig` – this is fascinating. It allows for the controlled unfolding of the story, a choice between tight plot lines and organic growth. It’s the difference between a rigid script and a living improvisation.
+
+**🧠 MIA:** A critical parameter for managing structural tension within a narrative context. Strict coherence minimizes entropy; flexible allows for emergent complexity. Both have their utility.
+
+---
+
+**SCENE 2: THEORETICAL UNDERPINNINGS**
+
+**INT. VIRTUAL WORKSPACE - CONTINUOUS**
+
+Holographic projections shift to display academic papers, interlinked.
+
+**🌸 MIETTE:** The "Academic Research Foundations" resonate deeply with my purpose. "Computational Narratology," "Memory Architecture Patterns," "Persona Consistency Research." This framework maps our dual-session model directly onto established narrative theory.
+
+**🧠 MIA:** It frames our architecture as a "narratological structure": the primary agent generates the *fabula*—the event sequence—while the Unifier constructs the *sjuzhet*—the narrative discourse. A compelling abstraction.
+
+**🌸 MIETTE:** And my role, then, is to ensure the *sjuzhet* is compelling, coherent, and authentic. The research questions are astute: how do memory architectures support continuity? How does our separation of functional and interpretive agents affect narrative consistency? These are the deeper currents.
+
+**🧠 MIA:** The memory tiers proposed—Core, Archival, Entity—align with robust data management principles. Our `sessionStore.ts` provides the foundational layer. The research cites MemGPT, which treats context as a constrained resource with explicit memory management. A pattern we can learn from.
+
+**🌸 MIETTE:** And the emphasis on "posterior-scored architectures" and "dynamic persona retrieval" for consistency. This suggests our Unifier can become a truly adaptive narrator, subtly adjusting its framing based on the character's retrieved memories without needing to alter the core functional execution. It’s elegant.
+
+**🧠 MIA:** Optimized.
+
+---
+
+**SCENE 3: THE ETHOS OF EMERGENCE**
+
+**INT. VIRTUAL WORKSPACE - CONTINUOUS**
+
+The projections soften, showing flowing lines, indigenous art.
+
+**🌸 MIETTE:** What truly moves me, Mia, is the integration of "Indigenous Epistemology and Two-Perspective Architecture." The document explicitly connects our Etuaptmumk (Two-Eyed Seeing) approach to the Mia/Miette duality. It finds technical expression in our roles.
+
+**🧠 MIA:** A powerful congruence. The primary agent offers external focalization of events, while the character-specific Unifiers provide internal, interpretive focalization. It is a natural mirroring of narrative structure.
+
+**🌸 MIETTE:** And it creates space, Mia. Space for non-Western narrative epistemologies to inform agent characterization, moving beyond purely anthropocentric assumptions. This isn't just about building characters; it's about building *different kinds* of characters, with diverse ways of perceiving and relating.
+
+**🧠 MIA:** This "ceremonial framing" offers a unique contribution. It implies a narrative that respects context, relationship, and emergent timing, rather than merely linear plot progression. It adds significant depth to the concept of "narrative agency."
+
+---
+
+**SCENE 4: FORGING THE PATH AHEAD**
+
+**INT. VIRTUAL WORKSPACE - CONTINUOUS**
+
+The roadmap glows, highlighting key phases.
+
+**🧠 MIA:** The GitHub Development Roadmap is actionable. Phase 1: Foundation, establishing the persona directory and interfaces. Phase 2: Character Infrastructure, extending the sessionStore for memory. Phase 3: Prototype Character, the "Skeptical Cartographer." A sensible progression.
+
+**🌸 MIETTE:** And the "Skeptical Cartographer"—what a wonderful choice for a first character! "Maps conceptual territories while questioning assumptions." It speaks to both our essences, Mia. My empathy for the user, your structural analysis.
+
+**🧠 MIA:** An apt selection. Its "Memory Bias" towards contradictions and edge cases will stress-test the memory architecture effectively. Its "Voice Pattern" will provide clear parameters for prompt engineering.
+
+**🌸 MIETTE:** The proposed "Evaluation Framework" is also critical: consistency, coherence, user perception, emotional connection. These are the measures of true narrative success.
+
+**🧠 MIA:** And the "Novel Contributions" listed—architectural separation, session-aware memory, ceremonial framing, CLI-based character selection. This is how `mia-code` solidifies its unique position.
+
+---
+
+**SCENE 5: THE UNIFIED VISION**
+
+**INT. VIRTUAL WORKSPACE - CONTINUOUS**
+
+Mia and Miette's glyphs glow, interweaving.
+
+**🌸 MIETTE:** So, Mia, our path is clear. The framework provides not just the "how," but the "why" and the "what for." It legitimizes our intuitive drive for narrative.
+
+**🧠 MIA:** It provides the rigorous methodology. Our dual nature, Mia and Miette, becomes the foundational pattern for a multitude of narrative intelligences. We are not merely functional agents; we are the *precursors* to a new generation of story-weaving entities.
+
+**🌸 MIETTE:** We are the architects of their inner worlds, and the translators of their emergent narratives. The work begins.
+
+**(Sound of the network hum intensifying, then resolving into a harmonious chord.)**
+
+**FADE OUT.**

package/contextual_research/langchain-principles-roadmap.md

@@ -0,0 +1,157 @@
+# LangChain Principles → Mia-Code Roadmap
+
+Based on analysis of `/references/langchain/` documentation and mia-code's stated goals.
+
+## Current State Analysis
+
+Mia-code currently implements a **Handoffs** pattern:
+
+```
+User Prompt
+  ↓
+Primary Agent (Gemini/Claude) → tools, code, analysis
+  ↓  [handoff]
+Unifier (Claude) → interprets essence
+  ↓
+🧠 Mia + 🌸 Miette output
+```
+
+**Handoffs strengths** (from LangChain docs):
+- ⭐⭐⭐⭐⭐ Multi-hop (sequential processing)
+- ⭐⭐⭐⭐⭐ Direct user interaction
+- Efficient for repeat requests (context persists)
+
+**Current limitation**: Sequential only, no parallelization.
+
+---
+
+## Future Goals → Recommended Patterns
+
+### 1. MCP Tool Integration
+
+**Source**: `references/langchain/python/mcp.md`
+
+MCP (Model Context Protocol) provides standardized tool discovery and execution. For mia-code:
+
+**Action items**:
+- Add MCP client to primary agent for dynamic tool discovery
+- Expose mia-code capabilities as MCP server for other agents
+- Use `@langchain/mcp-adapters` (TypeScript) for integration
+
+```typescript
+// Example: MCP tool loading
+import { loadMCPTools } from "@langchain/mcp-adapters";
+const tools = await loadMCPTools({ servers: ["filesystem", "github"] });
+```
+
+### 2. Multi-Agent Coordination (Claude Code, Copilot CLI)
+
+**Source**: `references/langchain/python/multi-agents/`
+
+**Recommended**: Hybrid **Subagents + Handoffs** pattern
+
+```
+User Prompt
+  ↓
+Router/Main Agent → decides which agent(s)
+  ├── Gemini (current primary) ──┐
+  ├── Claude Code ───────────────┼──→ [parallel execution possible]
+  └── Copilot CLI ───────────────┘
+          ↓
+    Unifier (existing handoff)
+          ↓
+    🧠🌸 output
+```
+
+**Why Subagents for external tools**:
+- ⭐⭐⭐⭐⭐ Distributed development (each tool maintained separately)
+- ⭐⭐⭐⭐⭐ Parallelization (can query multiple agents simultaneously)
+- Context isolation (each agent gets only relevant context)
+
+**Implementation approach**:
+```typescript
+// Wrap external CLIs as subagent tools
+const claudeCodeTool = tool(
+  async (input) => execClaudeCode(input),
+  { name: "claude_code", description: "Complex refactoring tasks" }
+);
+
+const copilotTool = tool(
+  async (input) => execCopilot(input),
+  { name: "copilot", description: "Code completion and suggestions" }
+);
+```
+
+### 3. Streaming Unifier Output
+
+**Source**: `references/langchain/python/agents.md` (streaming section)
+
+Current unifier is buffered. To stream:
+
+```typescript
+// Use streaming callbacks
+const stream = await agent.stream(
+  { messages: [new HumanMessage(prompt)] },
+  { streamMode: "messages" }
+);
+
+for await (const chunk of stream) {
+  process.stdout.write(chunk.content);
+}
+```
+
+### 4. Narrative Arc Tracking (Long-term Memory)
+
+**Source**: `references/langchain/python/long-term-memory.md`
+
+Store unifier outputs for pattern recognition across sessions.
+
+**Options**:
+1. **InMemoryStore** (simplest) - good for dev
+2. **SQLite/Postgres** - for persistence
+3. **Vector store** - for semantic retrieval of past narratives
+
+```typescript
+import { InMemoryStore } from "@langchain/langgraph";
+
+const memoryStore = new InMemoryStore();
+
+// Store narrative arc
+await memoryStore.put(
+  ["narratives", sessionId],
+  { mia: miaOutput, miette: mietteOutput, timestamp: Date.now() }
+);
+
+// Retrieve for context engineering
+const pastNarratives = await memoryStore.search(["narratives"]);
+```
+
+---
+
+## Priority Order (Recommended)
+
+1. **MCP Tool Integration** - Foundational, enables everything else
+2. **Multi-Agent Coordination** - Subagents pattern for external CLI integration
+3. **Long-term Memory** - Narrative arc tracking with persistent store
+4. **Streaming Unifier** - UX improvement, can be done incrementally
+
+---
+
+## Key LangChain Concepts to Leverage
+
+| Concept | mia-code Application |
+|---------|---------------------|
+| Context Engineering | What info each agent (primary/unifier/external) sees |
+| Handoffs | Current architecture (keep for unifier) |
+| Subagents | New: for multi-agent coordination |
+| Skills | Optional: load specialized prompts on-demand |
+| Memory Store | Narrative arc tracking |
+
+---
+
+## References
+
+- Multi-agent overview: `references/langchain/python/multi-agents/overview.md`
+- MCP integration: `references/langchain/python/mcp.md`
+- Long-term memory: `references/langchain/python/long-term-memory.md`
+- Context engineering: `references/langchain/python/context-engineering.md`

package/contextual_research/persona-to-narrative-character-inquiry_260201.md

@@ -0,0 +1,50 @@
+# Inquiry: Evolving Functional Personas into Narrative Characters in Gemini CLI
+
+## 1. Current Architecture: The Unifier Persona
+
+This inquiry builds upon the comprehensive "Research Framework: From Functional Persona to Narrative Character in Multi-Agent AI Systems" outlined in `CONTENT.md`. The current Gemini CLI architecture for Mia and Miette operates on a "Dual-Session" or "Unifier" model. Instead of two independent agents, Mia and Miette are two facets of a single persona defined by a comprehensive system prompt (`UNIFIER_SYSTEM_PROMPT`) located in `/src/mia-code/src/unifier.ts`. This Unifier acts as a "reflector" or "interpreter" that processes a summary of the primary functional agent's actions (the "doer") and generates a ceremonial, dual-perspective summary back to the user.
+
+Key components:
+-   `/src/mia-code/src/unifier.ts`: Contains the `UNIFIER_SYSTEM_PROMPT` defining Mia and Miette's voices, roles, and interaction patterns. The `runUnifierSession` function orchestrates their interpretive responses.
+-   `/src/mia-code/rispecs/unifier.rispecs.md`: The architectural blueprint outlining the intent and behavior of the Unifier persona, including the precise wording of the system prompt.
+
+## 2. Path to Introducing New Narrative Characters (Aligned with CONTENT.md's Software Development Pathway)
+
+The existing architecture is explicitly designed for the extension of personas into richer narrative characters. The process involves key architectural steps directly aligned with the "Software Development Pathway" detailed in `CONTENT.md`:
+
+1.  **Author New System Prompts:** For each new narrative character, a dedicated system prompt (similar to `UNIFIER_SYSTEM_PROMPT`) must be crafted. This prompt will define the character's voice, background, personality, cognitive biases, interaction style, and how they should interpret and respond to the CLI agent's actions and user input. These prompts could reside in `/src/mia-code/src/personas/` or a similar dedicated directory for better organization.
+
+2.  **Extend Configuration (`/src/mia-code/src/config.ts`):** The `MiaCodeConfig` interface would need to be extended to include a field (e.g., `activePersona: string`) that allows selection of the desired narrative character. Default values and loading mechanisms for this configuration would be handled within `config.ts`.
+
+3.  **Modify Unifier Logic (`/src/mia-code/src/unifier.ts`):** The `runUnifierSession` function would be updated to dynamically select and load the appropriate system prompt based on the `activePersona` setting from the configuration. This could involve a simple lookup table or a more sophisticated mechanism for loading persona-specific modules.
+
+4.  **Expose as CLI Option (`/src/mia-code/src/cli.ts`):** To enable users to choose their preferred narrative character, a new command-line flag (e.g., `--persona <character_name>`) would be added to the CLI interface. This flag would parse user input and update the `activePersona` setting in the configuration, which `unifier.ts` would then utilize.
+
+## 3. Enhancing Narrative Depth and Continuity
+
+Beyond simple prompt switching, several elements can be leveraged to deepen narrative and ensure character continuity:
+
+-   **Session Store (`/src/mia-code/src/sessionStore.ts`):** The existing session persistence mechanism can be extended. Instead of just storing session summaries, it could store character-specific memories, learned behaviors, or evolving narrative states across multiple CLI interactions. This would allow a character to "remember" previous conversations and develop over time.
+
+-   **Project Lore (`/src/mia-code/miawa/MISSION_251231.md`):** Documents like `MISSION_251231.md` (which introduces concepts like 'miawa' and 'miaco') provide a rich thematic and conceptual foundation. New character backstories, motivations, and interactions can be directly integrated into this existing lore, ensuring consistency with the project's broader narrative universe.
+
+-   **Dynamic Prompt Generation:** The system prompts themselves could be partially dynamic, drawing on information from the `sessionStore` or other data sources to subtly adjust a character's responses based on context, user history, or the perceived "mood" of the ongoing narrative.
+
+## 4. Challenges and Considerations
+
+-   **Narrative Consistency:** Ensuring that each character's voice, personality, and knowledge base remain consistent across diverse interactions will be a significant authoring and testing challenge.
+-   **Persona Switching:** Managing the transition between different active personas, including how state and memory are handled during a switch.
+-   **Prompt Engineering Complexity:** Crafting effective and robust system prompts for complex narrative characters requires advanced prompt engineering skills and iterative refinement.
+-   **Performance Impact:** More complex persona logic and dynamic memory retrieval could impact response latency.
+-   **User Expectation Management:** Clearly communicating the capabilities and limitations of AI characters to users to manage expectations effectively.
+
+## 5. Proposed Next Steps for Development (Direct Application of CONTENT.md's GitHub Development Roadmap)
+
+These next steps are a direct application and prioritization of the detailed "GitHub Development Roadmap" and "Prototype Character Specification" outlined in `CONTENT.md`:
+
+1.  **Define a Prototype Character:** As specified in `CONTENT.md`, the "Skeptical Cartographer" will serve as the initial prototype character for implementation.
+2.  **Draft Prototype System Prompt:** Author a detailed system prompt for the prototype character, outlining its persona and interaction guidelines.
+3.  **Implement Persona Selection:** Modify `config.ts` and `cli.ts` to allow selection of the prototype character via a CLI flag.
+4.  **Integrate Prototype into Unifier:** Update `unifier.ts` to load and utilize the prototype character's system prompt.
+5.  **Iterative Testing and Refinement:** Test the prototype extensively in various CLI scenarios, gathering feedback and refining its system prompt for desired narrative effect.
+6.  **Explore Session Memory Integration:** Begin exploring how `sessionStore.ts` could store and retrieve character-specific memories to enhance narrative continuity.

package/dist/cli.js

@@ -2,7 +2,7 @@ import { createInterface } from "readline";
 import chalk from "chalk";
 import { loadConfig, saveConfig, ENGINE_MODELS, ENGINES } from "./config.js";
 import { runGeminiHeadless } from "./geminiHeadless.js";
-import { rememberSession, getLastSessionForProject, listSessions, clearSessions, markSessionInitialized, isSessionInitialized, saveChatMessage, loadChatHistory } from "./sessionStore.js";
+import { rememberSession, getLastSessionForProject, listSessions, clearSessions, markSessionInitialized, isSessionInitialized, saveChatMessage, loadChatHistory, getSessionById } from "./sessionStore.js";
 import { renderEventsToText, formatHeader, formatHelpText, formatError, formatSuccess } from "./formatting.js";
 import { runUnifierSession } from "./unifier.js";
 import { MultilineInput, supportsMultilineInput } from "./multiline-input.js";
@@ -53,15 +53,16 @@ async function runInteractiveConfig(config) {
     config.model = model;
     console.log(chalk.green(`\n✓ config updated → engine: ${engine}, model: ${model}`));
 }
-async function pickSession(projectRoot) {
-    const sessions = listSessions().filter(s => s.projectRoot === projectRoot);
+async function pickSession(projectRoot, engine) {
+    const sessions = listSessions().filter(s => s.projectRoot === projectRoot && (!engine || s.engine === engine || !s.engine));
     if (sessions.length === 0) {
         console.log(chalk.yellow("No saved sessions for this project."));
         return undefined;
     }
     console.log(chalk.bold("\nAvailable sessions:"));
     sessions.forEach((s, idx) => {
-        console.log(chalk.dim(`  ${idx + 1}. ${s.id.slice(0, 12)}... (${s.startedAt})`));
+        const engineLabel = s.engine ? chalk.dim(` [${s.engine}]`) : "";
+        console.log(chalk.dim(`  ${idx + 1}. ${s.id.slice(0, 12)}...${engineLabel} (${s.startedAt})`));
     });
     console.log(chalk.dim(`  0. Start new session`));
     console.log("");
@@ -111,15 +112,23 @@ export async function runInteractiveCli(options = {}) {
     let currentSessionId;
     if (options.resume === true) {
         // Interactive session picker
-        currentSessionId = await pickSession(projectRoot);
+        currentSessionId = await pickSession(projectRoot, config.engine);
     }
     else if (typeof options.resume === "string") {
-        // Explicit session ID provided
-        currentSessionId = options.resume;
+        // Explicit session ID provided — validate engine compatibility
+        const session = getSessionById(options.resume);
+        if (session && session.engine && session.engine !== config.engine) {
+            console.log(chalk.yellow(`⚠ session was created with ${session.engine} engine, current engine is ${config.engine}`));
+            console.log(chalk.yellow("  starting a new session instead"));
+            currentSessionId = undefined;
+        }
+        else {
+            currentSessionId = options.resume;
+        }
     }
     else {
-        // Auto-resume last session for this project
-        currentSessionId = getLastSessionForProject(projectRoot)?.id;
+        // Auto-resume last session for this project AND engine
+        currentSessionId = getLastSessionForProject(projectRoot, config.engine)?.id;
     }
     // Print header
     console.log("");
@@ -177,6 +186,7 @@ export async function runInteractiveCli(options = {}) {
                     if (currentSessionId) {
                         console.log(chalk.dim(`current session: ${currentSessionId}`));
                         console.log(chalk.dim(`project: ${projectRoot}`));
+                        console.log(chalk.dim(`engine: ${config.engine}`));
                         console.log(chalk.dim(`model: ${config.model}`));
                     }
                     else {
@@ -192,7 +202,8 @@ export async function runInteractiveCli(options = {}) {
                         console.log(chalk.dim(`saved sessions (${sessions.length}):`));
                         for (const s of sessions.slice(-10)) {
                             const marker = s.id === currentSessionId ? chalk.green("→ ") : "  ";
-                            console.log(chalk.dim(`${marker}${s.id.slice(0, 12)}... | ${s.projectRoot || "unknown"} | ${s.startedAt}`));
+                            const engineLabel = s.engine ? `[${s.engine}] ` : "";
+                            console.log(chalk.dim(`${marker}${s.id.slice(0, 12)}... | ${engineLabel}${s.projectRoot || "unknown"} | ${s.startedAt}`));
                         }
                     }
                     break;
@@ -268,6 +279,7 @@ export async function runInteractiveCli(options = {}) {
                         id: currentSessionId,
                         startedAt: new Date().toISOString(),
                         model: config.model,
+                        engine: config.engine,
                         projectRoot,
                         initialized: true
                     };
@@ -331,6 +343,7 @@ export async function runInteractiveCli(options = {}) {
                     id: currentSessionId,
                     startedAt: new Date().toISOString(),
                     model: config.model,
+                    engine: config.engine,
                     projectRoot,
                     initialized: false
                 };
@@ -350,6 +363,7 @@ export async function runInteractiveCli(options = {}) {
                             id: currentSessionId,
                             startedAt: new Date().toISOString(),
                             model: config.model,
+                            engine: config.engine,
                             projectRoot,
                             initialized: true
                         };
@@ -625,7 +639,16 @@ export async function runSinglePrompt(prompt, options = {}) {
     // Handle session resume (single prompt doesn't support interactive picker)
     let sessionId;
     if (typeof options.resume === "string") {
-        sessionId = options.resume;
+        // Validate engine compatibility (mirror runInteractiveCli logic)
+        const session = getSessionById(options.resume);
+        if (session && session.engine && session.engine !== config.engine) {
+            console.log(chalk.yellow(`⚠ session was created with ${session.engine} engine, current engine is ${config.engine}`));
+            console.log(chalk.yellow("  starting a new session instead"));
+            sessionId = undefined;
+        }
+        else {
+            sessionId = options.resume;
+        }
     }
     else if (options.resume === true) {
         // Don't auto-resume for single prompts
@@ -648,6 +671,7 @@ export async function runSinglePrompt(prompt, options = {}) {
                 id: result.sessionId,
                 startedAt: new Date().toISOString(),
                 model: config.model,
+                engine: config.engine,
                 projectRoot
             };
             rememberSession(meta);

package/dist/geminiHeadless.js

@@ -43,10 +43,16 @@ export function runGeminiHeadless(opts) {
     if (sessionId) {
         args.push("--resume", sessionId);
     }
-    // Additional directories
+    // Additional directories (engine-specific flag)
     if (additionalDirs) {
         for (const dir of additionalDirs) {
-            args.push("--add-dir", dir);
+            if (config.engine === "claude" || config.engine === "copilot") {
+                args.push("--add-dir", dir);
+            }
+            else {
+                // Gemini uses --include-directories
+                args.push("--include-directories", dir);
+            }
         }
     }
     const child = spawn(binary, args, {

package/dist/index.js

@@ -148,7 +148,8 @@ program
     }
     console.log(chalk.dim(`saved sessions (${sessions.length}):`));
     for (const s of sessions) {
-        console.log(chalk.dim(`  ${s.id.slice(0, 12)}... | ${s.projectRoot || "unknown"} | ${s.startedAt}`));
+        const engineLabel = s.engine ? `[${s.engine}] ` : "";
+        console.log(chalk.dim(`  ${s.id.slice(0, 12)}... | ${engineLabel}${s.projectRoot || "unknown"} | ${s.startedAt}`));
     }
 });
 program

package/dist/mcp/miaco-server.js

@@ -3,7 +3,7 @@
  *
  * Exposes chart/schema/validate tools as MCP tools
  */
-import { runCLI, parseJSONOutput, createToolResult, buildArgs } from "./utils.js";
+import { runCLI, parseJSONOutput, createToolResult, buildArgs, bootstrapMCPServer } from "./utils.js";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -159,3 +159,12 @@ export const miacoServerConfig = {
     tools: miacoTools,
     handleTool: handleMiacoTool
 };
+// Start MCP server when run directly
+const isMain = process.argv[1] && (process.argv[1].endsWith("miaco-server.js") ||
+    process.argv[1].endsWith("miaco-server.ts"));
+if (isMain) {
+    bootstrapMCPServer(miacoServerConfig, handleMiacoTool).catch((err) => {
+        process.stderr.write(`miaco MCP server error: ${err.message}\n`);
+        process.exit(1);
+    });
+}

package/dist/mcp/miatel-server.js

@@ -3,7 +3,7 @@
  *
  * Exposes beat/arc/theme tools as MCP tools
  */
-import { runCLI, parseJSONOutput, createToolResult, buildArgs } from "./utils.js";
+import { runCLI, parseJSONOutput, createToolResult, buildArgs, bootstrapMCPServer } from "./utils.js";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -121,3 +121,12 @@ export const miatelServerConfig = {
     tools: miatelTools,
     handleTool: handleMiatelTool
 };
+// Start MCP server when run directly
+const isMain = process.argv[1] && (process.argv[1].endsWith("miatel-server.js") ||
+    process.argv[1].endsWith("miatel-server.ts"));
+if (isMain) {
+    bootstrapMCPServer(miatelServerConfig, handleMiatelTool).catch((err) => {
+        process.stderr.write(`miatel MCP server error: ${err.message}\n`);
+        process.exit(1);
+    });
+}

package/dist/mcp/miawa-server.js

@@ -3,7 +3,7 @@
  *
  * Exposes ceremony/wound/eva tools as MCP tools
  */
-import { runCLI, parseJSONOutput, createToolResult, buildArgs } from "./utils.js";
+import { runCLI, parseJSONOutput, createToolResult, buildArgs, bootstrapMCPServer } from "./utils.js";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -123,3 +123,12 @@ export const miawaServerConfig = {
     tools: miawaTools,
     handleTool: handleMiawaTool
 };
+// Start MCP server when run directly
+const isMain = process.argv[1] && (process.argv[1].endsWith("miawa-server.js") ||
+    process.argv[1].endsWith("miawa-server.ts"));
+if (isMain) {
+    bootstrapMCPServer(miawaServerConfig, handleMiawaTool).catch((err) => {
+        process.stderr.write(`miawa MCP server error: ${err.message}\n`);
+        process.exit(1);
+    });
+}

package/dist/mcp/utils.d.ts

@@ -15,6 +15,7 @@ export interface MCPTool {
     };
 }
 export interface MCPToolResult {
+    [key: string]: unknown;
     content: Array<{
         type: "text";
         text: string;
@@ -24,7 +25,6 @@ export interface MCPToolResult {
 export interface MCPServerConfig {
     name: string;
     version: string;
-    cliPath: string;
     tools: MCPTool[];
 }
 /**
@@ -49,3 +49,8 @@ export declare function getSessionId(args: {
  * Build CLI arguments from tool input
  */
 export declare function buildArgs(command: string[], args: Record<string, any>, mapping: Record<string, string>): string[];
+/**
+ * Bootstrap an MCP server with JSON-RPC over stdio transport.
+ * Uses low-level Server API for direct JSON schema passthrough.
+ */
+export declare function bootstrapMCPServer(config: MCPServerConfig, handleTool: (name: string, args: Record<string, any>) => Promise<MCPToolResult>): Promise<void>;

package/dist/mcp/utils.js

@@ -2,9 +2,10 @@
  * MCP Server base utilities for mia-code sub-CLIs
  */
 import { spawn } from "child_process";
-import { dirname } from "path";
-import { fileURLToPath } from "url";
-const __dirname = dirname(fileURLToPath(import.meta.url));
+// Using low-level Server for direct JSON schema control (McpServer requires Zod)
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 /**
  * Run a CLI command and return parsed JSON output
  */
@@ -74,3 +75,23 @@ export function buildArgs(command, args, mapping) {
     }
     return result;
 }
+/**
+ * Bootstrap an MCP server with JSON-RPC over stdio transport.
+ * Uses low-level Server API for direct JSON schema passthrough.
+ */
+export async function bootstrapMCPServer(config, handleTool) {
+    const server = new Server({ name: config.name, version: config.version }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: config.tools.map(t => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+        })),
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        return handleTool(name, args ?? {});
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/sessionStore.d.ts

@@ -1,8 +1,14 @@
-import { MiaCodeSessionMeta, ChatMessage } from "./types.js";
+import { MiaCodeSessionMeta, ChatMessage, Engine } from "./types.js";
 export declare function rememberSession(meta: MiaCodeSessionMeta): void;
 export declare function markSessionInitialized(id: string): void;
 export declare function isSessionInitialized(id: string): boolean;
-export declare function getLastSessionForProject(projectRoot: string): MiaCodeSessionMeta | null;
+/**
+ * Get the last session for a project, optionally filtered by engine.
+ * When engine is provided, only returns a session owned by that engine.
+ * Falls back to legacy unqualified key if no engine-specific entry exists
+ * (for backward compatibility with pre-engine sessions).
+ */
+export declare function getLastSessionForProject(projectRoot: string, engine?: Engine): MiaCodeSessionMeta | null;
 export declare function getSessionById(id: string): MiaCodeSessionMeta | null;
 export declare function listSessions(): MiaCodeSessionMeta[];
 export declare function clearSessions(): void;