iriai-build 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iriai-build",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Iriai Build tool — AI agent orchestration CLI",
   "type": "module",
   "bin": {

package/v3/orchestrator.js

@@ -469,67 +469,43 @@ export class Orchestrator {
         this._notifyOperatorOfDecision(feature, planDecision);
       }
     } else if (role === "ux-designer") {
-      // Compound design step: ux-designer done → dispatch ui-designer (no phase-review yet)
-      await this.adapter.postPipelineMessage(feature.id,
-        `UX Designer complete. Starting UI Designer...`);
-      queries.updateFeaturePlanningRole(feature.id, "ui-designer");
-      this.dispatchPlanningRole(feature.id, "ui-designer");
-    } else if (role === "ui-designer") {
-      // Compound design step: ui-designer done → surface as "designer" phase-review
-      // Both sub-roles are complete; present combined output for user approval
-      await this._requestPhaseReview(feature, "designer", output);
-    } else if (role === "architect") {
-      // Architect validation: ensure structured plan directory before review gate.
-      // The architect often drifts to writing a monolithic architecture doc
-      // instead of the structured plan directory (plan.yaml + phases/ + task files).
-      // Validate required artifacts and redispatch if incomplete.
+      // Validate UX designer output before proceeding to UI designer
       const planDir = path.join(feature.signal_dir, "plans");
-      const validation = this._validateArchitectOutput(planDir);
-
-      if (validation.pass) {
-        await this._requestPhaseReview(feature, role, output);
+      const validation = this._validatePlanningOutput(role, planDir);
+      if (!validation.pass) {
+        await this.adapter.postPipelineMessage(feature.id,
+          `UX Designer output incomplete (missing: ${validation.missing.join(", ")}). Redispatching...`);
+        this._redispatchForMissingArtifacts(feature, role, validation);
       } else {
-        // Redispatch architect with focused instructions
-        console.log(`[orchestrator] Architect output incomplete for ${slug}: missing ${validation.missing.join(", ")}`);
+        // Compound design step: ux-designer done → dispatch ui-designer (no phase-review yet)
         await this.adapter.postPipelineMessage(feature.id,
-          `Architect investigation complete — redispatching for structured plan output (missing: ${validation.missing.join(", ")})`);
-
-        const signalDir = path.join(feature.signal_dir, "planning", "architect");
-        ensureDir(signalDir);
-
-        // Write focused redispatch instructions as .user-message so the agent picks it up
-        const redispatchMsg = [
-          `STRUCTURED PLAN OUTPUT REQUIRED`,
-          ``,
-          `Your investigation phase is complete. You wrote a thorough context.md in $PLAN_DIR/.`,
-          `Now you MUST produce the structured plan directory. Read your CLAUDE.md "Output Format" section carefully.`,
-          ``,
-          `WHAT EXISTS (do NOT redo):`,
-          validation.found.map(f => `  ✓ ${f}`).join("\n"),
-          ``,
-          `WHAT IS MISSING (you must create these):`,
-          validation.missing.map(f => `  ✗ ${f}`).join("\n"),
-          ``,
-          `INSTRUCTIONS:`,
-          `1. Read $PLAN_DIR/context.md for your investigation notes — do NOT re-explore the entire codebase`,
-          `2. Do targeted source code reads ONLY where you need specific file paths, function signatures, or line numbers for task files`,
-          `3. Produce plan.yaml with phase DAG, role assignments, and journey refs`,
-          `4. Create phases/ directory with structured task files (YAML frontmatter + detailed instructions)`,
-          `5. Create journeys/ directory with test journeys (happy-path, failure, regression)`,
-          `6. Every task file must cite real file paths and code evidence from the codebase`,
-          `7. Signal .done + .output when complete`,
-          ``,
-          `Your context.md is the foundation. Build the structured plan ON TOP of it.`,
-        ].join("\n");
-
-        writeSignal(path.join(signalDir, SIGNAL.USER_MESSAGE), redispatchMsg);
-        queries.updateFeaturePlanningRole(feature.id, "architect");
-        // Fresh context — investigation session is done, architect needs full budget for structured output
-        this.dispatchPlanningRole(feature.id, "architect", { continue: false });
+          `UX Designer complete. Starting UI Designer...`);
+        queries.updateFeaturePlanningRole(feature.id, "ui-designer");
+        this.dispatchPlanningRole(feature.id, "ui-designer");
+      }
+    } else if (role === "ui-designer") {
+      // Validate UI designer output before surfacing combined design review
+      const planDir = path.join(feature.signal_dir, "plans");
+      const validation = this._validatePlanningOutput(role, planDir);
+      if (!validation.pass) {
+        await this.adapter.postPipelineMessage(feature.id,
+          `UI Designer output incomplete (missing: ${validation.missing.join(", ")}). Redispatching...`);
+        this._redispatchForMissingArtifacts(feature, role, validation);
+      } else {
+        // Both sub-roles complete; present combined output for user approval
+        await this._requestPhaseReview(feature, "designer", output);
       }
     } else {
-      // Non-final role → summary + artifact upload + Block Kit review gate (all sequential)
-      await this._requestPhaseReview(feature, role, output);
+      // All other roles (pm, architect, designer): validate then review gate
+      const planDir = path.join(feature.signal_dir, "plans");
+      const validation = this._validatePlanningOutput(role, planDir);
+      if (!validation.pass) {
+        await this.adapter.postPipelineMessage(feature.id,
+          `${PLANNING_ROLE_LABELS[role] || role} output incomplete (missing: ${validation.missing.join(", ")}). Redispatching...`);
+        this._redispatchForMissingArtifacts(feature, role, validation);
+      } else {
+        await this._requestPhaseReview(feature, role, output);
+      }
     }
 
     } finally {
@@ -539,69 +515,124 @@ export class Orchestrator {
   }
 
   /**
-   * Validate that the architect produced the required structured plan directory.
-   * Auto-normalizes architecture.md → context.md if needed.
-   * Returns { pass: boolean, found: string[], missing: string[] }
+   * Artifact requirements per planning role.
+   * Each entry: { label, check(planDir) → boolean }
    */
-  _validateArchitectOutput(planDir) {
-    const found = [];
-    const missing = [];
+  static ROLE_ARTIFACTS = {
+    pm: [
+      { label: "PRD document (*-prd.md)", check: (d) => !!findArtifact("prd", d) },
+    ],
+    "ux-designer": [
+      { label: "design-decisions.md", check: (d) => !!findArtifact("design-decisions", d) },
+    ],
+    "ui-designer": [
+      { label: "design-decisions.md (with Visual Design Language)", check: (d) => {
+        const content = findArtifact("design-decisions", d);
+        if (!content) return false;
+        try {
+          const text = fs.readFileSync(content, "utf-8");
+          return text.includes("Visual Design Language") || text.includes("Color Palette");
+        } catch { return false; }
+      }},
+      { label: "mockup.html", check: (d) => fs.existsSync(path.join(d, "mockup.html")) },
+    ],
+    designer: [
+      { label: "design-decisions.md", check: (d) => !!findArtifact("design-decisions", d) },
+      { label: "mockup.html", check: (d) => fs.existsSync(path.join(d, "mockup.html")) },
+    ],
+    architect: [
+      { label: "context.md (investigation notes)", check: (d) => !!findArtifact("context", d) || !!findArtifact("architecture", d) },
+      { label: "plan.yaml (phase DAG)", check: (d) => fs.existsSync(path.join(d, "plan.yaml")) },
+      { label: "phases/ (task files)", check: (d) => {
+        try {
+          return fs.readdirSync(path.join(d, "phases"), { withFileTypes: true }).some(e => e.isDirectory());
+        } catch { return false; }
+      }},
+      { label: "journeys/ (test journeys)", check: (d) => {
+        try {
+          return fs.readdirSync(path.join(d, "journeys")).some(e => e.endsWith(".md"));
+        } catch { return false; }
+      }},
+    ],
+  };
 
-    // Normalize: rename architecture.md → context.md if architect used wrong name
-    const archFile = path.join(planDir, "architecture.md");
-    const contextFile = path.join(planDir, "context.md");
-    if (fs.existsSync(archFile) && !fs.existsSync(contextFile)) {
-      try {
-        fs.renameSync(archFile, contextFile);
-        console.log(`[orchestrator] Renamed architecture.md → context.md in ${planDir}`);
-      } catch { /* ok, proceed with whatever exists */ }
+  /**
+   * Validate that a planning role produced its required artifacts.
+   * Runs auto-normalization (e.g. architecture.md → context.md) before checking.
+   * Returns { pass, found, missing }
+   */
+  _validatePlanningOutput(role, planDir) {
+    // Auto-normalize known filename drift
+    if (role === "architect") {
+      const archFile = path.join(planDir, "architecture.md");
+      const contextFile = path.join(planDir, "context.md");
+      if (fs.existsSync(archFile) && !fs.existsSync(contextFile)) {
+        try {
+          fs.renameSync(archFile, contextFile);
+          console.log(`[orchestrator] Renamed architecture.md → context.md in ${planDir}`);
+        } catch { /* ok */ }
+      }
     }
 
-    // Check context.md (investigation notes)
-    if (findArtifact("context", planDir) || findArtifact("architecture", planDir)) {
-      found.push("context.md (investigation notes)");
-    } else {
-      missing.push("context.md (investigation notes)");
-    }
+    const artifacts = Orchestrator.ROLE_ARTIFACTS[role];
+    if (!artifacts) return { pass: true, found: [], missing: [] };
 
-    // Check plan.yaml (phase DAG metadata)
-    if (fs.existsSync(path.join(planDir, "plan.yaml"))) {
-      found.push("plan.yaml (phase DAG)");
-    } else {
-      missing.push("plan.yaml (phase DAG + metadata)");
+    const found = [];
+    const missing = [];
+    for (const art of artifacts) {
+      if (art.check(planDir)) {
+        found.push(art.label);
+      } else {
+        missing.push(art.label);
+      }
     }
 
-    // Check phases/ directory with at least one phase subdirectory
-    const phasesDir = path.join(planDir, "phases");
-    let hasPhases = false;
-    try {
-      const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
-      hasPhases = entries.some(e => e.isDirectory());
-    } catch { /* doesn't exist */ }
-    if (hasPhases) {
-      found.push("phases/ (task files)");
-    } else {
-      missing.push("phases/ directory with task files");
-    }
+    return { pass: missing.length === 0, found, missing };
+  }
 
-    // Check journeys/ directory
-    const journeysDir = path.join(planDir, "journeys");
-    let hasJourneys = false;
-    try {
-      const entries = fs.readdirSync(journeysDir);
-      hasJourneys = entries.some(e => e.endsWith(".md"));
-    } catch { /* doesn't exist */ }
-    if (hasJourneys) {
-      found.push("journeys/ (test journeys)");
-    } else {
-      missing.push("journeys/ (test journeys)");
+  /**
+   * Redispatch a planning role that produced incomplete output.
+   * Writes focused instructions to .user-message and re-spawns with fresh context.
+   */
+  _redispatchForMissingArtifacts(feature, role, validation) {
+    const slug = feature.slug;
+    console.log(`[orchestrator] ${role} output incomplete for ${slug}: missing ${validation.missing.join(", ")}`);
+
+    const signalDir = path.join(feature.signal_dir, "planning", role);
+    ensureDir(signalDir);
+
+    const roleName = PLANNING_ROLE_LABELS[role] || role;
+    const lines = [
+      `INCOMPLETE OUTPUT — REDISPATCH`,
+      ``,
+      `You signaled .done but required artifacts are missing.`,
+      `Read your CLAUDE.md output format section and produce the missing items.`,
+      ``,
+      `WHAT EXISTS (do NOT redo):`,
+      ...validation.found.map(f => `  ✓ ${f}`),
+      ``,
+      `WHAT IS MISSING (you MUST create these):`,
+      ...validation.missing.map(f => `  ✗ ${f}`),
+      ``,
+      `Write the missing artifacts to $PLAN_DIR/, then signal .done + .output again.`,
+    ];
+
+    // Role-specific guidance
+    if (role === "architect") {
+      lines.push(
+        ``,
+        `ARCHITECT-SPECIFIC:`,
+        `1. Read $PLAN_DIR/context.md for your investigation notes — do NOT re-explore the entire codebase`,
+        `2. Do targeted source code reads ONLY where needed for specific file paths or function signatures`,
+        `3. Every task file must cite real file paths and code evidence from the codebase`,
+      );
     }
 
-    return {
-      pass: missing.length === 0,
-      found,
-      missing,
-    };
+    writeSignal(path.join(signalDir, SIGNAL.USER_MESSAGE), lines.join("\n"));
+    queries.updateFeaturePlanningRole(feature.id, role);
+
+    // Fresh context for the structured output pass
+    this.dispatchPlanningRole(feature.id, role, { continue: false });
   }
 
   /**