mia-code 0.2.0 → 0.3.0

package/skills/rise-pde-inquiry-session-multi-agents-v3/references/ceremonial-technology.md

@@ -0,0 +1,102 @@
+# Ceremonial Technology Development
+
+> Building tools, protocols, and software systems that treat knowledge work as ceremony — where technology serves relational accountability rather than extraction.
+
+---
+
+## What Is Ceremonial Technology?
+
+Ceremonial Technology Development is the practice of creating software, frameworks, and workflows that:
+
+1. **Honor relational accountability** at every layer — from data types to user interfaces
+2. **Treat code as ceremony** — systematic actions that create collective focus, not just task completion
+3. **Resist extraction** — knowledge belongs to the relationships and communities that created it
+4. **Create rather than eliminate** — oriented toward bringing desired outcomes into being, not removing problems
+
+The core insight: Robert Fritz's structural dynamics (Structural Tension, MMOT, Delayed Resolution, Creative Orientation) are not separate from Indigenous paradigm — they **function as ceremonial technology** that bridges systematic Western methodologies with sacred relational Indigenous ways.
+
+---
+
+## The Medicine Wheel Developer Suite
+
+The primary technical manifestation of Ceremonial Technology is the **Medicine Wheel Developer Suite** — seven published npm packages that encode Indigenous relational ontology as first-class code structures:
+
+| Package | Role | Direction |
+|---------|------|-----------|
+| `medicine-wheel-ontology-core` | Foundational types, RDF vocab, Zod schemas, Wilson alignment, OCAP | Center |
+| `medicine-wheel-relational-query` | Traverse kinship webs with relational constraints | East |
+| `medicine-wheel-narrative-engine` | Narrative beats and story flow bound to ceremony | South |
+| `medicine-wheel-ceremony-protocol` | Ceremony types, logs, governance, consent workflows | West |
+| `medicine-wheel-graph-viz` | Relational graph visualization | North |
+| `medicine-wheel-ui-components` | Community-facing interface components | Bridge |
+| `medicine-wheel-prompt-decomposition` | PDE — intention exploration as EAST practice | East |
+
+See: [Medicine Wheel Research](medicine-wheel-research.md) · [llms-medicine-wheel-packages.txt](../llms-medicine-wheel-packages.txt)
+
+---
+
+## LangChain & LangGraph Integration
+
+### LangChain — Sequential Ceremonial Workflows
+
+LangChain tools backed by ontology-core enable:
+
+- **RelationalNodeRetriever** — surfaces nodes constrained by direction, ceremony context, or OCAP flags
+- **NarrativeBeatPlanner** — uses Structural Tension Charts and Narrative Beats to generate next steps in research or ceremony
+
+### LangGraph — Four Directions Multi-Agent Orchestration
+
+LangGraph's stateful graph maps to the Medicine Wheel directions:
+
+| Direction | Agent Role | Function |
+|-----------|-----------|----------|
+| 🌅 **East** | Inquiry & bias detection | Nitshkees Thinking — structural tension detection |
+| 🔥 **South** | Planning & consent | OCAP flags, ceremony-protocol guidance |
+| 🌊 **West** | Experiential practice | Data gathering, field notes, transcripts |
+| ❄️ **North** | Reflection & archival | Narrative beats, ceremony logs, Wilson alignment summaries |
+
+Graph-level governance ensures that edges touching sacred knowledge are only traversed when appropriate ceremonies have been logged and IKSL conditions are met.
+
+---
+
+## Ceremonial Practices in Software
+
+### Coding as Ceremony
+
+When working under ceremonial technology principles:
+
+- **File creation** is a relational act — every new artifact enters a kinship network
+- **Refactoring** is relational change — positions shift within the kin map
+- **Commits** carry narrative meaning — not just what changed, but what it means relationally
+- **Reviews** use MMOT — truth as a verb, turning discrepancies into learning
+
+### The Five Ceremonial Stages
+
+The creative process parallels five ceremonial stages:
+
+1. **Preparation** — Establishing structural tension (desired outcome + current reality)
+2. **Invitation** — Opening sacred space for inquiry
+3. **Engagement** — Holding tension, resisting premature resolution
+4. **Integration** — Knowledge transforms practice
+5. **Completion** — Ceremony closes; obligations carry forward
+
+See: [Creative Orientation](creative-orientation.md) · [Structural Tension](structural-tension.md) · [Delayed Resolution](../llms-delayed-resolution-principle.md)
+
+---
+
+## Relationship to Relational Science
+
+[Relational Science](relational-science.md) provides the epistemological ground — **how knowledge works relationally**.
+
+Ceremonial Technology Development provides the tools — **software that embodies relational accountability in action**.
+
+The braid: *Relational Science names what is true about knowledge. Ceremonial Technology creates tools worthy of that truth.*
+
+---
+
+## Key Sources
+
+- [Medicine Wheel Research](medicine-wheel-research.md) — [llms-inquiry-medicine-wheel](../llms-inquiry-medicine-wheel-abundance-intelligence-research--d971fc13-64ee-41ab-8fcd-bb5900197ab8.md)
+- [Indigenous Research Paradigm](indigenous-research-paradigm.md) — [llms-inquiry-6406eb37](../llms-inquiry-6406eb37-69b1-471d-9cac-07ae69449c35.md)
+- [Kinship Hub System](kinship-hub.md) — [llms-kinship-hub-system-full.md](../llms-kinship-hub-system-full.md)
+- [KINSHIP.md](../KINSHIP.md) — this repo's relational charter

package/skills/rise-pde-inquiry-session-multi-agents-v3/references/creative-orientation.md

@@ -0,0 +1,99 @@
+# Creative Orientation
+
+> The foundational framework for shifting from reactive problem-solving to generative creation, based on Robert Fritz's structural dynamics.
+
+---
+
+## The Core Distinction
+
+| Reactive Approach (Elimination) | Creative Approach (Generation) |
+|-------------------------------|-------------------------------|
+| Focuses on removing unwanted conditions | Focuses on bringing desired outcomes into being |
+| Action driven by what you don't want | Action driven by what you want to create |
+| Energy diminishes as problems reduce | Energy sustains through structural tension |
+| Produces **oscillating patterns** | Produces **advancing patterns** |
+
+**This is not a preference — it is a structural difference.** The reactive approach oscillates because once the problem is sufficiently reduced, motivation decreases, and the problem returns. The creative approach advances because structural tension drives resolution toward the desired outcome.
+
+---
+
+## Structural Thinking Foundation
+
+Before creative orientation can function, **clear reality perception is essential**:
+
+- Structural tension cannot form without accurate assessment of "what is"
+- Hidden concepts and biases distort reality perception
+- **The structure of anything determines its behavior** — change the structure, change the pattern
+- Conceptual risk (imagined) vs. actual risk (present) must be distinguished
+
+### The Three Steps of Structural Thinking
+
+1. **Start with Nothing** — no preconceptions, no imported models
+2. **Picture What Is Said** — visualize the information as presented
+3. **Ask Questions** — Information, Clarification, Implication, Discrepancy
+
+See: [llms-structural-thinking.gemini.txt](../llms-structural-thinking.gemini.txt) · [llms-structural-thinking.claude](../llms-structural-thinking.claude.f04dc696-3959-4be4-ad3f-390df0f517d9.txt)
+
+---
+
+## Structural Tension
+
+**Structural tension is disequilibrium** — an active, loaded, dynamic force that seeks resolution through advancement. It is **NOT** "a gap to bridge."
+
+| ❌ Never say | ✅ Say instead |
+|-------------|---------------|
+| "bridge the gap" | "resolve the tension" |
+| "close the gap" | "advance toward the desired outcome" |
+| "fill the gap" | "the structure seeks resolution" |
+
+A structural tension chart has three components:
+
+1. **Desired Outcome** — what you want to create (not solve)
+2. **Current Reality** — honest assessment of where you are now
+3. **Action Steps** — strategic secondary choices supporting the primary goal (NOT a to-do list)
+
+See: [Structural Tension](structural-tension.md) for the full charting methodology.
+
+---
+
+## The Three Phases of Creation
+
+1. **Germination** — The vision forms; structural tension establishes between desired outcome and current reality
+2. **Assimilation** — Internalizing the vision; living within the tension without premature resolution
+3. **Completion** — The creation resolves; the structure advances to equilibrium
+
+These phases parallel the five ceremonial stages described in [Ceremonial Technology](ceremonial-technology.md).
+
+---
+
+## Delayed Resolution
+
+A critical principle: **hold structural tension rather than collapsing it prematurely**. 
+
+Premature resolution destroys the generative force. When an AI defaults to "Ready to begin" without genuinely assessing current reality, it eliminates the tension that drives creation.
+
+See: [llms-delayed-resolution-principle.md](../llms-delayed-resolution-principle.md)
+
+---
+
+## Creative Orientation as Decolonial Practice
+
+The creative orientation is inherently aligned with Indigenous epistemologies because:
+
+- **Creation, not elimination** resists Wetigo (consumption/extraction) mentality
+- **Knowledge-to-wisdom transformation** parallels ceremonial knowledge-making
+- **Structural tension as sacred space** — the tension between vision and reality is *mana*
+- **Advancing patterns** honor the relational web rather than extracting from it
+
+See: [Relational Science](relational-science.md) · [Indigenous Research Paradigm](indigenous-research-paradigm.md)
+
+---
+
+## Key Sources
+
+- [llms-creative-orientation.txt](../llms-creative-orientation.txt) — full framework
+- [llms-structural-thinking.gemini.txt](../llms-structural-thinking.gemini.txt) — diagnostic discipline
+- [llms-delayed-resolution-principle.md](../llms-delayed-resolution-principle.md) — tension maintenance
+- [llms-sccp-patterning.md](../llms-sccp-patterning.md) — macrostructural pattern analysis
+- [llms-leadership.txt](../llms-leadership.txt) — leadership through structural design
+- [llms-non-creative-orientation-approach-to-convert.txt](../llms-non-creative-orientation-approach-to-convert.txt) — reframing reactive methods

package/skills/rise-pde-inquiry-session-multi-agents-v3/references/prompt-decomposition.md

@@ -0,0 +1,73 @@
+# Prompt Decomposition Engine (PDE)
+
+> Intention exploration as EAST practice — decomposing prompts into explicit and implicit intents, mapping dependencies, and organizing action through the Four Directions.
+
+---
+
+## PDE as EAST Practice
+
+Prompt Decomposition is part of the **EAST** direction in the Medicine Wheel framework — the direction of **Vision**, where:
+
+- Intentions are explored before action begins
+- Explicit and implicit needs are surfaced
+- Ambiguities are named rather than assumed away
+- The full scope of what is being asked becomes visible
+
+The EAST practice then guides toward **SOUTH** — planning and structured activities with human and AI companions. This is the bridge from vision to embodied action.
+
+---
+
+## How PDE Works
+
+A prompt is decomposed into:
+
+### Primary Intent
+The single most important action — what the prompt is fundamentally asking for.
+
+### Secondary Intents
+Everything else, distinguished as:
+- **Explicit** — stated directly in the prompt
+- **Implicit** — inferred from hedging language ("probably," "I assume," "somehow")
+
+### Four Directions Mapping
+
+| Direction | Role | Examples |
+|-----------|------|----------|
+| 🌅 **East** | Vision — what is being asked | Requirements, desired outcomes, vision statements |
+| 🔥 **South** | Analysis — what needs to be learned | Research, investigation, reading, growing |
+| 🌊 **West** | Validation — what needs reflection | Testing, review, accountability checks |
+| ❄️ **North** | Action — what executes the cycle | Implementation, delivery, creation |
+
+### Action Stack
+An ordered list of tasks respecting dependencies, each mapped to a direction.
+
+### Ambiguities
+Places where the prompt is vague or uses uncertain language — surfaced explicitly rather than resolved by assumption.
+
+---
+
+## PDE and Delayed Resolution
+
+PDE embodies the [delayed resolution principle](../llms-delayed-resolution-principle.md): ambiguities are **named and held** rather than silently resolved. This prevents:
+
+- Premature commitment to misunderstood requirements
+- False confidence in AI interpretation
+- Loss of the generative tension between "what was asked" and "what is needed"
+
+---
+
+## Integration
+
+| Framework | Connection |
+|-----------|-----------|
+| [Creative Orientation](creative-orientation.md) | PDE frames decomposition as creation, not analysis |
+| [Structural Tension](structural-tension.md) | Each decomposed intent creates its own tension chart |
+| [Narrative Craft](narrative-craft.md) | Complex prompts contain story — PDE surfaces the narrative structure |
+
+---
+
+## Key Sources
+
+- [llms-pde.txt](../llms-pde.txt) — PDE reference (llms-txt format)
+- [medicine-wheel-prompt-decomposition](https://www.npmjs.com/package/medicine-wheel-prompt-decomposition) — npm package
+- [.pde/](../.pde/) — stored decompositions in this repository

package/skills/rise-pde-inquiry-session-multi-agents-v3/references/rise-framework.md

@@ -0,0 +1,74 @@
+# RISE Framework
+
+> **R**everse-engineer, **I**ntent-extract, **S**pecify, **E**xport — a creative-oriented methodology for understanding and generating code architectures through structural tension dynamics.
+
+---
+
+## Foundation: Specifications as Prose Code
+
+RISE builds on SpecLang's core insight: **specifications are "prose code"** — natural language representations of computation that still require you to think like a programmer.
+
+### SpecLang Principles
+
+- **Spec as Source of Truth** — the specification is what you maintain; executable code is secondary
+- **Variable Detail Levels** — offhand remarks may generate dozens of boilerplate lines; exact steps when precision matters
+- **Creating and Adjusting** — start simple, refine against running output, stop when reality matches vision
+- **Bi-directional Ideation** — the model "yes-ands" your intent, extending ideas naturally
+- **Intent-based Expression** — focus on behavior; toolchain handles plumbing
+
+---
+
+## The Four Phases
+
+### Phase 1: Reverse-engineer (R)
+
+**Creative Archaeology** — extracting what exists with respect for what was created.
+
+- Map the existing system's structure without importing preconceptions
+- Identify what users *love* about the current prototype
+- Use [Structural Thinking](creative-orientation.md) — start with nothing, picture what is said, ask questions
+
+### Phase 2: Intent-extract (I)
+
+**Uncovering creative vision** — what the creator wanted to bring into being.
+
+- Distinguish between what the code *does* and what the creator *intended*
+- Extract the structural tension: desired outcome vs. current reality of the codebase
+- Preserve the "beloved qualities" that make prototypes valuable
+
+### Phase 3: Specify (S)
+
+**SpecLang prose-code generation** — writing specifications that capture desired outcomes.
+
+- Specifications focus on *what you want to create*, not problems to fix
+- Detail varies: broad strokes for obvious patterns, precision for critical behavior
+- Each spec is a structural tension chart: desired behavior + current state + action plan
+
+### Phase 4: Export (E)
+
+**Manifesting the creation** — generating implementation from specification.
+
+- Code generation follows the spec as source of truth
+- Git-log-driven methodology maintains specs as code evolves
+- The creation advances toward the desired outcome through iterative refinement
+
+---
+
+## RISE and the Creative Orientation
+
+RISE transforms how reverse engineering is practiced:
+
+| Reactive Approach | RISE Approach |
+|------------------|---------------|
+| Find bugs and fix them | Discover creative intent and honor it |
+| Document what's broken | Specify what's desired |
+| Patch problems | Advance toward the vision |
+| Technical debt analysis | Creative archaeology |
+
+---
+
+## Key Sources
+
+- [llms-rise-framework.txt](../llms-rise-framework.txt) — full framework (998 lines)
+- [llms-creative-orientation.txt](../llms-creative-orientation.txt) — foundational principles
+- [llms-structural-thinking.gemini.txt](../llms-structural-thinking.gemini.txt) — diagnostic discipline

package/skills/rise-pde-inquiry-session-multi-agents-v3/references/structural-tension.md

@@ -0,0 +1,82 @@
+# Structural Tension Charts
+
+> Structural tension is **disequilibrium** — an active, loaded force that resolves through advancement, not a gap to bridge. Action steps are telescoped sub-charts, not a to-do list.
+
+---
+
+## Core Components
+
+Every structural tension chart holds three elements:
+
+1. **Desired Outcome** — What you want to create (not what you want to solve or eliminate)
+2. **Current Reality** — An honest, unbiased assessment of what actually exists right now
+3. **Action Steps** — Strategic secondary choices that *support* the primary goal
+
+### The Tension Dynamic
+
+Structural tension is a state of **disequilibrium** between Desired Outcome and Current Reality. Like a stretched elastic band, it is an energized, causal force that naturally seeks resolution through advancement.
+
+```
+  Desired Outcome ───────────── TENSION ───────────── Current Reality
+       (what you want to create)         (what actually is)
+                              │
+                    ┌─────────▼─────────┐
+                    │   Action Steps    │
+                    │  (each a chart    │
+                    │   in itself)      │
+                    └───────────────────┘
+```
+
+---
+
+## Action Steps Are NOT a To-Do List
+
+This is the most common failure. Action steps are:
+
+- ✅ Strategic secondary choices that SUPPORT the primary goal
+- ✅ Understood in the CONTEXT of structural tension
+- ✅ Related to EACH OTHER as part of an overview strategy
+- ✅ A BLUEPRINT for the creative process
+- ❌ NOT items on a checklist
+- ❌ NOT independent tasks
+- ❌ NOT detailed instructions
+
+**The Test Question**: "If we took these steps, would we achieve this result?"
+
+Each action step is itself a telescoped structural tension chart — with its own desired outcome, current reality, and sub-steps.
+
+---
+
+## Language Discipline
+
+| ❌ Never say | ✅ Say instead | Why |
+|-------------|---------------|-----|
+| "bridge the gap" | "resolve the tension" | Tension is a force, not a void |
+| "close the gap" | "advance toward the desired outcome" | The structure advances |
+| "the gap between" | "the tension between" | Gap = emptiness. Tension = loaded energy |
+| "fill the gap" | "the structure seeks resolution" | Nothing is being filled |
+
+---
+
+## Integration with Other Frameworks
+
+### As Ceremonial Technology
+
+Structural Tension Charting functions as **entering sacred space** — the tension between vision and reality is *mana* (sacred space between things). See: [Ceremonial Technology](ceremonial-technology.md) · [Indigenous Research Paradigm](indigenous-research-paradigm.md)
+
+### With MMOT
+
+When a discrepancy appears between expectation and delivery, the [Managerial Moment of Truth](performance-truth.md) provides a four-step process for addressing it within the structural tension framework.
+
+### With Delayed Resolution
+
+The principle of [delayed resolution](../llms-delayed-resolution-principle.md) prevents premature collapse of structural tension. Current reality must be genuinely assessed, not defaulted to comfortable starting positions.
+
+---
+
+## Key Sources
+
+- [llms-structural-tension-charts.txt](../llms-structural-tension-charts.txt) — full charting guide
+- [llms-creative-orientation.txt](../llms-creative-orientation.txt) — foundational framework
+- [llms-delayed-resolution-principle.md](../llms-delayed-resolution-principle.md) — tension maintenance
+- [llms-managerial-moment-of-truth.md](../llms-managerial-moment-of-truth.md) — MMOT process

package/src/cli.ts

@@ -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 { MiaCodeSessionMeta, MiaCodeConfig, Engine, ChatMessage } from "./types.js";
 import { renderEventsToText, formatHeader, formatHelpText, formatError, formatSuccess } from "./formatting.js";
 import { runUnifierSession } from "./unifier.js";
@@ -57,8 +57,10 @@ async function runInteractiveConfig(config: MiaCodeConfig): Promise<void> {
   console.log(chalk.green(`\n✓ config updated → engine: ${engine}, model: ${model}`));
 }
 
-async function pickSession(projectRoot: string): Promise<string | undefined> {
-  const sessions = listSessions().filter(s => s.projectRoot === projectRoot);
+async function pickSession(projectRoot: string, engine?: Engine): Promise<string | undefined> {
+  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."));
@@ -67,7 +69,8 @@ async function pickSession(projectRoot: string): Promise<string | 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("");
@@ -134,13 +137,20 @@ export async function runInteractiveCli(options: CliOptions = {}): Promise<void>
   
   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
@@ -203,6 +213,7 @@ export async function runInteractiveCli(options: CliOptions = {}): Promise<void>
           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 {
             console.log(chalk.dim("no active session"));
@@ -217,7 +228,8 @@ export async function runInteractiveCli(options: CliOptions = {}): Promise<void>
             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;
@@ -303,6 +315,7 @@ export async function runInteractiveCli(options: CliOptions = {}): Promise<void>
             id: currentSessionId,
             startedAt: new Date().toISOString(),
             model: config.model,
+            engine: config.engine,
             projectRoot,
             initialized: true
           };
@@ -367,6 +380,7 @@ export async function runInteractiveCli(options: CliOptions = {}): Promise<void>
           id: currentSessionId,
           startedAt: new Date().toISOString(),
           model: config.model,
+          engine: config.engine,
           projectRoot,
           initialized: false
         };
@@ -389,6 +403,7 @@ export async function runInteractiveCli(options: CliOptions = {}): Promise<void>
               id: currentSessionId,
               startedAt: new Date().toISOString(),
               model: config.model,
+              engine: config.engine,
               projectRoot,
               initialized: true
             };
@@ -690,7 +705,15 @@ export async function runSinglePrompt(prompt: string, options: CliOptions = {}):
   // Handle session resume (single prompt doesn't support interactive picker)
   let sessionId: string | undefined;
   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
     sessionId = undefined;
@@ -713,6 +736,7 @@ export async function runSinglePrompt(prompt: string, options: CliOptions = {}):
         id: result.sessionId,
         startedAt: new Date().toISOString(),
         model: config.model,
+        engine: config.engine,
         projectRoot
       };
       rememberSession(meta);

package/src/geminiHeadless.ts

@@ -66,10 +66,15 @@ export function runGeminiHeadless(
     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);
+      }
     }
   }
 

package/src/index.ts

@@ -153,7 +153,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}`));
     }
   });
 

package/src/mcp/miaco-server.ts

@@ -4,7 +4,7 @@
  * Exposes chart/schema/validate tools as MCP tools
  */
 
-import { runCLI, parseJSONOutput, createToolResult, buildArgs, MCPTool, MCPToolResult } from "./utils.js";
+import { runCLI, parseJSONOutput, createToolResult, buildArgs, bootstrapMCPServer, MCPTool, MCPToolResult } from "./utils.js";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 
@@ -197,3 +197,15 @@ 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/src/mcp/miatel-server.ts

@@ -4,7 +4,7 @@
  * Exposes beat/arc/theme tools as MCP tools
  */
 
-import { runCLI, parseJSONOutput, createToolResult, buildArgs, MCPTool, MCPToolResult } from "./utils.js";
+import { runCLI, parseJSONOutput, createToolResult, buildArgs, bootstrapMCPServer, MCPTool, MCPToolResult } from "./utils.js";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 
@@ -136,3 +136,15 @@ 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/src/mcp/miawa-server.ts

@@ -4,7 +4,7 @@
  * Exposes ceremony/wound/eva tools as MCP tools
  */
 
-import { runCLI, parseJSONOutput, createToolResult, buildArgs, MCPTool, MCPToolResult } from "./utils.js";
+import { runCLI, parseJSONOutput, createToolResult, buildArgs, bootstrapMCPServer, MCPTool, MCPToolResult } from "./utils.js";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 
@@ -156,3 +156,15 @@ 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);
+  });
+}