project-iris 0.0.1

package/dist/iris/workflow/config.js

@@ -0,0 +1,51 @@
+import yaml from "js-yaml";
+import fs from "fs";
+import { FrameworkError } from "../../framework/framework-types.js";
+// Default workflow for frameworks that don't specify one
+export const DEFAULT_WORKFLOW_CONFIG = {
+    schemaVersion: 1,
+    steps: [
+        { id: "interview", kind: "interview" },
+        { id: "artifacts", kind: "artifacts" },
+        { id: "plan", kind: "planning" },
+        { id: "build", kind: "construction" },
+        { id: "execute", kind: "execution" },
+        { id: "validate", kind: "validate" },
+        { id: "pack", kind: "pack" },
+        { id: "handoff", kind: "handoff" }
+    ]
+};
+export function loadEffectiveWorkflowConfig(framework) {
+    if (!framework || !framework.files.workflow) {
+        return DEFAULT_WORKFLOW_CONFIG;
+    }
+    try {
+        const content = fs.readFileSync(framework.files.workflow, "utf-8");
+        const doc = yaml.load(content);
+        if (!doc)
+            throw new Error("Empty workflow file");
+        // Basic schema validation
+        if (doc.schemaVersion !== 1) {
+            throw new FrameworkError("INVALID_SCHEMA", framework.files.workflow, `Unsupported workflow schema version: ${doc.schemaVersion}. Only version 1 is supported.`);
+        }
+        if (!Array.isArray(doc.steps)) {
+            throw new FrameworkError("INVALID_SCHEMA", framework.files.workflow, "Workflow must have a 'steps' array.");
+        }
+        // Validate steps
+        for (const step of doc.steps) {
+            if (!step.id || !step.kind) {
+                throw new FrameworkError("INVALID_SCHEMA", framework.files.workflow, "Workflow steps must have 'id' and 'kind'.");
+            }
+            if (!['interview', 'artifacts', 'planning', 'construction', 'validate', 'pack', 'handoff', 'execution'].includes(step.kind)) {
+                throw new FrameworkError("INVALID_SCHEMA", framework.files.workflow, `Unknown step kind: '${step.kind}'.`);
+            }
+        }
+        return doc;
+    }
+    catch (e) {
+        // Wrap generic errors
+        if (e instanceof FrameworkError)
+            throw e;
+        throw new FrameworkError("INVALID_YAML", framework.files.workflow, `Failed to parse workflow configuration: ${e.message}`);
+    }
+}

package/dist/iris/workflow/engine.js

@@ -0,0 +1,129 @@
+import path from "path";
+import fs from "fs";
+import { writeJsonAtomic } from "../fs/atomic.js";
+import { ensureDir } from "../../lib.js";
+import { generateIntentId } from "../utils/interpolate.js";
+// Constants
+export const RUNS_DIR = ".iris/runs";
+export const RUN_FILE_NAME = "run.json";
+export const EVENTS_FILE_NAME = "events.ndjson";
+export const LATEST_POINTER_FILE = "latest";
+export class WorkflowEngine {
+    repoRoot;
+    runDir;
+    state;
+    eventsPath;
+    constructor(repoRoot, runId, initialState) {
+        this.repoRoot = repoRoot;
+        this.runDir = path.join(repoRoot, RUNS_DIR, runId);
+        this.eventsPath = path.join(this.runDir, EVENTS_FILE_NAME);
+        if (initialState) {
+            this.state = initialState;
+        }
+        else {
+            // Check if exists
+            try {
+                const content = fs.readFileSync(path.join(this.runDir, RUN_FILE_NAME), "utf-8");
+                this.state = JSON.parse(content);
+            }
+            catch (e) {
+                throw new Error(`Run '${runId}' not found and no initial state provided.`);
+            }
+        }
+    }
+    getRunId() {
+        return this.state.runId;
+    }
+    getRunDir() {
+        return this.runDir;
+    }
+    getState() {
+        return { ...this.state }; // Clone
+    }
+    static create(repoRoot, frameworkId, frameworkVersion, workflow) {
+        const runId = generateRunId();
+        const runDir = path.join(repoRoot, RUNS_DIR, runId);
+        ensureDir(runDir);
+        // Generate intentId (no draft available at creation, uses fallback slug)
+        const intentId = generateIntentId();
+        const state = {
+            schemaVersion: 1,
+            runId,
+            intentId,
+            framework: { id: frameworkId, version: frameworkVersion },
+            workflow,
+            cursor: { nextStepId: workflow.steps[0]?.id || null },
+            steps: {},
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
+        };
+        const engine = new WorkflowEngine(repoRoot, runId, state);
+        engine.persist();
+        engine.appendEvent("RUN_STARTED", { msg: "Run created" });
+        engine.updateLatestPointer();
+        return engine;
+    }
+    static load(repoRoot, runId) {
+        return new WorkflowEngine(repoRoot, runId);
+    }
+    static getLatestRunId(repoRoot) {
+        try {
+            const pointer = path.join(repoRoot, RUNS_DIR, LATEST_POINTER_FILE);
+            if (fs.existsSync(pointer)) {
+                return fs.readFileSync(pointer, "utf-8").trim();
+            }
+        }
+        catch (e) {
+            return null;
+        }
+        return null;
+    }
+    persist() {
+        this.state.updatedAt = new Date().toISOString();
+        writeJsonAtomic(path.join(this.runDir, RUN_FILE_NAME), this.state);
+    }
+    updateLatestPointer() {
+        const pointer = path.join(this.repoRoot, RUNS_DIR, LATEST_POINTER_FILE);
+        ensureDir(path.dirname(pointer));
+        fs.writeFileSync(pointer, this.state.runId);
+    }
+    appendEvent(type, data = {}) {
+        const event = {
+            ts: new Date().toISOString(),
+            type,
+            ...data
+        };
+        fs.appendFileSync(this.eventsPath, JSON.stringify(event) + "\n");
+    }
+    getStepStatus(stepId) {
+        return this.state.steps[stepId];
+    }
+    updateStepstatus(stepId, update) {
+        if (!this.state.steps[stepId]) {
+            this.state.steps[stepId] = {
+                status: 'pending',
+                updatedAt: new Date().toISOString(),
+                ...update
+            };
+        }
+        else {
+            this.state.steps[stepId] = {
+                ...this.state.steps[stepId],
+                updatedAt: new Date().toISOString(),
+                ...update
+            };
+        }
+        this.persist();
+    }
+    advanceCursor(nextStepId) {
+        this.state.cursor.nextStepId = nextStepId;
+        this.persist();
+    }
+}
+function generateRunId() {
+    const now = new Date();
+    // YYYYMMDD-HHMMSS-rand
+    const ts = now.toISOString().replace(/[:.]/g, "-").split("T").join("-").substring(0, 19);
+    const rand = Math.random().toString(36).substring(2, 6);
+    return `${ts}-${rand}`;
+}

package/dist/iris/workflow/steps.js

@@ -0,0 +1,448 @@
+import path from "path";
+import fs from "fs";
+import { runIntentInterview } from "../interactive/intent-interview.js";
+import { validateDraft } from "../interactive/intent-schema.js";
+import { loadEffectiveInterviewConfig } from "../interview/config.js";
+import { loadEffectiveArtifactsConfig } from "../artifacts/config.js";
+import { generateArtifacts } from "../artifacts/generator.js";
+import { validate } from "../validator.js";
+import { generatePack } from "../packer.js";
+import { loadFramework } from "../../framework/framework-loader.js";
+import { writeJsonAtomic } from "../fs/atomic.js";
+import { ensureDir } from "../../lib.js";
+// --- Interview Step ---
+export const InterviewStep = {
+    async execute(state, config, root, runDir, options) {
+        const draftPath = path.join(runDir, "intent-draft.json");
+        // 1. Seed handling
+        if (options.seed) {
+            const seedPath = path.isAbsolute(options.seed) ? options.seed : path.resolve(root, options.seed);
+            if (!fs.existsSync(seedPath)) {
+                return { status: "failed", error: `Seed file not found: ${options.seed}` };
+            }
+            try {
+                const content = JSON.parse(fs.readFileSync(seedPath, "utf-8"));
+                // Validation
+                const val = validateDraft(content); // Basic check
+                if (!val.valid) {
+                    return { status: "failed", error: `Invalid seed draft: ${val.errors.join(", ")}` };
+                }
+                writeJsonAtomic(draftPath, content);
+                return { status: "done", outputs: ["intent-draft.json"] };
+            }
+            catch (e) {
+                return { status: "failed", error: `Failed to process seed: ${e.message}` };
+            }
+        }
+        // 2. Interactive
+        if (options.interactive) {
+            // Load framework resolution for config
+            const resolution = await resolveFramework(state, root);
+            const interviewConfig = loadEffectiveInterviewConfig(resolution);
+            // Run interactive
+            const draft = await runIntentInterview("", interviewConfig); // TODO: Resume logic?
+            if (!draft) {
+                return { status: "failed", error: "Interview cancelled" };
+            }
+            writeJsonAtomic(draftPath, draft);
+            return { status: "done", outputs: ["intent-draft.json"] };
+        }
+        // 3. Non-interactive (Blocked)
+        return {
+            status: "blocked",
+            reason: "Interview requires interactive mode or valid seed.",
+            error: "Cannot run interview in non-interactive mode without seed."
+        };
+    }
+};
+// --- Artifacts Step ---
+export const ArtifactsStep = {
+    async execute(state, config, root, runDir, options) {
+        const draftPath = path.join(runDir, "intent-draft.json");
+        if (!fs.existsSync(draftPath)) {
+            return { status: "failed", error: "Missing input: intent-draft.json" };
+        }
+        const draft = JSON.parse(fs.readFileSync(draftPath, "utf-8"));
+        const resolution = await resolveFramework(state, root);
+        const artifactsConfig = loadEffectiveArtifactsConfig(resolution);
+        // 4.7D SaaS Bootstrap injection
+        // If package.json missing, inject U000 into unit-list template
+        const packageJsonPath = path.join(root, "package.json");
+        if (!fs.existsSync(packageJsonPath)) {
+            const unitListDef = artifactsConfig.artifacts.find(a => a.id === "unit-list");
+            if (unitListDef && unitListDef.output.template) {
+                // Check if we already have U000
+                if (!unitListDef.output.template.includes("U000:")) {
+                    const injection = `        - [ ] U000: Repo Bootstrap
+              summary: Initialize project repository with basic structure and tooling.`;
+                    // Regex replace the first list item or insert after ## Units
+                    // The default template has "## Units"
+                    unitListDef.output.template = unitListDef.output.template.replace(/## Units\s*/, `## Units\n${injection}\n`);
+                }
+            }
+        }
+        try {
+            const result = generateArtifacts(draft, artifactsConfig, resolution, state.intentId);
+            // Write artifacts to runDir? Or to artifacts.json?
+            // Spec says "artifacts.json". But usually generateArtifacts returns contents step by step.
+            // We should save the `GeneratedArtifactsOutput` to `artifacts.json`.
+            // AND potentially write them to disk?
+            // "artifacts: template-only" -> usually writes to disk.
+            // `iris generate` writes to disk. `iris run` should probably do the same?
+            // Or just produce the JSON?
+            // "Save .iris/runs/<runId>/artifacts.json" implies we enable tooling to read it.
+            // Let's write artifacts.json containing the generated content.
+            // If the user wants files, they might need to be written to the project?
+            // Wait, "Step 7" `iris generate` writes to output path.
+            // "OS loop" -> should it modify the project?
+            // "Artifacts: call generateArtifacts... Input: draft... Save artifacts.json"
+            // It seems `iris run` is about accumulating state. Project mutation happens when?
+            // Ideally `iris run` prepares everything. 
+            // `validate` runs on REPO state. So artifacts MUST be written to repo for validate to pass?
+            // "Validation Plan" says "iris run ... verify run directory created".
+            // If artifacts are NOT written to repo, validate will fail if it checks for them?
+            // But `validate` checks *policy constraints* which might require artifacts.
+            // IF artifacts step doesn't write to repo, `validate` sees old repo.
+            // DECISION: Write artifacts to `artifacts.json` AND apply them to repo?
+            // Or does `pack` take them from `artifacts.json`?
+            // `pack` collects files from repo.
+            // SO: Artifacts MUST be written to repo to be useful for `validate` and `pack`.
+            // BUT: `iris run` should be safe?
+            // Start by writing to `artifacts.json`. 
+            // Writing to real files updates the project state.
+            // Let's assume for now we WRITE to repo, because otherwise validate/pack sees nothing.
+            const artifactsPath = path.join(runDir, "artifacts.json");
+            writeJsonAtomic(artifactsPath, result);
+            // Write to project (Side Effect)
+            for (const art of result.artifacts) {
+                // If it has a path? `GeneratedArtifact` has `id, content`.
+                // Artifact definition in `artifacts.yaml` has `out`.
+                // Transformation needed?
+                // `generateArtifacts` returns `GeneratedArtifact` which logic (in command) mapped to files.
+                // `src/iris/artifacts/generator.ts` does NOT write files. `src/commands/generate.ts` does.
+                // We need to map `result.artifacts` to files using `artifactsConfig.artifacts`.
+                const def = artifactsConfig.artifacts.find(d => d.id === art.id);
+                // Use interpolated path from generator if available
+                const relativePath = art.path || (def && def.out);
+                if (relativePath) {
+                    const outPath = path.join(root, relativePath);
+                    ensureDir(path.dirname(outPath));
+                    fs.writeFileSync(outPath, art.content);
+                }
+            }
+            return { status: "done", outputs: ["artifacts.json"] };
+        }
+        catch (e) {
+            return { status: "failed", error: e.message };
+        }
+    }
+};
+// --- Validate Step ---
+export const ValidateStep = {
+    async execute(state, config, root, runDir, options) {
+        const resolution = await resolveFramework(state, root);
+        try {
+            const result = await validate({
+                apply: false,
+                strict: true,
+                frameworkResolution: resolution
+            });
+            const validatePath = path.join(runDir, "validate.json");
+            writeJsonAtomic(validatePath, result);
+            if (!result.valid) {
+                return {
+                    status: "failed",
+                    error: `Validation failed with ${result.errors.length} errors.`,
+                    outputs: ["validate.json"]
+                };
+            }
+            return { status: "done", outputs: ["validate.json"] };
+        }
+        catch (e) {
+            return { status: "failed", error: `Validation exception: ${e.message}` };
+        }
+    }
+};
+// --- Pack Step ---
+export const PackStep = {
+    async execute(state, config, root, runDir, options) {
+        const resolution = await resolveFramework(state, root);
+        const packPath = path.join(runDir, "pack.md"); // Artifact
+        const packMetaPath = path.join(runDir, "pack.json"); // Metadata (files list etc)
+        try {
+            const result = await generatePack({
+                output: packPath,
+                json: true, // We want the metadata object returned
+                frameworkResolution: resolution,
+                stdout: false,
+                quiet: options.quiet // Suppress console output
+            });
+            // generatePack returns { path, size, fileCount } if not stdout
+            // It writes the file to `output`.
+            writeJsonAtomic(packMetaPath, result);
+            return { status: "done", outputs: ["pack.md", "pack.json"] };
+        }
+        catch (e) {
+            return { status: "failed", error: `Pack failed: ${e.message}` };
+        }
+    }
+};
+// --- Handoff Step ---
+export const HandoffStep = {
+    async execute(state, config, root, runDir, options) {
+        const handoffJsonPath = path.join(runDir, "handoff.json");
+        const handoffMdPath = path.join(runDir, "handoff.md");
+        const handoffData = {
+            schemaVersion: 1,
+            runId: state.runId,
+            framework: state.framework,
+            files: {
+                intentDraft: path.join(runDir, "intent-draft.json"),
+                artifacts: path.join(runDir, "artifacts.json"),
+                validate: path.join(runDir, "validate.json"),
+                pack: path.join(runDir, "pack.md")
+            },
+            nextActions: ["Review plan", "Execute bolts"], // Placeholder or derived?
+            timestamp: new Date().toISOString()
+        };
+        writeJsonAtomic(handoffJsonPath, handoffData);
+        const mdContent = `# IRIS Handoff
+Run ID: ${state.runId}
+Framework: ${state.framework.id}
+
+## Files
+- [Intent Draft](file://${handoffData.files.intentDraft})
+- [Artifacts](file://${handoffData.files.artifacts})
+- [Validation Report](file://${handoffData.files.validate})
+- [Context Pack](file://${handoffData.files.pack})
+
+## Next Actions
+${handoffData.nextActions.map(a => `- ${a}`).join("\n")}
+`;
+        fs.writeFileSync(handoffMdPath, mdContent);
+        return { status: "done", outputs: ["handoff.json", "handoff.md"] };
+    }
+};
+// Helper
+async function resolveFramework(state, root) {
+    if (state.framework.id) {
+        return await loadFramework(state.framework.id, { repoRoot: root });
+    }
+    return null;
+}
+// --- Planning Step ---
+export const PlanningStep = {
+    async execute(state, config, root, runDir, options) {
+        if (!state.intentId) {
+            return { status: "failed", error: "Missing intentId in state" };
+        }
+        const unitListPath = path.join(root, "memory-bank", "intents", state.intentId, "unit-list.md");
+        if (!fs.existsSync(unitListPath)) {
+            return { status: "failed", error: `Missing unit-list artifact at ${unitListPath}` };
+        }
+        try {
+            const { parseUnitList } = await import("../parsers/unit-parser.js");
+            const { UNIT_BRIEF_TEMPLATE } = await import("../templates.js");
+            const { interpolateTokens } = await import("../utils/interpolate.js"); // If needed for other paths
+            const content = fs.readFileSync(unitListPath, "utf-8");
+            const units = parseUnitList(content);
+            const outputs = [];
+            for (const unit of units) {
+                const unitDir = path.join(root, "memory-bank", "intents", state.intentId, "units", unit.id);
+                ensureDir(unitDir);
+                const briefPath = path.join(unitDir, "unit-brief.md");
+                // Skip if exists and not forced
+                if (fs.existsSync(briefPath) && !options.force) {
+                    outputs.push(briefPath);
+                    continue;
+                }
+                // Render Template
+                let briefContent = UNIT_BRIEF_TEMPLATE
+                    .replace("{{unitId}}", unit.id)
+                    .replace("{{title}}", unit.title)
+                    .replace("{{summary}}", unit.summary);
+                fs.writeFileSync(briefPath, briefContent);
+                outputs.push(briefPath);
+            }
+            return { status: "done", outputs };
+        }
+        catch (e) {
+            return { status: "failed", error: `Planning step failed: ${e.message}` };
+        }
+    }
+};
+// --- Construction Step ---
+export const ConstructionStep = {
+    async execute(state, config, root, runDir, options) {
+        if (!state.intentId)
+            return { status: "failed", error: "Missing intentId" };
+        const unitsDir = path.join(root, "memory-bank", "intents", state.intentId, "units");
+        if (!fs.existsSync(unitsDir)) {
+            // If no units, we can't construct anything. Should validation fail first?
+            // Or is this valid "nothing to do"? 
+            // If planning succeeded but produced no units (unlikely), we do nothing.
+            return { status: "done", outputs: [] };
+        }
+        try {
+            const { BOLT_TEMPLATE } = await import("../templates.js");
+            const glob = (await import("fast-glob")).default;
+            // Find all APPROVED unit briefs
+            const briefPattern = path.join(unitsDir, "*", "unit-brief.md");
+            // Fast-glob expects forward slashes, handle windows? internal logic usually handles it.
+            // Using absolute path might be tricky with glob. Relative logic is safer.
+            const relUnitsDir = path.relative(process.cwd(), unitsDir);
+            const briefs = await glob(path.join(relUnitsDir, "*", "unit-brief.md").replace(/\\/g, "/"), { cwd: process.cwd() });
+            const outputs = [];
+            // TODO: In future, track which bolts are already generated for which unit.
+            // For MVP: 1 Bolt per Unit.
+            // Check if bolt exists for unit.
+            // Or just read frontmatter? We need matter.
+            const matter = (await import("gray-matter")).default;
+            for (const briefRel of briefs) {
+                const briefPath = path.resolve(process.cwd(), briefRel);
+                const content = fs.readFileSync(briefPath, 'utf-8');
+                const parsed = matter(content);
+                if (parsed.data.status !== 'approved')
+                    continue;
+                const unitId = parsed.data.id;
+                const unitTitle = (content.match(/^# Unit Brief: (.+)$/m) || [])[1] || "Untitled"; // Fallback title parsing
+                // Generate Bolt ID: B001 (How to map U001 -> B001?)
+                // If we assume 1-to-1, maybe B<UnitNumber>? Or global counter?
+                // Let's use B + UnitNumber for simplicity if U001 -> B001.
+                // Or just B001 for first bolt of unit.
+                const boltId = `B${unitId.replace(/^U/, '')}.1`; // U001 -> B001.1? U001 -> B001 check
+                const boltsDir = path.join(path.dirname(briefPath), "bolts");
+                ensureDir(boltsDir);
+                // Slugify title
+                const slug = unitTitle.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
+                const boltDirName = `${boltId}-${slug}`;
+                const boltDir = path.join(boltsDir, boltDirName);
+                ensureDir(boltDir);
+                const boltPath = path.join(boltDir, "bolt.md");
+                if (fs.existsSync(boltPath) && !options.force) {
+                    outputs.push(boltPath);
+                    continue;
+                }
+                let boltContent = BOLT_TEMPLATE
+                    .replace("{{boltId}}", boltId)
+                    .replace("{{unitId}}", unitId)
+                    .replace("{{title}}", unitTitle);
+                fs.writeFileSync(boltPath, boltContent);
+                outputs.push(boltPath);
+            }
+            return { status: "done", outputs };
+        }
+        catch (e) {
+            return { status: "failed", error: `Construction step failed: ${e.message}` };
+        }
+    }
+};
+// --- Execution Step ---
+export const ExecutionStep = {
+    async execute(state, config, root, runDir, options) {
+        if (!state.intentId)
+            return { status: "failed", error: "Missing intentId" };
+        const unitsDir = path.join(root, "memory-bank", "intents", state.intentId, "units");
+        if (!fs.existsSync(unitsDir)) {
+            return { status: "done", outputs: [] };
+        }
+        try {
+            const { TEST_REPORT_TEMPLATE } = await import("../templates.js");
+            const glob = (await import("fast-glob")).default;
+            const matter = (await import("gray-matter")).default;
+            const { spawnAsync } = await import("../../lib.js"); // Assume lib.ts is in ../../lib.ts relative to steps.ts
+            // Find all bolts under units
+            const pattern = path.join(path.relative(process.cwd(), unitsDir), "*", "bolts", "*", "bolt.md").replace(/\\/g, "/");
+            const boltFiles = await glob(pattern, { cwd: process.cwd() });
+            let executedCount = 0;
+            const outputs = [];
+            let hasFailures = false;
+            for (const boltRel of boltFiles) {
+                const boltPath = path.resolve(process.cwd(), boltRel);
+                const content = fs.readFileSync(boltPath, 'utf-8');
+                const parsed = matter(content);
+                // Run ONLY if status is 'approved'
+                // If 'done' or 'failed', we skip unless force? 
+                // Wait, if failed, user fixes code and resets status or we re-run?
+                // If status is 'failed' and user updated code (fs mtime?), can we detect?
+                // Simplest MVP: User must manually set status to 'approved' to re-run.
+                if (parsed.data.status !== 'approved')
+                    continue;
+                // Mark in_progress
+                /*
+                // Updating bolt file status complicates things if we fail mid-write.
+                // But we should to indicate activity.
+                const inProgressContent = content.replace(/^status: .*$/m, "status: in_progress");
+                fs.writeFileSync(boltPath, inProgressContent);
+                */
+                // Actually, if we mark in_progress, and crash, user sees in_progress.
+                // Let's run test.
+                const boltCwd = parsed.data.cwd || ".";
+                const testCmd = parsed.data.commands?.test;
+                if (!testCmd) {
+                    outputs.push(`${boltRel} (skipped: no test command)`);
+                    continue;
+                }
+                if (!options.quiet)
+                    console.log(`Running tests for ${parsed.data.id}...`);
+                // Execute
+                const absCwd = path.resolve(path.dirname(boltPath), boltCwd);
+                // Ensure cwd exists
+                if (!fs.existsSync(absCwd)) {
+                    // Fail bolt?
+                    console.error(`CWD not found: ${absCwd}`);
+                    continue;
+                }
+                // If testCmd has "npm ", make sure npm is valid? spawnAsync handles shell: true.
+                const { code, stdout, stderr } = await spawnAsync(testCmd, [], absCwd);
+                const status = code === 0 ? "done" : "failed";
+                if (status === "failed")
+                    hasFailures = true;
+                // Update Bolt Status
+                // We use replace to update status field.
+                // Re-read content in case changed? No, we are lock-step.
+                const newContent = content.replace(/^status: .*$/m, `status: ${status}`);
+                fs.writeFileSync(boltPath, newContent);
+                // Write Test Report
+                const reportPath = path.join(path.dirname(boltPath), "test-report.md");
+                const report = TEST_REPORT_TEMPLATE
+                    .replace(/{{boltId}}/g, parsed.data.id)
+                    .replace(/{{status}}/g, status)
+                    .replace(/{{title}}/g, parsed.data.id || "Untitled")
+                    .replace(/{{timestamp}}/g, new Date().toISOString())
+                    .replace("{{output}}", stdout + "\n" + stderr);
+                fs.writeFileSync(reportPath, report);
+                outputs.push(`${parsed.data.id}: ${status}`);
+                executedCount++;
+            }
+            if (executedCount === 0) {
+                // No approved bolts found.
+                // Should we return 'done'?
+                return { status: "done", outputs: ["No approved bolts to execute"] };
+            }
+            // If we ran bolts, and some failed, should execute step fail?
+            // "Run loop" implies we want to see failure in CLI?
+            // But if we return 'failed', workflow stops.
+            // If we return 'done', workflow continues to 'validate'.
+            // If bolts failed, validation might fail if policy checks test-reports.
+            // Generally, execution step is "done" (it finished executing). 
+            // The *Result* of execution is persisted in artifacts.
+            // If strict is on, maybe fail?
+            // Let's return 'done' but with outputs indicating status.
+            return { status: "done", outputs };
+        }
+        catch (e) {
+            return { status: "failed", error: `Execution step failed: ${e.message}` };
+        }
+    }
+};
+export const EXEC_REGISTRY = {
+    interview: InterviewStep,
+    artifacts: ArtifactsStep,
+    planning: PlanningStep,
+    construction: ConstructionStep,
+    execution: ExecutionStep,
+    validate: ValidateStep,
+    pack: PackStep,
+    handoff: HandoffStep
+};

package/dist/iris/workflow/types.js

@@ -0,0 +1 @@
+export {};