project-iris 0.0.12 → 0.0.14

package/dist/workflows/bolt-plan.js

@@ -1,221 +0,0 @@
-import { randomUUID } from "crypto";
-import inquirer from "inquirer";
-import kleur from "kleur";
-import fs from "fs";
-import path from "path";
-import { WorkflowStage } from "../bridge/types.js";
-import { appendEvent, saveRun } from "../iris/run-state.js";
-import { fileURLToPath } from "url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-/**
- * Execute Bolt Plan stage
- * Steps:
- * 1. Generate bolt plan and individual bolt files
- * 2. Parse bolt list from plan
- * 3. Gate: Approve bolt plan? (y/N)
- */
-export async function executeBoltPlan(runState, connector, options) {
-    console.log(kleur.bold("Bolt Plan Stage"));
-    console.log(kleur.dim("Generating implementation plan and bolts\n"));
-    // Step 1: Generate bolt plan
-    console.log(kleur.cyan("→ Generating bolt plan..."));
-    const planTaskId = randomUUID();
-    // Load template
-    const templateDir = path.join(__dirname, "../templates/construction");
-    let boltTemplate = "";
-    try {
-        if (fs.existsSync(path.join(templateDir, "bolt-template.md"))) {
-            boltTemplate = fs.readFileSync(path.join(templateDir, "bolt-template.md"), "utf-8");
-        }
-    }
-    catch (e) {
-        console.error("Failed to load bolt template:", e);
-    }
-    const planPacket = {
-        taskId: planTaskId,
-        intent: runState.intent,
-        stage: WorkflowStage.BOLT_PLAN,
-        agent: "iris-master-agent",
-        instructions: `Based on the intent artifacts, create a bolt plan and individual bolt files.
-        
-You must create a DETAILED implementation plan.
-
-Intent: ${runState.intent}
-
-Review the intent artifacts in memory-bank/intents/ to understand requirements.
-
-Create:
-1. memory-bank/bolts/plan.md - Overall implementation plan listing all bolts
-2. memory-bank/bolts/<bolt-id>/bolt.md - One directory and file per bolt
-
-For each bolt, generate a separate markdown file with:
-1. Rich YAML frontmatter:
-   - id, unit, intent, type, status
-   - stories list
-   - timestamps (created, started, completed)
-   - requires_bolts/enables_bolts arrays
-   - complexity metrics
-2. Full bolt structure:
-   - Overview, Objective, Stories Included
-   - Bolt Type with reference
-   - Stages checklist
-   - Dependencies (Requires/Enables)
-   - Success Criteria
-   - Implementation Notes
-
-Analyze dependencies:
-- Identify which bolts must complete before others
-- Set requires_bolts field for dependent bolts
-- Set enables_bolts to show what each bolt unlocks
-- Calculate complexity based on:
-  - avg_complexity: 1-5 (code complexity)
-  - avg_uncertainty: 1-5 (requirements clarity)
-  - max_dependencies: count
-  - testing_scope: 1-5 (testing needed)
-
-Use the following Bolt Template EXACTLY for each bolt file:
-
---- TEMPLATE: bolt.md ---
-${boltTemplate}
--------------------------
-
-In plan.md, list all bolts in dependency order.`,
-        inputs: runState.artifacts,
-        expectedOutputs: [
-            "memory-bank/bolts/plan.md"
-        ],
-        metadata: { step: "generate_bolt_plan" }
-    };
-    appendEvent(runState.runId, {
-        stage: WorkflowStage.BOLT_PLAN,
-        action: "Requesting bolt plan generation",
-        taskId: planTaskId
-    });
-    if (options.noBridge) {
-        console.log(kleur.yellow("  Bridge disabled. Task packet written to:"));
-        console.log(kleur.dim(`  .iris/bridge/inbox/${planTaskId}.json`));
-        console.log(kleur.dim("  Manually create result in .iris/bridge/outbox/\n"));
-        return;
-    }
-    try {
-        await connector.sendTask(planPacket);
-        console.log(kleur.dim(`  Task sent: ${planTaskId}`));
-        console.log(kleur.dim("  Waiting for IDE agent to create bolt plan...\n"));
-        const planResult = await connector.waitResult(planTaskId, {
-            timeoutMs: 600000 // 10 minutes
-        });
-        if (planResult.status === "error") {
-            throw new Error(planResult.error || "Failed to generate bolt plan");
-        }
-        console.log(kleur.green("✓ Bolt plan created"));
-        if (planResult.filesChanged) {
-            planResult.filesChanged.forEach(file => {
-                console.log(kleur.dim(`  - ${file}`));
-                runState.artifacts.push(file);
-            });
-        }
-        console.log("");
-        appendEvent(runState.runId, {
-            stage: WorkflowStage.BOLT_PLAN,
-            action: "Bolt plan generated",
-            outputs: planResult.filesChanged,
-            resultStatus: "ok"
-        });
-        // Step 2: Parse bolt list from plan
-        const bolts = await parseBoltsFromPlan();
-        if (bolts.length === 0) {
-            console.log(kleur.yellow("⚠ No bolts found in plan. Creating default bolt.\n"));
-            bolts.push({
-                id: "implementation",
-                status: "pending"
-            });
-        }
-        runState.bolts = bolts;
-        console.log(kleur.cyan(`Found ${bolts.length} bolt(s):`));
-        bolts.forEach((bolt, i) => {
-            console.log(kleur.dim(`  ${i + 1}. ${bolt.id}`));
-        });
-        console.log("");
-        // Step 3: Gate - Approve bolt plan?
-        if (options.gate === "manual") {
-            console.log(kleur.bold(kleur.yellow("Gate: Bolt Plan Approval")));
-            const { approved } = await inquirer.prompt([
-                {
-                    type: "confirm",
-                    name: "approved",
-                    message: "Approve bolt plan and proceed to execution?",
-                    default: true
-                }
-            ]);
-            appendEvent(runState.runId, {
-                stage: WorkflowStage.BOLT_PLAN,
-                action: "Gate decision",
-                userGateDecision: approved ? "approved" : "rejected"
-            });
-            if (!approved) {
-                console.log(kleur.yellow("\n⚠ Bolt plan rejected. Revision loop not yet implemented."));
-                console.log(kleur.dim("For now, manually edit bolt files and re-run.\n"));
-                runState.stage = WorkflowStage.DONE;
-                return;
-            }
-            console.log(kleur.green("✓ Bolt plan approved\n"));
-        }
-        // Move to next stage
-        runState.stage = WorkflowStage.BOLT_EXECUTION;
-        runState.currentBoltIndex = 0;
-        saveRun(runState);
-    }
-    catch (error) {
-        console.error(kleur.red(`\n✗ Error: ${error.message}`));
-        appendEvent(runState.runId, {
-            stage: WorkflowStage.BOLT_PLAN,
-            action: "Stage failed",
-            message: error.message,
-            resultStatus: "error"
-        });
-        throw error;
-    }
-}
-/**
- * Parse bolts from plan.md
- * Looks for bolt file references or creates default list
- */
-async function parseBoltsFromPlan() {
-    const planPath = path.join(process.cwd(), "memory-bank/bolts/plan.md");
-    if (!fs.existsSync(planPath)) {
-        return [];
-    }
-    const content = fs.readFileSync(planPath, "utf8");
-    const bolts = [];
-    // Look for bolt file references (e.g., "- bolt-name" or "1. bolt-name")
-    const boltPattern = /(?:^|\n)(?:\d+\.|[-*])\s+([a-z0-9-]+)(?:\/bolt\.md)?/gi;
-    let match;
-    while ((match = boltPattern.exec(content)) !== null) {
-        const boltId = match[1].replace(/\/bolt\.md$/, "");
-        if (!bolts.find(b => b.id === boltId)) {
-            bolts.push({
-                id: boltId,
-                status: "pending"
-            });
-        }
-    }
-    // Also check for actual bolt directories
-    const boltsDir = path.join(process.cwd(), "memory-bank/bolts");
-    if (fs.existsSync(boltsDir)) {
-        const files = fs.readdirSync(boltsDir);
-        files.forEach(file => {
-            // Check if it's a directory and has bolt.md
-            const boltPath = path.join(boltsDir, file, "bolt.md");
-            if (fs.existsSync(boltPath)) {
-                if (!bolts.find(b => b.id === file)) {
-                    bolts.push({
-                        id: file,
-                        status: "pending"
-                    });
-                }
-            }
-        });
-    }
-    return bolts;
-}

package/dist/workflows/intent-inception.js

@@ -1,285 +0,0 @@
-import { randomUUID } from "crypto";
-import inquirer from "inquirer";
-import kleur from "kleur";
-import path from "path";
-import { WorkflowStage } from "../bridge/types.js";
-import { appendEvent, saveRun } from "../iris/run-state.js";
-import fs from "fs";
-import { fileURLToPath } from "url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-/**
- * Execute Intent Inception stage
- * Steps:
- * 1. Generate clarifying questions (3-8)
- * 2. Prompt user for answers
- * 3. Generate requirements/system-context/stories/units
- * 4. Gate: Approve intent? (y/N)
- */
-export async function executeIntentInception(runState, connector, options) {
-    console.log(kleur.bold("Intent Inception Stage"));
-    console.log(kleur.dim("Clarifying requirements and creating intent artifacts\n"));
-    try {
-        // Step 1: Clarification Loop (Ping-Pong)
-        console.log(kleur.cyan("→ Starting clarification loop..."));
-        const history = [];
-        let isDone = false;
-        let turnCount = 0;
-        const MAX_TURNS = 10;
-        while (!isDone && turnCount < MAX_TURNS) {
-            turnCount++;
-            const turnId = randomUUID();
-            // Prepare context for the agent
-            const contextStr = history.map(h => `Q: ${h.question}\nA: ${h.answer}`).join("\n\n");
-            const instructions = `You are an expert product manager refining a user's intent.
-Intent: "${runState.intent}"
-
-Current Understanding (Q&A History):
-${contextStr || "(None yet)"}
-
-Task:
-Analyze the intent and history.
-You MUST clarify the following aspects before finishing:
-1. Target User & Use Case
-2. Technical Constraints (Language, Frameworks, Database)
-3. Success Criteria (Specific requirements)
-4. Non-Goals (What to avoid)
-
-Instructions:
-1. If you have clear answers for ALL the above aspects, return exactly the string "DONE".
-2. If any aspect is missing or vague, ask the SINGLE most important clarifying question to ask the user next.
-
-Return ONLY the question string or "DONE". Do not include JSON or explanation.`;
-            const packet = {
-                taskId: turnId,
-                intent: runState.intent,
-                stage: WorkflowStage.INTENT_INCEPTION,
-                agent: "iris-inception-agent",
-                instructions,
-                inputs: [],
-                expectedOutputs: [],
-                metadata: { step: "clarify_turn", turn: turnCount }
-            };
-            if (options.noBridge) {
-                console.log(kleur.yellow(`  [Turn ${turnCount}] Bridge disabled. Write result to .iris/bridge/inbox/${turnId}.json`));
-                return; // Cannot proceed in loop without bridge in this mock implementation
-            }
-            // Inner try/catch for turn resilience
-            try {
-                await connector.sendTask(packet);
-                // Show loading spinner or status?
-                const turnResult = await connector.waitResult(turnId, { timeoutMs: 120000 }); // 2 mins per turn
-                if (turnResult.status === "error") {
-                    throw new Error(turnResult.error || "Agent failed to respond");
-                }
-                const agentResponse = turnResult.message.trim();
-                if (agentResponse === "DONE" || agentResponse.includes('"DONE"')) {
-                    isDone = true;
-                    console.log(kleur.green("\n✓ Intent clarified. Proceeding to design...\n"));
-                }
-                else {
-                    // It's a question
-                    const question = agentResponse.replace(/^"|"$/g, ""); // strip quotes if present
-                    console.log(kleur.bold(`\n${question}`));
-                    const { answer } = await inquirer.prompt([
-                        {
-                            type: "input",
-                            name: "answer",
-                            message: "Answer:",
-                            validate: (val) => val.trim().length > 0 || "Please provide an answer"
-                        }
-                    ]);
-                    history.push({ question, answer });
-                    // Append event for tracking
-                    appendEvent(runState.runId, {
-                        stage: WorkflowStage.INTENT_INCEPTION,
-                        action: "Q&A Turn",
-                        message: `Q: ${question}\nA: ${answer}`
-                    });
-                }
-            }
-            catch (e) {
-                console.error(kleur.red(`Error in clarification loop: ${e.message}`));
-                break; // Exit loop on error to save partial progress
-            }
-        }
-        if (history.length > 0) {
-            console.log(kleur.dim(`Captured ${history.length} clarification points.`));
-        }
-        // Prepare answers object for artifact generation (format match)
-        const answers = {};
-        history.forEach((h, i) => {
-            answers[`${i + 1}. ${h.question}`] = h.answer;
-        });
-        // Step 3: Generate intent artifacts
-        console.log(kleur.cyan("→ Generating intent artifacts..."));
-        const intentSlug = runState.intent
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, "-")
-            .replace(/^-|-$/g, "")
-            .substring(0, 50);
-        const artifactsTaskId = randomUUID();
-        // Load templates
-        const templateDir = path.join(__dirname, "../templates/inception");
-        let templates = {
-            requirements: "",
-            systemContext: "",
-            units: "",
-            unitBrief: "",
-            story: ""
-        };
-        try {
-            if (fs.existsSync(path.join(templateDir, "requirements-template.md"))) {
-                templates.requirements = fs.readFileSync(path.join(templateDir, "requirements-template.md"), "utf-8");
-                templates.systemContext = fs.readFileSync(path.join(templateDir, "system-context-template.md"), "utf-8");
-                templates.units = fs.readFileSync(path.join(templateDir, "units-template.md"), "utf-8");
-                templates.unitBrief = fs.readFileSync(path.join(templateDir, "unit-brief-template.md"), "utf-8");
-                templates.story = fs.readFileSync(path.join(templateDir, "story-template.md"), "utf-8");
-            }
-        }
-        catch (e) {
-            console.error("Failed to load templates:", e);
-        }
-        const artifactsPacket = {
-            taskId: artifactsTaskId,
-            intent: runState.intent,
-            stage: WorkflowStage.INTENT_INCEPTION,
-            agent: "iris-inception-agent",
-            instructions: `Based on the intent and user answers, create the following intent artifacts.
-            
-You refer to the templates below. Your job is to fill them out with EXTREME DETAIL based on the user's input.
-
-Intent: ${runState.intent}
-
-User Answers:
-${Object.entries(answers).map(([q, a]) => `Q: ${q}\nA: ${a}`).join("\n\n")}
-
-Create files in: memory-bank/intents/${intentSlug}/
-
-=== INSTRUCTIONS ===
-
-1. **requirements.md**:
-   - Use the TEMPLATE below.
-   - Use "FR-X.Y" numbering for functional requirements.
-   - Use "SHALL", "SHOULD", "MAY" keywords.
-   - Group FRs by feature area.
-   - Include specific metrics for NFRs.
-   - Fill out "Business Goals" with measurable metrics.
-
-2. **system-context.md**:
-   - Use the TEMPLATE below.
-   - Draw a Mermaid diagram for the context.
-   - List specific external integrations.
-
-3. **units.md**:
-   - Decompose the intent into 3-8 logical units.
-   - Each unit should have a clear responsibility.
-   - Define dependencies between units.
-
-4. **unit-brief.md** (for each unit):
-   - Create a directory for each unit: memory-bank/intents/${intentSlug}/units/{unit-name}/
-   - Create unit-brief.md inside.
-   - Use the TEMPLATE below.
-
-5. **stories.md**:
-   - Use the TEMPLATE below.
-   - Create clear user stories and technical stories.
-
-DO NOT use placeholders like "{insert here}". Write REAL content.
-
-=== TEMPLATES ===
-
---- TEMPLATE: requirements.md ---
-${templates.requirements}
---------------------------------
-
---- TEMPLATE: system-context.md ---
-${templates.systemContext}
-----------------------------------
-
---- TEMPLATE: units.md (Use for listing units) ---
-${templates.units}
--------------------------------------------------
-
---- TEMPLATE: unit-brief.md (Use for each unit in units/) ---
-${templates.unitBrief}
------------------------------------------------------------
-
---- TEMPLATE: story.md (Use for each story in unit stories/) ---
-${templates.story}
---------------------------------------------------------------
-`,
-            inputs: [],
-            expectedOutputs: [
-                `memory-bank/intents/${intentSlug}/requirements.md`,
-                `memory-bank/intents/${intentSlug}/system-context.md`
-            ],
-            metadata: { step: "generate_artifacts", intentSlug }
-        };
-        appendEvent(runState.runId, {
-            stage: WorkflowStage.INTENT_INCEPTION,
-            action: "Requesting artifact generation",
-            taskId: artifactsTaskId
-        });
-        await connector.sendTask(artifactsPacket);
-        console.log(kleur.dim(`  Task sent: ${artifactsTaskId}`));
-        console.log(kleur.dim("  Waiting for IDE agent to create artifacts...\n"));
-        const artifactsResult = await connector.waitResult(artifactsTaskId, {
-            timeoutMs: 600000 // 10 minutes
-        });
-        if (artifactsResult.status === "error") {
-            throw new Error(artifactsResult.error || "Failed to generate artifacts");
-        }
-        console.log(kleur.green("✓ Artifacts created"));
-        if (artifactsResult.filesChanged) {
-            artifactsResult.filesChanged.forEach(file => {
-                console.log(kleur.dim(`  - ${file}`));
-                runState.artifacts.push(file);
-            });
-        }
-        console.log("");
-        appendEvent(runState.runId, {
-            stage: WorkflowStage.INTENT_INCEPTION,
-            action: "Artifacts generated",
-            outputs: artifactsResult.filesChanged,
-            resultStatus: "ok"
-        });
-        // Step 4: Gate - Approve intent?
-        if (options.gate === "manual") {
-            console.log(kleur.bold(kleur.yellow("Gate: Intent Approval")));
-            const { approved } = await inquirer.prompt([
-                {
-                    type: "confirm",
-                    name: "approved",
-                    message: "Approve intent artifacts and proceed to Bolt Plan?",
-                    default: true
-                }
-            ]);
-            appendEvent(runState.runId, {
-                stage: WorkflowStage.INTENT_INCEPTION,
-                action: "Gate decision",
-                userGateDecision: approved ? "approved" : "rejected"
-            });
-            if (!approved) {
-                console.log(kleur.yellow("\n⚠ Intent rejected. Revision loop not yet implemented."));
-                console.log(kleur.dim("For now, manually edit artifacts and re-run.\n"));
-                runState.stage = WorkflowStage.DONE;
-                return;
-            }
-            console.log(kleur.green("✓ Intent approved\n"));
-        }
-        // Move to next stage
-        runState.stage = WorkflowStage.BOLT_PLAN;
-        saveRun(runState);
-    }
-    catch (error) {
-        console.error(kleur.red(`\n✗ Error: ${error.message}`));
-        appendEvent(runState.runId, {
-            stage: WorkflowStage.INTENT_INCEPTION,
-            action: "Stage failed",
-            message: error.message,
-            resultStatus: "error"
-        });
-        throw error;
-    }
-}

package/dist/workflows/memory-bank-generator.js

@@ -1,180 +0,0 @@
-import { randomUUID } from "crypto";
-import { WorkflowStage } from "../bridge/types.js";
-import path from "path";
-import fs from "fs";
-import { fileURLToPath } from "url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-/**
- * Orchestrate the full memory bank structure generation
- */
-export async function generateMemoryBankStructure(options) {
-    const { intent, answers, connector } = options;
-    const intentSlug = intent.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-    // Use a timestamp based ID for now or fetch next ID if available in context
-    const intentId = "001"; // Placeholder, would need state to know next ID
-    const intentPath = `memory-bank/intents/${intentId}-${intentSlug}`;
-    // Create base directory
-    fs.mkdirSync(intentPath, { recursive: true });
-    // Load templats
-    const templates = loadTemplates();
-    // 1. Generate Requirements & System Context (Batched to save prompt tokens/time)
-    console.log("-> Generating Requirements & Context...");
-    await generateInitialArtifacts(intent, intentId, intentSlug, answers, connector, templates);
-    // 2. Decompose into Units
-    console.log("-> Decomposing into Units...");
-    const units = await decomposeIntoUnits(intent, intentSlug, connector, templates);
-    // 3. Generate Unit Briefs & Stories
-    console.log(`-> Generating details for ${units.length} units...`);
-    for (const unit of units) {
-        console.log(`  -> Processing Unit: ${unit.name}`);
-        // Create unit directory
-        const unitDir = path.join(intentPath, "units", unit.name);
-        fs.mkdirSync(unitDir, { recursive: true });
-        await generateUnitBrief(unit, intent, intentSlug, connector, templates);
-        const stories = await generateStoriesForUnit(unit, intent, connector, templates);
-        // Save stories
-        const storiesDir = path.join(unitDir, "stories");
-        fs.mkdirSync(storiesDir, { recursive: true });
-        // This would typically involve another AI pass to write content for each story
-        // For efficiency in this script we might batch or generate placeholders
-        // But the user requested "full automation", so we should ideally generate them.
-        // For V1, we will list them in the unit brief or stories.md and create stub files
-    }
-    // 4. Generate Bolt Plan & Bolts
-    console.log("-> Generating Bolt Plan...");
-    // This re-uses the logic we improved in bolt-plan.ts, essentially calling the agent
-    // We can construct a packet similar to bolt-plan instructions
-    await generateBolts(intent, intentSlug, units, connector);
-}
-function loadTemplates() {
-    const templateDir = path.join(__dirname, "../templates/inception");
-    return {
-        requirements: fs.readFileSync(path.join(templateDir, "requirements-template.md"), "utf-8"),
-        systemContext: fs.readFileSync(path.join(templateDir, "system-context-template.md"), "utf-8"),
-        units: fs.readFileSync(path.join(templateDir, "units-template.md"), "utf-8"),
-        unitBrief: fs.readFileSync(path.join(templateDir, "unit-brief-template.md"), "utf-8"),
-        story: fs.readFileSync(path.join(templateDir, "story-template.md"), "utf-8"),
-        stories: fs.readFileSync(path.join(templateDir, "stories-template.md"), "utf-8"),
-    };
-}
-async function generateInitialArtifacts(intent, intentId, slug, answers, connector, templates) {
-    const taskId = randomUUID();
-    const packet = {
-        taskId,
-        intent,
-        stage: WorkflowStage.INTENT_INCEPTION,
-        agent: "iris-inception-agent",
-        instructions: `Generate detailed requirements and system context for intent: "${intent}".
-        
-User Answers:
-${Object.entries(answers).map(([q, a]) => `Q: ${q}\nA: ${a}`).join("\n\n")}
-
-Files to create in memory-bank/intents/${intentId}-${slug}/:
-1. requirements.md
-2. system-context.md
-
-Use these templates EXACTLY:
-
---- TEMPLATE: requirements.md ---
-${templates.requirements}
---------------------------------
-
---- TEMPLATE: system-context.md ---
-${templates.systemContext}
-----------------------------------
-`,
-        inputs: [],
-        expectedOutputs: [
-            `memory-bank/intents/${intentId}-${slug}/requirements.md`,
-            `memory-bank/intents/${intentId}-${slug}/system-context.md`
-        ],
-        metadata: { step: "initial_artifacts" }
-    };
-    const result = await connector.sendTask(packet);
-    const taskResult = await connector.waitResult(taskId);
-    if (taskResult.status === 'error')
-        throw new Error(taskResult.error || "Unknown error");
-}
-async function decomposeIntoUnits(intent, slug, connector, templates) {
-    const taskId = randomUUID();
-    const packet = {
-        taskId,
-        intent,
-        stage: WorkflowStage.INTENT_INCEPTION,
-        agent: "iris-inception-agent",
-        instructions: `Analyze the intent "${intent}" and decompose it into 3-8 logical units.
-
-Return a JSON object with the units list.
-Do NOT write files yet, just return the JSON analysis.
-
-Format:
-{
-  "units": [
-    {
-      "name": "001-unit-name",
-      "purpose": "Brief purpose",
-      "description": "Longer description"
-    }
-  ]
-}
-`,
-        inputs: [],
-        expectedOutputs: [], // We expect JSON in text response for this internal step
-        metadata: { step: "decompose_units" }
-    };
-    // In a real implementation we might want to have the agent write to a file or parse the output
-    // For this implementation, we'll assume the agent writes a 'units.json' or we'd parse the completion.
-    // Since our bridge is file-based in many cases, we can ask it to write memory-bank/intents/{slug}/units-analysis.json
-    // We will update instructions to write to a file we can read
-    packet.instructions += `\nWrite the JSON to memory-bank/intents/temp-units-analysis.json`;
-    packet.expectedOutputs = [`memory-bank/intents/temp-units-analysis.json`];
-    await connector.sendTask(packet);
-    const result = await connector.waitResult(taskId);
-    // Read the file
-    // Note: In a real app we'd handle paths more robustly
-    const analysisPath = path.resolve(process.cwd(), "memory-bank/intents/temp-units-analysis.json");
-    if (fs.existsSync(analysisPath)) {
-        try {
-            const data = JSON.parse(fs.readFileSync(analysisPath, 'utf8'));
-            return data.units || [];
-        }
-        catch (e) {
-            console.error("Failed to parse units analysis", e);
-            return [];
-        }
-    }
-    return [];
-}
-async function generateUnitBrief(unit, intent, intentSlug, connector, templates) {
-    const taskId = randomUUID();
-    const packet = {
-        taskId,
-        intent,
-        stage: WorkflowStage.INTENT_INCEPTION,
-        agent: "iris-inception-agent",
-        instructions: `Generate unit brief for unit: ${unit.name}
-        
-Intent: ${intent}
-Unit Purpose: ${unit.purpose}
-
-File to create: memory-bank/intents/${intentSlug}/units/${unit.name}/unit-brief.md
-
-Use TEMPLATE:
-${templates.unitBrief}
-`,
-        inputs: [],
-        expectedOutputs: [`memory-bank/intents/${intentSlug}/units/${unit.name}/unit-brief.md`],
-        metadata: { step: "unit_brief", unit: unit.name }
-    };
-    await connector.sendTask(packet);
-    await connector.waitResult(taskId);
-}
-async function generateStoriesForUnit(unit, intent, connector, templates) {
-    // Similar implementation to generate unit brief, but for stories
-    return []; // Placeholder for brevity in this first pass
-}
-async function generateBolts(intent, intentSlug, units, connector) {
-    // Reuse the logic from bolt-plan.ts but orchestrated here
-    // This would send a task to the Master Agent to create the bolt plan and bolt files
-}