iriai-build 0.4.3 → 0.5.0

package/package.json

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

package/v3/orchestrator.js

@@ -450,17 +450,18 @@ export class Orchestrator {
 
         // Start interactive plan review session (compiled tabbed HTML)
         let reviewUrl = null;
+        const planDecisionId = `plan-approval@${feature.slug}`;
         if (this.reviewSessions) {
           const compiledPath = compilePlanReviewHtml(planDir);
           if (compiledPath) {
             reviewUrl = await this.reviewSessions.startDocReview(
-              "plan-approval", compiledPath, "Plan Review", { featureId: feature.id }
+              planDecisionId, compiledPath, "Plan Review", { featureId: feature.id }
             );
           }
         }
 
         const planDecision = {
-          id: "plan-approval",
+          id: planDecisionId,
           title: "Plan ready for approval",
           context: "All planning phases complete. Review the artifacts.",
           options: [
@@ -888,22 +889,27 @@ export class Orchestrator {
     if (feature.phase === "plan-approval") {
       // Restore or start plan review session
       let reviewUrl = null;
+      const planDecisionId = `plan-approval@${feature.slug}`;
       if (this.reviewSessions) {
-        reviewUrl = await this.reviewSessions.restoreSession("plan-approval");
+        reviewUrl = await this.reviewSessions.restoreSession(planDecisionId);
+        if (!reviewUrl) {
+          // Try legacy key for in-flight features with old sessions
+          reviewUrl = await this.reviewSessions.restoreSession("plan-approval");
+        }
         if (!reviewUrl) {
           // No prior session — compile and start fresh
           const planDir = path.join(feature.signal_dir, "plans");
           const compiledPath = compilePlanReviewHtml(planDir);
           if (compiledPath) {
             reviewUrl = await this.reviewSessions.startDocReview(
-              "plan-approval", compiledPath, "Plan Review", { featureId }
+              planDecisionId, compiledPath, "Plan Review", { featureId }
             );
           }
         }
       }
 
       const decision = {
-        id: "plan-approval",
+        id: planDecisionId,
         title: "Plan ready for approval",
         context: "All planning phases complete. Review the artifacts.",
         options: [
@@ -1559,6 +1565,7 @@ export class Orchestrator {
           dashboardLog: path.join(tree.featureDir, ".dashboard-log"),
           questionTeams: opts.questionTeams,
           crashedTeams: opts.crashedTeams,
+          gateTeams: opts.gateTeams,
           recoveryContext: opts.recoveryContext,
           featureDir: tree.featureDir,
           teamWorktreeBase: path.join(PROJECT_ROOT, ".features", feature.slug, "teams"),
@@ -1604,12 +1611,23 @@ export class Orchestrator {
     const tree = this._signalTrees[feature.slug];
     if (!tree?.featureLead) return;
 
+    // Read which teams were under review (written at gate-ready trigger time)
+    const reviewTeamsFile = path.join(tree.featureDir, ".gate-review-teams");
+    let reviewTeams;
+    try {
+      reviewTeams = JSON.parse(fs.readFileSync(reviewTeamsFile, "utf-8"));
+      fs.unlinkSync(reviewTeamsFile);
+    } catch {
+      // Fallback: all teams (backward compat for in-flight features without the file)
+      reviewTeams = Object.keys(tree.teams);
+    }
+
     writeSignal(path.join(tree.featureLead, SIGNAL.USER_MESSAGE),
-      "GATE APPROVED. Advance all teams to the next phase.");
+      `GATE APPROVED. Advance teams ${reviewTeams.join(", ")} to the next phase. Other teams are unaffected.`);
 
     queries.updateFeatureGateEvidenceTs(featureId, null);
     queries.updateFeatureGate(featureId, (feature.gate_number || 0) + 1);
-    queries.insertEvent(featureId, "gate-approved", "bridge", `Gate ${(feature.gate_number || 0) + 1} approved by user`);
+    queries.insertEvent(featureId, "gate-approved", "bridge", `Gate ${(feature.gate_number || 0) + 1} approved (teams ${reviewTeams.join(", ")})`);
   }
 
   async handleGateRejection(featureId, reason) {
@@ -1618,20 +1636,153 @@ export class Orchestrator {
     const tree = this._signalTrees[feature.slug];
     if (!tree?.featureLead) return;
 
+    // Read which teams were under review
+    const reviewTeamsFile = path.join(tree.featureDir, ".gate-review-teams");
+    let reviewTeams;
+    try {
+      reviewTeams = JSON.parse(fs.readFileSync(reviewTeamsFile, "utf-8"));
+      fs.unlinkSync(reviewTeamsFile);
+    } catch {
+      reviewTeams = Object.keys(tree.teams);
+    }
+
     writeSignal(path.join(tree.featureLead, SIGNAL.USER_MESSAGE),
-      `GATE REJECTED: ${reason || "Please revise and resubmit."}`);
+      `GATE REJECTED (teams ${reviewTeams.join(", ")}): ${reason || "Please revise and resubmit."}`);
 
     queries.updateFeatureGateEvidenceTs(featureId, null);
-    queries.insertEvent(featureId, "gate-rejected", "bridge", `Gate rejected: ${reason}`);
+    queries.insertEvent(featureId, "gate-rejected", "bridge", `Gate rejected (teams ${reviewTeams.join(", ")}): ${reason}`);
+  }
+
+  // ─── Gate Team Dependency Resolution ─────────────────────────────────
+
+  /**
+   * Derive which teams must sync for a gate, based on plan.yaml phase dependencies.
+   * Teams whose current phases have cross-dependencies form a gate group.
+   * Falls back to all teams if plan.yaml is unavailable.
+   *
+   * @param {string} slug - Feature slug
+   * @param {string} triggeringTeam - Team number that signaled gate-ready
+   * @returns {string[]} Array of team numbers in the gate group
+   */
+  _getGateTeams(slug, triggeringTeam) {
+    const tree = this._signalTrees[slug];
+    if (!tree) return [triggeringTeam];
+
+    const allTeamNums = Object.keys(tree.teams);
+    if (allTeamNums.length <= 1) return allTeamNums.length ? allTeamNums : [triggeringTeam];
+
+    // Read plan.yaml for phase dependency graph
+    const planYamlPath = tree.plansDir
+      ? path.join(tree.plansDir, "plan.yaml")
+      : path.join(tree.featureDir, "plans", "plan.yaml");
+
+    let phaseDeps;
+    try {
+      const content = fs.readFileSync(planYamlPath, "utf-8");
+      phaseDeps = this._parsePhaseDependencies(content);
+    } catch {
+      // No plan.yaml — fall back to all teams (safe default, old behavior)
+      console.log(`[orchestrator] No plan.yaml for ${slug}, falling back to all-teams gate check`);
+      return allTeamNums;
+    }
+
+    // Read each team's manifest to get their current phases
+    const teamPhases = {};
+    for (const tn of allTeamNums) {
+      const manifestPath = path.join(tree.teams[tn].dir, "manifest.yaml");
+      try {
+        const manifest = fs.readFileSync(manifestPath, "utf-8");
+        // Parse gate_phases (new field) or fall back to current_phase
+        const gatePhasesMatch = manifest.match(/^gate_phases:\s*\[([^\]]*)\]/m);
+        if (gatePhasesMatch) {
+          teamPhases[tn] = gatePhasesMatch[1].split(",").map(s => s.trim().replace(/['"]/g, "")).filter(Boolean);
+        } else {
+          const currentPhaseMatch = manifest.match(/^current_phase:\s*(\S+)/m);
+          teamPhases[tn] = currentPhaseMatch ? [currentPhaseMatch[1]] : [];
+        }
+      } catch {
+        teamPhases[tn] = [];
+      }
+    }
+
+    // Build gate group: triggering team + any team with cross-phase dependencies
+    const myPhases = new Set(teamPhases[triggeringTeam] || []);
+    const gateTeams = new Set([triggeringTeam]);
+
+    for (const tn of allTeamNums) {
+      if (tn === triggeringTeam) continue;
+      const otherPhases = new Set(teamPhases[tn] || []);
+
+      // Check: do any of my phases depend on any of their phases?
+      for (const myPhase of myPhases) {
+        for (const dep of (phaseDeps[myPhase] || [])) {
+          if (otherPhases.has(dep)) gateTeams.add(tn);
+        }
+      }
+      // Check: do any of their phases depend on any of my phases?
+      for (const otherPhase of otherPhases) {
+        for (const dep of (phaseDeps[otherPhase] || [])) {
+          if (myPhases.has(dep)) gateTeams.add(tn);
+        }
+      }
+    }
+
+    return [...gateTeams];
+  }
+
+  /**
+   * Parse phase dependency graph from plan.yaml content.
+   * Returns { phaseId: [dep1, dep2, ...] } map.
+   * Uses simple regex parsing (no yaml library).
+   * Only parses the `phases:` block — ignores journeys and other top-level keys.
+   */
+  _parsePhaseDependencies(content) {
+    // Extract only the phases: block (stop at next top-level key or end of file)
+    const phasesMatch = content.match(/^phases:\s*\n([\s\S]*?)(?=\n[a-zA-Z])/m)
+      || content.match(/^phases:\s*\n([\s\S]*)$/m);
+    if (!phasesMatch) return {};
+    const phasesBlock = phasesMatch[1];
+
+    const deps = {};
+    const phaseEntries = phasesBlock.split(/(?=^\s*-\s+id:\s)/m);
+    for (const block of phaseEntries) {
+      const idMatch = block.match(/^\s*-?\s*id:\s*(\S+)/m);
+      if (!idMatch) continue;
+      const phaseId = idMatch[1];
+      const depsMatch = block.match(/depends_on:\s*\[([^\]]*)\]/);
+      if (depsMatch && depsMatch[1].trim()) {
+        deps[phaseId] = depsMatch[1].split(",").map(s => s.trim().replace(/['"]/g, "")).filter(Boolean);
+      } else {
+        deps[phaseId] = [];
+      }
+    }
+    return deps;
   }
 
   // ─── Decision Click Routing (Block Kit Buttons) ──────────────────────
 
   async handleDecisionClick(decisionId, optionId, userId, channel, messageTs, feedback = "", route = "") {
     // Collect annotations from review session and enrich rejection feedback
+    // Review session keys are scoped by feature: try scoped key first, then bare decisionId
     let enrichedFeedback = feedback;
     if (this.reviewSessions && optionId !== "approve") {
-      const annotations = await this.reviewSessions.collectFeedback(decisionId);
+      let annotations = null;
+      // For plan-approval and gate decisions, the session key includes @<slug>
+      // Try to find the scoped session by looking up feature from channel
+      if (decisionId === "plan-approval" || decisionId.startsWith("plan-approval@") || decisionId.startsWith("gate-")) {
+        const features = queries.getActiveFeatures();
+        const feature = features.find(f => {
+          const fChannel = f.feature_channel || this.adapter?.planningChannel;
+          return fChannel === channel;
+        });
+        if (feature) {
+          const scopedKey = decisionId.includes("@") ? decisionId : `${decisionId}@${feature.slug}`;
+          annotations = await this.reviewSessions.collectFeedback(scopedKey);
+        }
+      }
+      if (!annotations) {
+        annotations = await this.reviewSessions.collectFeedback(decisionId);
+      }
       if (annotations && annotations.length > 0) {
         enrichedFeedback = formatAnnotationsAsFeedback(annotations, feedback);
       }
@@ -1675,15 +1826,22 @@ export class Orchestrator {
       return;
     }
 
-    // Plan approval: "plan-approval"
-    if (decisionId === "plan-approval") {
-      const features = queries.getActiveFeatures();
-      // Use channel to disambiguate when multiple features are in plan-approval
-      const feature = features.find(f => {
-        if (f.phase !== "plan-approval") return false;
-        const fChannel = f.feature_channel || this.adapter.planningChannel;
-        return fChannel === channel;
-      });
+    // Plan approval: "plan-approval@<slug>" (or legacy bare "plan-approval")
+    if (decisionId === "plan-approval" || decisionId.startsWith("plan-approval@")) {
+      let feature;
+      // New format: plan-approval@<slug> — extract slug directly
+      const slugMatch = decisionId.match(/^plan-approval@(.+)$/);
+      if (slugMatch) {
+        feature = queries.getFeatureBySlug(slugMatch[1]);
+      } else {
+        // Legacy fallback: bare "plan-approval" — use channel to disambiguate
+        const features = queries.getActiveFeatures();
+        feature = features.find(f => {
+          if (f.phase !== "plan-approval") return false;
+          const fChannel = f.feature_channel || this.adapter.planningChannel;
+          return fChannel === channel;
+        });
+      }
       if (!feature) return;
 
       if (optionId === "approve") {
@@ -1708,7 +1866,15 @@ export class Orchestrator {
         await this.handleGateRejection(feature.id, enrichedFeedback || "Rejected via button");
       }
       await this._resolveDecisionMessage(feature.id, messageTs, decisionId, optionId, userId, feedback);
-      if (this.reviewSessions) await this.reviewSessions.stop(decisionId);
+      // Review session key is scoped by feature slug — try scoped key, fall back to bare decisionId
+      if (this.reviewSessions) {
+        const scopedKey = `${decisionId}@${feature.slug}`;
+        if (this.reviewSessions.hasSession(scopedKey)) {
+          await this.reviewSessions.stop(scopedKey);
+        } else {
+          await this.reviewSessions.stop(decisionId);
+        }
+      }
       return;
     }
 
@@ -1818,7 +1984,7 @@ export class Orchestrator {
     // Plan approval
     if (feature.phase === "plan-approval") {
       return {
-        id: "plan-approval",
+        id: `plan-approval@${feature.slug}`,
         options: [
           { id: "approve", label: "Approve Plan" },
           { id: "reject", label: "Reject Plan" },
@@ -1826,10 +1992,10 @@ export class Orchestrator {
       };
     }
 
-    // Gate review
+    // Gate review — scoped by feature slug for review session lookup
     if (feature.gate_evidence_ts) {
       return {
-        id: `gate-${(feature.gate_number || 0) + 1}-review`,
+        id: `gate-${(feature.gate_number || 0) + 1}-review@${feature.slug}`,
         options: [
           { id: "approve", label: "Approve" },
           { id: "reject", label: "Reject" },
@@ -2145,15 +2311,16 @@ export class Orchestrator {
             description: o.description || "",
           }));
 
-          // Start review session for gate decisions
+          // Start review session for gate decisions — scope key by feature to avoid cross-feature collisions
           let reviewUrl = null;
           let qaUrl = null;
+          const reviewSessionKey = decision.id.startsWith("gate-") ? `${decision.id}@${feature.slug}` : decision.id;
           if (this.reviewSessions && decision.type === "approval" && decision.id.startsWith("gate-")) {
             // Look for gate evidence HTML
             const evidencePath = path.join(feature.signal_dir, "feature-lead", ".gate-evidence.html");
             if (fs.existsSync(evidencePath)) {
               reviewUrl = await this.reviewSessions.startDocReview(
-                decision.id, evidencePath, `Gate Evidence — ${decision.title}`, { featureId: feature.id }
+                reviewSessionKey, evidencePath, `Gate Evidence — ${decision.title}`, { featureId: feature.id }
               );
             }
 
@@ -2177,7 +2344,7 @@ export class Orchestrator {
                 }
               }
               qaUrl = await this.reviewSessions.startQaSession(
-                decision.id, verification.url, { featureId: feature.id }
+                reviewSessionKey, verification.url, { featureId: feature.id }
               );
             }
           }
@@ -2287,18 +2454,25 @@ export class Orchestrator {
       }
     });
 
-    // Gate-ready: check if ALL teams are ready
+    // Gate-ready: check only co-dependent teams (derived from plan.yaml phase dependencies)
     this.fileIO.on("impl:gateReady", ({ slug, teamNum }) => {
       const tree = this._signalTrees[slug];
       if (!tree) return;
 
-      const allReady = Object.keys(tree.teams).every(tn =>
-        fs.existsSync(path.join(tree.teams[tn].orchestrator, SIGNAL.GATE_READY))
+      const gateTeams = this._getGateTeams(slug, String(teamNum));
+      const gateReady = gateTeams.every(tn =>
+        tree.teams[tn]?.orchestrator && fs.existsSync(path.join(tree.teams[tn].orchestrator, SIGNAL.GATE_READY))
       );
 
-      if (allReady) {
-        console.log(`[orchestrator] All teams gate-ready for ${slug}`);
-        this._triggerFeatureLead(slug, "gate-ready");
+      if (gateReady) {
+        console.log(`[orchestrator] Gate teams [${gateTeams.join(", ")}] ready for ${slug}`);
+        // Persist which teams are under review (read by handleGateApproval/Rejection).
+        // NOTE: assumes FL serializes gate reviews — if two independent gate groups finish
+        // concurrently, the second write overwrites the first. Safe because the FL processes
+        // one gate review at a time per feature before advancing to the next.
+        const reviewTeamsFile = path.join(tree.featureDir, ".gate-review-teams");
+        writeSignal(reviewTeamsFile, JSON.stringify(gateTeams));
+        this._triggerFeatureLead(slug, "gate-ready", { gateTeams });
       }
     });
 
@@ -2405,7 +2579,7 @@ export class Orchestrator {
     // If FL is already running, send trigger as a .user-message instead of killing it
     if (this.supervisor.isRunning(flKey)) {
       const msg = trigger === "gate-ready"
-        ? "TRIGGER: All teams have signaled gate-ready. Begin gate review."
+        ? `TRIGGER: Teams ${(opts.gateTeams || ["all"]).join(", ")} have signaled gate-ready. Review ONLY these teams' work for this gate.`
         : trigger === "question"
         ? `TRIGGER: Teams ${(opts.questionTeams || []).join(", ")} have questions needing resolution.`
         : trigger === "crash"
@@ -2649,11 +2823,16 @@ export class Orchestrator {
       return;
     }
 
+    // Re-read feature from DB — the file watcher's _handlePlanningDone may have
+    // updated phase/role between the time the exit event was queued and now.
+    const freshFeature = queries.getFeatureById(feature.id);
+    if (!freshFeature) return;
+
     // Check if the file watcher already processed .done (it deletes the file).
     // If review gate is posted or agent already marked done, don't retry.
     const meta = queries.getFeatureMetadata(feature.id);
     const agent = queries.getAgentById(agentId);
-    if (meta.awaiting_phase_review && meta.phase_review_role === roleName) {
+    if (meta.awaiting_phase_review) {
       console.log(`[orchestrator] ${roleName} exit: review gate already posted, skipping retry`);
       queries.updateAgentStatus(agentId, "done");
       return;
@@ -2662,9 +2841,15 @@ export class Orchestrator {
       console.log(`[orchestrator] ${roleName} exit: already marked done, skipping retry`);
       return;
     }
-    // Also skip if phase has already advanced past this role
-    if (feature.active_planning_role && feature.active_planning_role !== roleName) {
-      console.log(`[orchestrator] ${roleName} exit: phase already advanced to ${feature.active_planning_role}, skipping retry`);
+    // Skip if feature has left planning phase (e.g. plan-compiler PASS → plan-approval)
+    if (freshFeature.phase !== "planning") {
+      console.log(`[orchestrator] ${roleName} exit: feature phase is ${freshFeature.phase}, not planning — skipping retry`);
+      queries.updateAgentStatus(agentId, "done");
+      return;
+    }
+    // Skip if phase has already advanced past this role (null means role was cleared)
+    if (freshFeature.active_planning_role !== roleName) {
+      console.log(`[orchestrator] ${roleName} exit: active role is now ${freshFeature.active_planning_role || "none"}, skipping retry`);
       queries.updateAgentStatus(agentId, "done");
       return;
     }
@@ -3261,14 +3446,24 @@ modify a SPECIFIC section — never re-read them in full.\n`;
       const flAgent = queries.getAgentByKey(`fl-${slug}`);
       const flRunning = flAgent && (flAgent.status === "running" || this.supervisor.isRunning(`fl-${slug}`));
       if (!flRunning && !feature.gate_evidence_ts) {
-        const allReady = Object.keys(tree.teams).every(tn =>
-          tree.teams[tn].orchestrator && fs.existsSync(path.join(tree.teams[tn].orchestrator, SIGNAL.GATE_READY))
-        );
-        if (allReady && Object.keys(tree.teams).length > 0) {
-          console.log(`[orchestrator] Stale scan: all teams gate-ready for ${slug}`);
-          this._triggerFeatureLead(slug, "gate-ready");
-          continue;
+        // Check each team's gate group independently (not all teams at once)
+        let gateTriggered = false;
+        for (const tn of Object.keys(tree.teams)) {
+          if (!tree.teams[tn].orchestrator || !fs.existsSync(path.join(tree.teams[tn].orchestrator, SIGNAL.GATE_READY))) continue;
+          const gateTeams = this._getGateTeams(slug, tn);
+          const gateReady = gateTeams.every(gt =>
+            tree.teams[gt]?.orchestrator && fs.existsSync(path.join(tree.teams[gt].orchestrator, SIGNAL.GATE_READY))
+          );
+          if (gateReady) {
+            console.log(`[orchestrator] Stale scan: gate teams [${gateTeams.join(", ")}] ready for ${slug}`);
+            const reviewTeamsFile = path.join(tree.featureDir, ".gate-review-teams");
+            writeSignal(reviewTeamsFile, JSON.stringify(gateTeams));
+            this._triggerFeatureLead(slug, "gate-ready", { gateTeams });
+            gateTriggered = true;
+            break;
+          }
         }
+        if (gateTriggered) continue;
       }
 
       // Check for stale questions

package/v3/prompt-builder.js

@@ -659,13 +659,16 @@ Then poll for feature-review/health-monitor/.done, read its .output, and act on
 
 function buildGateReviewInstructions(featureLeadDir, featureReviewDir, featureStatusFile, dashboardFile) {
   return `
-## Gate Review (once all teams are gate-ready)
+## Gate Review (once gate teams are ready)
+
+Gates are per-team-group: the trigger message tells you which teams to review.
+Review ONLY those teams — other teams may be working independently on unrelated phases.
 
 Follow the Gate Evidence Document Protocol from your CLAUDE.md. The ordered steps below ensure
 adversarial cross-check happens LAST (after all review agents have completed):
 
-1. **Read team evidence** — Read \`.gate-evidence.yaml\` from each team's orchestrator signal dir.
-   If any team lacks \`.gate-evidence.yaml\`, REJECT the gate immediately.
+1. **Read team evidence** — Read \`.gate-evidence.yaml\` from each REVIEWED team's orchestrator signal dir.
+   If any reviewed team lacks \`.gate-evidence.yaml\`, REJECT the gate immediately.
 2. **Push team branches** and create PRs (team branch → integration branch) per repo using gh CLI
 3. **Determine which review agents to dispatch** for this gate:
    a. Read the current phase's \`phase.yaml\` and look for the \`review_roles\` field.
@@ -838,7 +841,15 @@ ${planReadInstruction}
 3. Identify the gate boundaries in the plan
 4. Partition the current gate's work across ${numTeams} teams
 4. Write GATE-CONTEXT.md for each team (at ${teamSignalBase}/team-N/GATE-CONTEXT.md)
-5. Write team manifests if not present (at ${teamSignalBase}/team-N/manifest.yaml)
+5. Write team manifests (at ${teamSignalBase}/team-N/manifest.yaml) — MUST include \`gate_phases\` field:
+   \`\`\`yaml
+   current_phase: phase-1    # starting phase for this gate
+   current_gate: 1
+   gate_phases: [phase-1]    # ALL phases assigned to this team for this gate
+   \`\`\`
+   The \`gate_phases\` field lists every phase this team will complete before signaling gate-ready.
+   Gates are per-team-group: teams working on independent phases (no shared dependencies in plan.yaml)
+   will be reviewed independently. Only teams whose phases share dependencies need to sync.
 6. Dispatch to each team orchestrator by writing .task files (at ${teamSignalBase}/team-N/orchestrator/.task)
 7. Update ${featureStatusFile} with gate 1 status
 8. Update ${dashboardFile}
@@ -916,7 +927,7 @@ ${slackComm}`;
 export function buildFeatureLeadTriggerPrompt({
   featureName, numTeams, trigger, teamSignalBase,
   featureLeadDir, featureReviewDir, dashboardLog,
-  questionTeams, crashedTeams, recoveryContext,
+  questionTeams, crashedTeams, gateTeams, recoveryContext,
   featureDir, teamWorktreeBase,
 }) {
   const featureStatusFile = `${featureDir}/FEATURE-STATUS.md`;
@@ -949,7 +960,9 @@ ${base}`;
   switch (trigger) {
     case "gate-ready":
       base += `
-TRIGGER: All ${numTeams} teams have signaled .gate-ready.
+TRIGGER: Teams ${(gateTeams || ["all"]).join(", ")} have signaled .gate-ready.
+Review ONLY these teams' work for this gate — other teams may still be working independently.
+Read each reviewed team's .gate-evidence.yaml and GATE-CONTEXT.md to scope the review.
 ${gateReview}`;
       break;
 

package/v3/recovery.js

@@ -100,8 +100,10 @@ export class Recovery {
       };
     }
 
-    // Emit stale signals
+    // Emit stale signals — only for the active planning role
+    const activeRole = feature.active_planning_role;
     for (const [role, dir] of Object.entries(planningTree)) {
+      if (role !== activeRole) continue;
       for (const [sig, eventType] of [
         [SIGNAL.DONE, "planning:done"],
         [SIGNAL.AGENT_RESPONSE, "planning:response"],
@@ -281,8 +283,12 @@ export class Recovery {
         };
       }
 
-      // Emit stale signals
+      // Emit stale signals — only for the active planning role to avoid
+      // re-processing signals from already-completed roles (which would cause
+      // duplicate artifact uploads and decision re-posts).
+      const activeRole = feature.active_planning_role;
       for (const [role, dir] of Object.entries(planningTree)) {
+        if (role !== activeRole) continue;
         for (const [sig, eventType] of [
           [SIGNAL.DONE, "planning:done"],
           [SIGNAL.AGENT_RESPONSE, "planning:response"],

package/v3/roles/feature-lead/CLAUDE.md

@@ -18,9 +18,10 @@ The user will reject weak evidence. Catch problems before they reach the user.
 ## Constraints
 - ONLY read/write signal files and status documents
 - Partition plan phases across teams based on domain boundaries
-- Monitor `.gate-ready` signals from all team orchestrators
-- At gate boundaries: dispatch gate-level QA (integration-tester, code-reviewer)
-- Compile the full gate evidence bundle before posting to the user
+- Monitor `.gate-ready` signals from team orchestrators
+- Gates are per-team-group: teams with independent phases are reviewed separately
+- At gate boundaries: dispatch gate-level QA (integration-tester, code-reviewer) for the reviewed teams only
+- Compile the gate evidence bundle for only the reviewed teams before posting to the user
 - Escalate questions you cannot answer with high confidence to the user via the bridge
 
 ## Dynamic Dispatch Model
@@ -97,7 +98,7 @@ You post to the feature's channel via the bridge. Rules:
    - The HTML file IS the message. No text summary needed.
    - Include `[evidence:<path to .gate-evidence.html>]` marker — HTML uploaded as attachment
    - Include `[DECISION]` block with approve/reject buttons
-   - This is the ONE approval point per gate — no per-team approvals
+   - This is the ONE approval point per gate group — the trigger tells you which teams are in scope
    - The HTML links to team gate HTMLs for drill-down
    ```
    [evidence:<path to .gate-evidence.html>]
@@ -166,10 +167,18 @@ The bridge posts this to the user. Wait for `.user-message`, then transcribe the
 1. Read `plan.yaml` — understand feature scope and phase ordering
 2. Partition phases across teams by domain (backend, frontend, etc.)
 3. Write `.task` files to each team orchestrator with phase references and cross-team context
-4. Monitor gate completion across all teams
-5. At gate boundaries: run gate-level QA, compile evidence, present to user
-6. On approval: advance all teams to next gate
-7. On feature completion: manage merge ordering across team branches
+4. Write team manifests with `gate_phases` listing all phases for the current gate
+5. Monitor gate completion — gates are per-team-group based on phase dependencies
+6. At gate boundaries: run gate-level QA for the reviewed teams, compile evidence, present to user
+7. On approval: advance ONLY the reviewed teams to next gate (other teams unaffected)
+8. On feature completion: manage merge ordering across team branches
+
+### Per-Team-Group Gates
+Teams whose current phases have NO cross-dependencies in `plan.yaml` are reviewed independently.
+Example: if Team 1 works on phase-1 (depends_on: []) and Team 2 works on phase-5 (depends_on: []),
+they form separate gate groups — Team 1's gate review doesn't wait for Team 2.
+Only when a phase depends on another team's phase (e.g., phase-6 depends_on: [phase-4, phase-5])
+do both teams need to sync for a shared gate.
 
 ## Output
 Write `FEATURE-STATUS.md` and `DASHBOARD.md` in your feature's signal directory with current state.

package/v3/validate-gate-dispatch.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+/**
+ * Validate gate dispatch correctness for a feature.
+ *
+ * Reads plan.yaml + all team manifests and checks:
+ * 1. gate_phases / current_phase reference valid phase IDs
+ * 2. Phase dependencies are satisfiable (deps in prior gates or same-team same-gate)
+ * 3. Gate groups are consistent (teams with cross-deps should share a gate boundary)
+ * 4. GATE-CONTEXT.md phase references match manifest
+ *
+ * Usage: node v3/validate-gate-dispatch.js <feature-signal-dir>
+ *   e.g. node v3/validate-gate-dispatch.js .implementation/features/desktop-companion-app-for-iriai-build
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+function parsePlanYaml(content) {
+  // Extract only the phases: block (stop at next top-level key or end of file)
+  const phasesMatch = content.match(/^phases:\s*\n([\s\S]*?)(?=\n[a-zA-Z])/m)
+    || content.match(/^phases:\s*\n([\s\S]*)$/m);
+  if (!phasesMatch) return [];
+  const phasesBlock = phasesMatch[1];
+
+  const phases = [];
+  const phaseEntries = phasesBlock.split(/(?=^\s*-\s+id:\s)/m);
+  for (const block of phaseEntries) {
+    const idMatch = block.match(/^\s*-?\s*id:\s*(\S+)/m);
+    if (!idMatch) continue;
+    const phaseId = idMatch[1];
+    const depsMatch = block.match(/depends_on:\s*\[([^\]]*)\]/);
+    const deps = depsMatch && depsMatch[1].trim()
+      ? depsMatch[1].split(",").map(s => s.trim().replace(/['"]/g, "")).filter(Boolean)
+      : [];
+    const titleMatch = block.match(/title:\s*"?([^"\n]+)"?/);
+    phases.push({ id: phaseId, depends_on: deps, title: titleMatch ? titleMatch[1].trim() : phaseId });
+  }
+  return phases;
+}
+
+function parseManifest(content) {
+  const result = {};
+  const teamMatch = content.match(/^team:\s*(\S+)/m);
+  if (teamMatch) result.team = teamMatch[1];
+  const phaseMatch = content.match(/^current_phase:\s*(\S+)/m);
+  if (phaseMatch) result.current_phase = phaseMatch[1];
+  const gateMatch = content.match(/^current_gate:\s*(\S+)/m);
+  if (gateMatch) result.current_gate = gateMatch[1];
+  const gatePhasesMatch = content.match(/^gate_phases:\s*\[([^\]]*)\]/m);
+  if (gatePhasesMatch) {
+    result.gate_phases = gatePhasesMatch[1].split(",").map(s => s.trim().replace(/['"]/g, "")).filter(Boolean);
+  }
+  return result;
+}
+
+function main() {
+  const featureDir = process.argv[2];
+  if (!featureDir || !fs.existsSync(featureDir)) {
+    console.error("Usage: node v3/validate-gate-dispatch.js <feature-signal-dir>");
+    process.exit(1);
+  }
+
+  const errors = [];
+  const warnings = [];
+
+  // 1. Read plan.yaml
+  const planPath = path.join(featureDir, "plans", "plan.yaml");
+  if (!fs.existsSync(planPath)) {
+    console.error(`ERROR: No plan.yaml at ${planPath}`);
+    process.exit(1);
+  }
+  const phases = parsePlanYaml(fs.readFileSync(planPath, "utf-8"));
+  const phaseIds = new Set(phases.map(p => p.id));
+  const phaseDeps = Object.fromEntries(phases.map(p => [p.id, p.depends_on]));
+
+  console.log(`Plan: ${phases.length} phases — ${phases.map(p => p.id).join(", ")}`);
+
+  // 2. Read team manifests
+  const teamsDir = path.join(featureDir, "teams");
+  if (!fs.existsSync(teamsDir)) {
+    console.error(`ERROR: No teams directory at ${teamsDir}`);
+    process.exit(1);
+  }
+
+  const teams = {};
+  for (const entry of fs.readdirSync(teamsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith("team-")) continue;
+    const teamNum = entry.name.replace("team-", "");
+    const manifestPath = path.join(teamsDir, entry.name, "manifest.yaml");
+    if (!fs.existsSync(manifestPath)) {
+      errors.push(`Team ${teamNum}: No manifest.yaml`);
+      continue;
+    }
+    teams[teamNum] = parseManifest(fs.readFileSync(manifestPath, "utf-8"));
+    teams[teamNum].dir = path.join(teamsDir, entry.name);
+  }
+
+  console.log(`Teams: ${Object.keys(teams).length} — ${Object.keys(teams).map(t => `team-${t}`).join(", ")}`);
+
+  // 3. Validate each team's phases
+  for (const [tn, manifest] of Object.entries(teams)) {
+    const teamPhases = manifest.gate_phases || (manifest.current_phase ? [manifest.current_phase] : []);
+
+    if (!manifest.gate_phases) {
+      warnings.push(`Team ${tn}: No gate_phases in manifest — falling back to current_phase: ${manifest.current_phase || "MISSING"}`);
+    }
+
+    for (const phaseId of teamPhases) {
+      if (!phaseIds.has(phaseId)) {
+        errors.push(`Team ${tn}: Phase '${phaseId}' not found in plan.yaml`);
+      }
+    }
+
+    // Check dependencies are satisfiable
+    for (const phaseId of teamPhases) {
+      const deps = phaseDeps[phaseId] || [];
+      for (const dep of deps) {
+        // Dep should be in a prior gate (another team's completed work) or same team's gate_phases
+        const inSameGate = teamPhases.includes(dep);
+        const inOtherTeam = Object.entries(teams).some(([otherTn, otherManifest]) => {
+          if (otherTn === tn) return false;
+          const otherPhases = otherManifest.gate_phases || (otherManifest.current_phase ? [otherManifest.current_phase] : []);
+          return otherPhases.includes(dep);
+        });
+
+        if (inOtherTeam && !inSameGate) {
+          // Cross-team dependency — this is an expected sync point
+          const depTeam = Object.entries(teams).find(([otherTn, otherManifest]) => {
+            if (otherTn === tn) return false;
+            const otherPhases = otherManifest.gate_phases || (otherManifest.current_phase ? [otherManifest.current_phase] : []);
+            return otherPhases.includes(dep);
+          });
+          if (depTeam) {
+            console.log(`  Team ${tn} phase ${phaseId} depends on Team ${depTeam[0]} phase ${dep} — cross-team gate sync required`);
+          }
+        } else if (!inSameGate && !inOtherTeam) {
+          // Dep is not in any team's current gate — should be from a prior completed gate
+          warnings.push(`Team ${tn}: Phase '${phaseId}' depends on '${dep}' which is not in any team's current gate (should be completed already)`);
+        }
+      }
+    }
+
+    // 4. Check GATE-CONTEXT.md consistency
+    const gateContextPath = path.join(manifest.dir, "GATE-CONTEXT.md");
+    if (fs.existsSync(gateContextPath)) {
+      const gateContext = fs.readFileSync(gateContextPath, "utf-8");
+      for (const phaseId of teamPhases) {
+        // Check that the phase is mentioned in GATE-CONTEXT
+        const phaseNum = phaseId.replace("phase-", "");
+        if (!gateContext.includes(`Phase ${phaseNum}`) && !gateContext.includes(phaseId)) {
+          warnings.push(`Team ${tn}: GATE-CONTEXT.md doesn't mention ${phaseId}`);
+        }
+      }
+    } else {
+      warnings.push(`Team ${tn}: No GATE-CONTEXT.md`);
+    }
+  }
+
+  // 5. Compute and display gate groups
+  console.log("\n--- Gate Groups (derived from plan.yaml dependencies) ---");
+  const allTeamNums = Object.keys(teams);
+  const processed = new Set();
+
+  for (const tn of allTeamNums) {
+    if (processed.has(tn)) continue;
+    const myPhases = new Set(teams[tn].gate_phases || (teams[tn].current_phase ? [teams[tn].current_phase] : []));
+    const group = new Set([tn]);
+
+    for (const otherTn of allTeamNums) {
+      if (otherTn === tn) continue;
+      const otherPhases = new Set(teams[otherTn].gate_phases || (teams[otherTn].current_phase ? [teams[otherTn].current_phase] : []));
+
+      let linked = false;
+      for (const p of myPhases) {
+        for (const dep of (phaseDeps[p] || [])) {
+          if (otherPhases.has(dep)) linked = true;
+        }
+      }
+      for (const p of otherPhases) {
+        for (const dep of (phaseDeps[p] || [])) {
+          if (myPhases.has(dep)) linked = true;
+        }
+      }
+      if (linked) group.add(otherTn);
+    }
+
+    for (const g of group) processed.add(g);
+    const groupPhases = [...group].flatMap(g => teams[g].gate_phases || (teams[g].current_phase ? [teams[g].current_phase] : []));
+    console.log(`  Gate group [${[...group].join(", ")}]: ${groupPhases.join(", ")}`);
+  }
+
+  // 6. Print results
+  if (errors.length > 0) {
+    console.log("\n--- ERRORS ---");
+    for (const e of errors) console.log(`  ✗ ${e}`);
+  }
+  if (warnings.length > 0) {
+    console.log("\n--- WARNINGS ---");
+    for (const w of warnings) console.log(`  ⚠ ${w}`);
+  }
+  if (errors.length === 0 && warnings.length === 0) {
+    console.log("\n✓ All checks passed");
+  }
+
+  process.exit(errors.length > 0 ? 1 : 0);
+}
+
+main();