ralph-hero-mcp-server 2.4.99 → 2.4.102

package/dist/lib/pipeline-detection.js

@@ -55,17 +55,17 @@ export function detectPipelinePosition(issues, isGroup, groupPrimary, options =
             required: false,
             met: true,
             blocking: [],
-        });
+        }, options.streamCount);
     }
     // Step 1: Check for oversized issues needing split (skip already-split issues)
     const oversized = issues.filter((i) => i.estimate !== null && OVERSIZED_ESTIMATES.has(i.estimate) && i.subIssueCount === 0);
     if (oversized.length > 0) {
-        return buildResult("SPLIT", `${oversized.length} issue(s) need splitting (estimate: ${oversized.map((i) => `#${i.number}=${i.estimate}`).join(", ")})`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] });
+        return buildResult("SPLIT", `${oversized.length} issue(s) need splitting (estimate: ${oversized.map((i) => `#${i.number}=${i.estimate}`).join(", ")})`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] }, options.streamCount);
     }
     // Step 2: Check for issues without workflow state
     const noState = issues.filter((i) => !i.workflowState || i.workflowState === "unknown");
     if (noState.length > 0) {
-        return buildResult("TRIAGE", `${noState.length} issue(s) have no workflow state; triage first`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] });
+        return buildResult("TRIAGE", `${noState.length} issue(s) have no workflow state; triage first`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] }, options.streamCount);
     }
     // Categorize issues by state
     const needsResearch = issues.filter((i) => i.workflowState === "Research Needed");
@@ -95,47 +95,47 @@ export function detectPipelinePosition(issues, isGroup, groupPrimary, options =
                 })),
             ],
         };
-        return buildResult("RESEARCH", `${needsResearch.length} need research, ${inResearch.length} in progress`, issues, isGroup, groupPrimary, convergence);
+        return buildResult("RESEARCH", `${needsResearch.length} need research, ${inResearch.length} in progress`, issues, isGroup, groupPrimary, convergence, options.streamCount);
     }
     // Step 4: All issues in Ready for Plan -> PLAN (convergence met)
     if (readyForPlan.length === issues.length) {
-        return buildResult("PLAN", "All issues ready for planning", issues, isGroup, groupPrimary, { required: isGroup, met: true, blocking: [] });
+        return buildResult("PLAN", "All issues ready for planning", issues, isGroup, groupPrimary, { required: isGroup, met: true, blocking: [] }, options.streamCount);
     }
     // Step 5: Some Ready for Plan but not all (mixed with earlier states) -> still need earlier work
     // This is handled by the checks above (research, backlog) and below (plan in progress/review)
     // Step 6: Any issues in Plan in Progress -> REVIEW (plans still being written)
     // If some are in Plan in Progress and some in Plan in Review, we're still in REVIEW phase
     if (planInProgress.length > 0) {
-        return buildResult("REVIEW", `${planInProgress.length} plan(s) in progress, ${planInReview.length} in review`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] });
+        return buildResult("REVIEW", `${planInProgress.length} plan(s) in progress, ${planInReview.length} in review`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] }, options.streamCount);
     }
     // Step 7: All issues in Plan in Review -> HUMAN_GATE (all plans awaiting approval)
     if (planInReview.length === issues.length) {
-        return buildResult("HUMAN_GATE", "All plans awaiting human approval", issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] });
+        return buildResult("HUMAN_GATE", "All plans awaiting human approval", issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] }, options.streamCount);
     }
     // Some in Plan in Review (but not all, and none in Plan in Progress) -> REVIEW
     if (planInReview.length > 0) {
-        return buildResult("REVIEW", `${planInReview.length} plan(s) in review`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] });
+        return buildResult("REVIEW", `${planInReview.length} plan(s) in review`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] }, options.streamCount);
     }
     // Step 8: Any issues in In Progress -> IMPLEMENT
     if (inProgress.length > 0) {
-        return buildResult("IMPLEMENT", `${inProgress.length} issue(s) in progress`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] });
+        return buildResult("IMPLEMENT", `${inProgress.length} issue(s) in progress`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] }, options.streamCount);
     }
     // Step 9: All issues terminal (In Review or Done or Canceled)
     const terminal = inReview.length + done.length + canceled.length;
     if (terminal === issues.length) {
         // In auto mode, "In Review" issues are actionable (integrator can merge)
         if (options.autoMode && inReview.length > 0 && done.length + canceled.length < issues.length) {
-            return buildResult("INTEGRATE", `${inReview.length} issue(s) awaiting integration`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] });
+            return buildResult("INTEGRATE", `${inReview.length} issue(s) awaiting integration`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] }, options.streamCount);
         }
-        return buildResult("TERMINAL", "All issues in review or done", issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] });
+        return buildResult("TERMINAL", "All issues in review or done", issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] }, options.streamCount);
     }
     // Step 10: Any issues need human intervention -> TERMINAL
     if (humanNeeded.length > 0) {
-        return buildResult("TERMINAL", `${humanNeeded.length} issue(s) need human intervention`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] });
+        return buildResult("TERMINAL", `${humanNeeded.length} issue(s) need human intervention`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] }, options.streamCount);
     }
     // Step 11: Backlog issues -> TRIAGE
     if (backlog.length > 0) {
-        return buildResult("TRIAGE", `${backlog.length} issue(s) in Backlog`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] });
+        return buildResult("TRIAGE", `${backlog.length} issue(s) in Backlog`, issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] }, options.streamCount);
     }
     // Step 12: Mixed states - default to earliest incomplete phase
     // Check Ready for Plan mixed with later states
@@ -143,10 +143,10 @@ export function detectPipelinePosition(issues, isGroup, groupPrimary, options =
         const blocking = issues
             .filter((i) => i.workflowState !== "Ready for Plan")
             .map((i) => ({ number: i.number, state: i.workflowState }));
-        return buildResult("PLAN", "Some issues ready for planning, mixed states", issues, isGroup, groupPrimary, { required: isGroup, met: false, blocking });
+        return buildResult("PLAN", "Some issues ready for planning, mixed states", issues, isGroup, groupPrimary, { required: isGroup, met: false, blocking }, options.streamCount);
     }
     // Fallback
-    return buildResult("TRIAGE", "Mixed states, defaulting to triage", issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] });
+    return buildResult("TRIAGE", "Mixed states, defaulting to triage", issues, isGroup, groupPrimary, { required: false, met: true, blocking: [] }, options.streamCount);
 }
 // ---------------------------------------------------------------------------
 // Stream-level detection
@@ -165,14 +165,17 @@ export function detectStreamPipelinePositions(streams, issueStates, options = {}
         return {
             streamId: stream.id,
             issues: filteredIssues,
-            position: detectPipelinePosition(filteredIssues, isGroup, groupPrimary, options),
+            position: detectPipelinePosition(filteredIssues, isGroup, groupPrimary, {
+                ...options,
+                streamCount: streams.length,
+            }),
         };
     });
 }
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-function computeSuggestedRoster(phase, issues) {
+function computeSuggestedRoster(phase, issues, streamCount) {
     // TERMINAL: no workers needed
     if (phase === 'TERMINAL') {
         return { analyst: 0, builder: 0, integrator: 0 };
@@ -189,13 +192,12 @@ function computeSuggestedRoster(phase, issues) {
             : needsResearch.length <= 5 ? 2
                 : 3;
     }
-    // Builder scaling: default 1; 2 if 5+ issues with M/L estimates
-    const largeSized = issues.filter(i => i.estimate != null && ['M', 'L', 'XL'].includes(i.estimate));
-    const builder = largeSized.length >= 5 ? 2 : 1;
+    // Builder scaling: 1 per independent stream, capped at 3
+    const builder = Math.min(streamCount || 1, 3);
     const integrator = issues.length >= 5 ? 2 : 1;
     return { analyst, builder, integrator };
 }
-function buildResult(phase, reason, issues, isGroup, groupPrimary, convergence) {
+function buildResult(phase, reason, issues, isGroup, groupPrimary, convergence, streamCount) {
     // Derive recommendation from convergence state
     let recommendation;
     if (convergence.met) {
@@ -207,7 +209,7 @@ function buildResult(phase, reason, issues, isGroup, groupPrimary, convergence)
     else {
         recommendation = "wait";
     }
-    const suggestedRoster = computeSuggestedRoster(phase, issues);
+    const suggestedRoster = computeSuggestedRoster(phase, issues, streamCount);
     return {
         phase,
         reason,

package/dist/tools/dashboard-tools.js

@@ -361,11 +361,20 @@ export function registerDashboardTools(server, client, fieldCache) {
                 subIssueCount: s.subIssueCount ?? 0,
             }));
             const positions = detectStreamPipelinePositions(streamResult.streams, states, { autoMode: client.config.autoMode });
+            // Aggregate roster: max analyst/integrator across streams, stream-count-based builder
+            const suggestedRoster = positions.length > 0
+                ? {
+                    analyst: Math.max(...positions.map(p => p.position.suggestedRoster.analyst)),
+                    builder: Math.min(streamResult.totalStreams, 3),
+                    integrator: Math.max(...positions.map(p => p.position.suggestedRoster.integrator)),
+                }
+                : { analyst: 0, builder: 0, integrator: 0 };
             return toolSuccess({
                 streams: positions,
                 totalStreams: streamResult.totalStreams,
                 totalIssues: streamResult.totalIssues,
                 rationale: streamResult.rationale,
+                suggestedRoster,
             });
         }
         catch (error) {

package/dist/tools/issue-tools.js

@@ -854,23 +854,47 @@ export function registerIssueTools(server, client, fieldCache) {
                             .map((name) => allLabels.find((l) => l.name === name)?.id)
                             .filter((id) => id !== undefined);
                     }
-                    await client.mutate(`mutation($issueId: ID!, $title: String, $body: String, $labelIds: [ID!], $assigneeIds: [ID!]) {
-                updateIssue(input: {
-                  id: $issueId,
-                  title: $title,
-                  body: $body,
-                  labelIds: $labelIds,
-                  assigneeIds: $assigneeIds
-                }) {
+                    // Resolve assignee IDs if provided
+                    let assigneeIds;
+                    if (args.assignees) {
+                        assigneeIds = [];
+                        for (const username of args.assignees) {
+                            const userResult = await client.query(`query($login: String!) { user(login: $login) { id } }`, { login: username }, { cache: true, cacheTtlMs: 5 * 60 * 1000 });
+                            if (userResult.user) {
+                                assigneeIds.push(userResult.user.id);
+                            }
+                        }
+                    }
+                    // Build mutation dynamically to avoid sending null for unprovided fields
+                    // (GitHub treats null as "clear" not "leave unchanged")
+                    const varDefs = ["$issueId: ID!"];
+                    const inputFields = ["id: $issueId"];
+                    const variables = { issueId };
+                    if (args.title !== undefined) {
+                        varDefs.push("$title: String");
+                        inputFields.push("title: $title");
+                        variables.title = args.title;
+                    }
+                    if (args.body !== undefined) {
+                        varDefs.push("$body: String");
+                        inputFields.push("body: $body");
+                        variables.body = args.body;
+                    }
+                    if (labelIds !== undefined) {
+                        varDefs.push("$labelIds: [ID!]");
+                        inputFields.push("labelIds: $labelIds");
+                        variables.labelIds = labelIds;
+                    }
+                    if (assigneeIds !== undefined) {
+                        varDefs.push("$assigneeIds: [ID!]");
+                        inputFields.push("assigneeIds: $assigneeIds");
+                        variables.assigneeIds = assigneeIds;
+                    }
+                    await client.mutate(`mutation(${varDefs.join(", ")}) {
+                updateIssue(input: { ${inputFields.join(", ")} }) {
                   issue { number title url }
                 }
-              }`, {
-                        issueId,
-                        title: args.title ?? null,
-                        body: args.body ?? null,
-                        labelIds: labelIds ?? null,
-                        assigneeIds: null, // Would need username -> ID resolution
-                    });
+              }`, variables);
                     if (args.title !== undefined)
                         changes.title = args.title;
                     if (args.body !== undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralph-hero-mcp-server",
-  "version": "2.4.99",
+  "version": "2.4.102",
   "description": "MCP server for GitHub Projects V2 - Ralph workflow automation",
   "type": "module",
   "main": "dist/index.js",