ralph-hero-mcp-server 2.4.43 → 2.4.48

package/dist/lib/dashboard.js

@@ -219,6 +219,52 @@ export function detectHealthIssues(phases, config = DEFAULT_HEALTH_CONFIG) {
     return warnings;
 }
 // ---------------------------------------------------------------------------
+// detectCrossProjectHealth
+// ---------------------------------------------------------------------------
+/**
+ * Detect health issues that span multiple projects.
+ *
+ * Currently detects:
+ * - unbalanced_workload: one project has >3x active items vs another
+ *
+ * "Active" = states in STATE_ORDER that are NOT terminal and NOT "Backlog".
+ */
+export function detectCrossProjectHealth(breakdowns) {
+    const warnings = [];
+    const projectNumbers = Object.keys(breakdowns).map(Number);
+    // Count active items per project
+    const activeCounts = [];
+    for (const pn of projectNumbers) {
+        const { phases } = breakdowns[pn];
+        let active = 0;
+        for (const phase of phases) {
+            if (phase.state !== "Backlog" &&
+                !TERMINAL_STATES.includes(phase.state) &&
+                STATE_ORDER.includes(phase.state)) {
+                active += phase.count;
+            }
+        }
+        if (active > 0) {
+            activeCounts.push({ projectNumber: pn, count: active });
+        }
+    }
+    // Need at least 2 projects with active items to compare
+    if (activeCounts.length < 2) {
+        return warnings;
+    }
+    const maxEntry = activeCounts.reduce((a, b) => a.count > b.count ? a : b);
+    const minEntry = activeCounts.reduce((a, b) => a.count < b.count ? a : b);
+    if (maxEntry.count > 3 * minEntry.count) {
+        warnings.push({
+            type: "unbalanced_workload",
+            severity: "warning",
+            message: `Unbalanced workload: project ${maxEntry.projectNumber} has ${maxEntry.count} active items vs project ${minEntry.projectNumber} with ${minEntry.count}`,
+            issues: [],
+        });
+    }
+    return warnings;
+}
+// ---------------------------------------------------------------------------
 // computeArchiveStats
 // ---------------------------------------------------------------------------
 const ARCHIVE_TERMINAL_STATES = new Set(["Done", "Canceled"]);
@@ -275,6 +321,45 @@ export function buildDashboard(items, config = DEFAULT_HEALTH_CONFIG, now = Date
     const phases = aggregateByPhase(items, now, config);
     const warnings = detectHealthIssues(phases, config);
     const archive = computeArchiveStats(items, now, config.archiveThresholdDays, config.doneWindowDays);
+    // Per-project breakdown (only when items span multiple projects)
+    const projectGroups = new Map();
+    for (const item of items) {
+        if (item.projectNumber !== undefined) {
+            const group = projectGroups.get(item.projectNumber);
+            if (group) {
+                group.push(item);
+            }
+            else {
+                projectGroups.set(item.projectNumber, [item]);
+            }
+        }
+    }
+    let projectBreakdowns;
+    if (projectGroups.size >= 2) {
+        projectBreakdowns = {};
+        for (const [pn, projectItems] of projectGroups) {
+            const pPhases = aggregateByPhase(projectItems, now, config);
+            const pWarnings = detectHealthIssues(pPhases, config);
+            projectBreakdowns[pn] = {
+                projectTitle: projectItems[0].projectTitle ?? `Project ${pn}`,
+                phases: pPhases,
+                health: { ok: pWarnings.length === 0, warnings: pWarnings },
+            };
+        }
+        // Cross-project health detection
+        const crossWarnings = detectCrossProjectHealth(projectBreakdowns);
+        if (crossWarnings.length > 0) {
+            warnings.push(...crossWarnings);
+            // Re-sort by severity
+            const severityRank = {
+                critical: 0,
+                warning: 1,
+                info: 2,
+            };
+            warnings.sort((a, b) => (severityRank[a.severity] ?? 99) -
+                (severityRank[b.severity] ?? 99));
+        }
+    }
     return {
         generatedAt: new Date(now).toISOString(),
         totalIssues: items.length,
@@ -284,6 +369,7 @@ export function buildDashboard(items, config = DEFAULT_HEALTH_CONFIG, now = Date
             warnings,
         },
         archive,
+        ...(projectBreakdowns ? { projectBreakdowns } : {}),
     };
 }
 // ---------------------------------------------------------------------------
@@ -352,6 +438,45 @@ export function formatMarkdown(data, issuesPerPhase = 10) {
             }
         }
     }
+    // Per-project breakdown (only for multi-project)
+    if (data.projectBreakdowns &&
+        Object.keys(data.projectBreakdowns).length > 1) {
+        lines.push("");
+        lines.push("## Per-Project Breakdown");
+        const sortedProjects = Object.entries(data.projectBreakdowns)
+            .map(([pn, bd]) => ({ projectNumber: Number(pn), ...bd }))
+            .sort((a, b) => a.projectNumber - b.projectNumber);
+        for (const project of sortedProjects) {
+            lines.push("");
+            lines.push(`### ${project.projectTitle}`);
+            lines.push("");
+            const nonZeroPhases = project.phases.filter((p) => p.count > 0);
+            if (nonZeroPhases.length > 0) {
+                lines.push("| Phase | Count |");
+                lines.push("|-------|------:|");
+                for (const phase of nonZeroPhases) {
+                    lines.push(`| ${phase.state} | ${phase.count} |`);
+                }
+            }
+            else {
+                lines.push("_No active items_");
+            }
+            lines.push("");
+            if (project.health.ok) {
+                lines.push("**Health**: All clear");
+            }
+            else {
+                for (const w of project.health.warnings) {
+                    const icon = w.severity === "critical"
+                        ? "[CRITICAL]"
+                        : w.severity === "warning"
+                            ? "[WARNING]"
+                            : "[INFO]";
+                    lines.push(`- ${icon} ${w.message}`);
+                }
+            }
+        }
+    }
     return lines.join("\n");
 }
 /**
@@ -393,6 +518,37 @@ export function formatAscii(data) {
     if (data.archive) {
         lines.push(`Archive: ${data.archive.eligibleForArchive} eligible (threshold: ${data.archive.archiveThresholdDays}d), ${data.archive.recentlyCompleted} recent`);
     }
+    // Per-project breakdown (only for multi-project)
+    if (data.projectBreakdowns &&
+        Object.keys(data.projectBreakdowns).length > 1) {
+        lines.push("");
+        lines.push("--- Per-Project ---");
+        const sortedProjects = Object.entries(data.projectBreakdowns)
+            .map(([pn, bd]) => ({ projectNumber: Number(pn), ...bd }))
+            .sort((a, b) => a.projectNumber - b.projectNumber);
+        for (const project of sortedProjects) {
+            lines.push("");
+            lines.push(project.projectTitle);
+            const nonZeroPhases = project.phases.filter((p) => p.count > 0);
+            if (nonZeroPhases.length > 0) {
+                const projMax = Math.max(1, ...nonZeroPhases.map((p) => p.count));
+                for (const phase of nonZeroPhases) {
+                    const label = phase.state.padStart(20);
+                    const barLen = Math.round((phase.count / projMax) * 20);
+                    const bar = barLen > 0 ? "\u2588".repeat(barLen) : "\u2591";
+                    lines.push(`${label} ${bar} ${phase.count}`);
+                }
+            }
+            if (project.health.ok) {
+                lines.push("  Health: OK");
+            }
+            else {
+                for (const w of project.health.warnings) {
+                    lines.push(`  ${w.severity.toUpperCase()}: ${w.message}`);
+                }
+            }
+        }
+    }
     return lines.join("\n");
 }
 //# sourceMappingURL=dashboard.js.map

package/dist/lib/helpers.js

@@ -86,8 +86,8 @@ export async function resolveIssueNodeId(client, owner, repo, number) {
 // ---------------------------------------------------------------------------
 // Helper: Resolve issue's project item ID (for field updates)
 // ---------------------------------------------------------------------------
-export async function resolveProjectItemId(client, fieldCache, owner, repo, issueNumber) {
-    const projectId = fieldCache.getProjectId();
+export async function resolveProjectItemId(client, fieldCache, owner, repo, issueNumber, projectNumber) {
+    const projectId = fieldCache.getProjectId(projectNumber);
     if (!projectId) {
         throw new Error("Field cache not populated - cannot resolve project item ID");
     }
@@ -121,18 +121,18 @@ export async function resolveProjectItemId(client, fieldCache, owner, repo, issu
 // ---------------------------------------------------------------------------
 // Helper: Update a single-select field value on a project item
 // ---------------------------------------------------------------------------
-export async function updateProjectItemField(client, fieldCache, projectItemId, fieldName, optionName) {
-    const projectId = fieldCache.getProjectId();
+export async function updateProjectItemField(client, fieldCache, projectItemId, fieldName, optionName, projectNumber) {
+    const projectId = fieldCache.getProjectId(projectNumber);
     if (!projectId) {
         throw new Error("Field cache not populated");
     }
-    const fieldId = fieldCache.getFieldId(fieldName);
+    const fieldId = fieldCache.getFieldId(fieldName, projectNumber);
     if (!fieldId) {
         throw new Error(`Field "${fieldName}" not found in project`);
     }
-    const optionId = fieldCache.resolveOptionId(fieldName, optionName);
+    const optionId = fieldCache.resolveOptionId(fieldName, optionName, projectNumber);
     if (!optionId) {
-        const validOptions = fieldCache.getOptionNames(fieldName);
+        const validOptions = fieldCache.getOptionNames(fieldName, projectNumber);
         throw new Error(`Option "${optionName}" not found for field "${fieldName}". ` +
             `Valid options: ${validOptions.join(", ")}`);
     }
@@ -150,8 +150,8 @@ export async function updateProjectItemField(client, fieldCache, projectItemId,
 // ---------------------------------------------------------------------------
 // Helper: Get current field value for an issue's project item
 // ---------------------------------------------------------------------------
-export async function getCurrentFieldValue(client, fieldCache, owner, repo, issueNumber, fieldName) {
-    const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, issueNumber);
+export async function getCurrentFieldValue(client, fieldCache, owner, repo, issueNumber, fieldName, projectNumber) {
+    const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, issueNumber, projectNumber);
     const result = await client.query(`query($itemId: ID!) {
       node(id: $itemId) {
         ... on ProjectV2Item {
@@ -286,18 +286,18 @@ export function resolveFullConfig(client, args) {
  * Sync the default Status field to match a Workflow State change.
  * Best-effort: logs warning on failure but does not throw.
  */
-export async function syncStatusField(client, fieldCache, projectItemId, workflowState) {
+export async function syncStatusField(client, fieldCache, projectItemId, workflowState, projectNumber) {
     const targetStatus = WORKFLOW_STATE_TO_STATUS[workflowState];
     if (!targetStatus)
         return;
-    const statusFieldId = fieldCache.getFieldId("Status");
+    const statusFieldId = fieldCache.getFieldId("Status", projectNumber);
     if (!statusFieldId)
         return;
-    const statusOptionId = fieldCache.resolveOptionId("Status", targetStatus);
+    const statusOptionId = fieldCache.resolveOptionId("Status", targetStatus, projectNumber);
     if (!statusOptionId)
         return;
     try {
-        await updateProjectItemField(client, fieldCache, projectItemId, "Status", targetStatus);
+        await updateProjectItemField(client, fieldCache, projectItemId, "Status", targetStatus, projectNumber);
     }
     catch {
         // Best-effort sync - don't fail the primary operation

package/dist/lib/routing-config.js

@@ -75,7 +75,7 @@ export async function loadRoutingConfig(configPath) {
  *
  * Skips disabled rules (enabled === false).
  */
-export function validateRulesLive(config, fieldCache) {
+export function validateRulesLive(config, fieldCache, projectNumber) {
     const errors = [];
     for (let i = 0; i < config.rules.length; i++) {
         const rule = config.rules[i];
@@ -84,9 +84,9 @@ export function validateRulesLive(config, fieldCache) {
             continue;
         // Validate workflowState references
         if (rule.action.workflowState) {
-            const optionId = fieldCache.resolveOptionId("Workflow State", rule.action.workflowState);
+            const optionId = fieldCache.resolveOptionId("Workflow State", rule.action.workflowState, projectNumber);
             if (optionId === undefined) {
-                const valid = fieldCache.getOptionNames("Workflow State");
+                const valid = fieldCache.getOptionNames("Workflow State", projectNumber);
                 errors.push({
                     phase: "live_validation",
                     path: ["rules", String(i), "action", "workflowState"],

package/dist/tools/batch-tools.js

@@ -181,16 +181,16 @@ export function registerBatchTools(server, client, fieldCache) {
             const { owner, repo, projectNumber, projectOwner } = resolveFullConfig(client, args);
             // Ensure field cache is populated
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
             // Validate option names up front (before any API calls)
             for (const op of args.operations) {
                 const projectFieldName = FIELD_NAME_MAP[op.field];
-                const optionId = fieldCache.resolveOptionId(projectFieldName, op.value);
+                const optionId = fieldCache.resolveOptionId(projectFieldName, op.value, projectNumber);
                 if (!optionId) {
-                    const validOptions = fieldCache.getOptionNames(projectFieldName);
+                    const validOptions = fieldCache.getOptionNames(projectFieldName, projectNumber);
                     return toolError(`Invalid value "${op.value}" for field "${op.field}". ` +
                         `Valid options: ${validOptions.join(", ")}`);
                 }
@@ -280,8 +280,8 @@ export function registerBatchTools(server, client, fieldCache) {
                     for (let opIdx = 0; opIdx < args.operations.length; opIdx++) {
                         const op = args.operations[opIdx];
                         const projectFieldName = FIELD_NAME_MAP[op.field];
-                        const fieldId = fieldCache.getFieldId(projectFieldName);
-                        const optionId = fieldCache.resolveOptionId(projectFieldName, op.value);
+                        const fieldId = fieldCache.getFieldId(projectFieldName, projectNumber);
+                        const optionId = fieldCache.resolveOptionId(projectFieldName, op.value, projectNumber);
                         updates.push({
                             alias: `u${num}_${opIdx}`,
                             itemId: issue.projectItemId,
@@ -295,9 +295,9 @@ export function registerBatchTools(server, client, fieldCache) {
                         if (op.field === "workflow_state") {
                             const targetStatus = WORKFLOW_STATE_TO_STATUS[op.value];
                             if (targetStatus) {
-                                const statusFieldId = fieldCache.getFieldId("Status");
+                                const statusFieldId = fieldCache.getFieldId("Status", projectNumber);
                                 const statusOptionId = statusFieldId
-                                    ? fieldCache.resolveOptionId("Status", targetStatus)
+                                    ? fieldCache.resolveOptionId("Status", targetStatus, projectNumber)
                                     : undefined;
                                 if (statusFieldId && statusOptionId) {
                                     updates.push({

package/dist/tools/hygiene-tools.js

@@ -61,7 +61,7 @@ export function registerHygieneTools(server, client, fieldCache) {
             }
             // Ensure field cache
             await ensureFieldCache(client, fieldCache, owner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }

package/dist/tools/issue-tools.js

@@ -122,7 +122,7 @@ export function registerIssueTools(server, client, fieldCache) {
             const { owner, repo, projectNumber, projectOwner } = resolveFullConfig(client, args);
             // Ensure field cache is populated
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
@@ -575,7 +575,7 @@ export function registerIssueTools(server, client, fieldCache) {
                 .getCache()
                 .set(`issue-node-id:${owner}/${repo}#${issue.number}`, issue.id, 30 * 60 * 1000);
             // Step 4: Add to project
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID for adding issue to project");
             }
@@ -594,13 +594,13 @@ export function registerIssueTools(server, client, fieldCache) {
                 .set(`project-item-id:${owner}/${repo}#${issue.number}`, projectItemId, 30 * 60 * 1000);
             // Step 5: Set field values
             if (args.workflowState) {
-                await updateProjectItemField(client, fieldCache, projectItemId, "Workflow State", args.workflowState);
+                await updateProjectItemField(client, fieldCache, projectItemId, "Workflow State", args.workflowState, projectNumber);
             }
             if (args.estimate) {
-                await updateProjectItemField(client, fieldCache, projectItemId, "Estimate", args.estimate);
+                await updateProjectItemField(client, fieldCache, projectItemId, "Estimate", args.estimate, projectNumber);
             }
             if (args.priority) {
-                await updateProjectItemField(client, fieldCache, projectItemId, "Priority", args.priority);
+                await updateProjectItemField(client, fieldCache, projectItemId, "Priority", args.priority, projectNumber);
             }
             return toolSuccess({
                 number: issue.number,
@@ -725,13 +725,13 @@ export function registerIssueTools(server, client, fieldCache) {
             // Ensure field cache is populated
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
             // Get current state for the response
-            const previousState = await getCurrentFieldValue(client, fieldCache, owner, repo, args.number, "Workflow State");
+            const previousState = await getCurrentFieldValue(client, fieldCache, owner, repo, args.number, "Workflow State", projectNumber);
             // Resolve project item ID
-            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number);
+            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number, projectNumber);
             // Update the field with the resolved state
-            await updateProjectItemField(client, fieldCache, projectItemId, "Workflow State", resolvedState);
+            await updateProjectItemField(client, fieldCache, projectItemId, "Workflow State", resolvedState, projectNumber);
             // Sync default Status field (best-effort, one-way)
-            await syncStatusField(client, fieldCache, projectItemId, resolvedState);
+            await syncStatusField(client, fieldCache, projectItemId, resolvedState, projectNumber);
             const result = {
                 number: args.number,
                 previousState: previousState || "(unknown)",
@@ -768,8 +768,8 @@ export function registerIssueTools(server, client, fieldCache) {
         try {
             const { owner, repo, projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number);
-            await updateProjectItemField(client, fieldCache, projectItemId, "Estimate", args.estimate);
+            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number, projectNumber);
+            await updateProjectItemField(client, fieldCache, projectItemId, "Estimate", args.estimate, projectNumber);
             return toolSuccess({
                 number: args.number,
                 estimate: args.estimate,
@@ -800,8 +800,8 @@ export function registerIssueTools(server, client, fieldCache) {
         try {
             const { owner, repo, projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number);
-            await updateProjectItemField(client, fieldCache, projectItemId, "Priority", args.priority);
+            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number, projectNumber);
+            await updateProjectItemField(client, fieldCache, projectItemId, "Priority", args.priority, projectNumber);
             return toolSuccess({
                 number: args.number,
                 priority: args.priority,
@@ -1057,7 +1057,7 @@ export function registerIssueTools(server, client, fieldCache) {
             const { owner, repo, projectNumber, projectOwner } = resolveFullConfig(client, args);
             // Ensure field cache is populated
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }

package/dist/tools/project-management-tools.js

@@ -35,11 +35,11 @@ export function registerProjectManagementTools(server, client, fieldCache) {
         try {
             const { owner, repo, projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
-            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number);
+            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number, projectNumber);
             if (args.unarchive) {
                 await client.projectMutate(`mutation($projectId: ID!, $itemId: ID!) {
               unarchiveProjectV2Item(input: {
@@ -84,11 +84,11 @@ export function registerProjectManagementTools(server, client, fieldCache) {
         try {
             const { owner, repo, projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
-            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number);
+            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number, projectNumber);
             await client.projectMutate(`mutation($projectId: ID!, $itemId: ID!) {
             deleteProjectV2Item(input: {
               projectId: $projectId,
@@ -122,7 +122,7 @@ export function registerProjectManagementTools(server, client, fieldCache) {
         try {
             const { owner, repo, projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
@@ -164,7 +164,7 @@ export function registerProjectManagementTools(server, client, fieldCache) {
         try {
             const { projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
@@ -232,17 +232,17 @@ export function registerProjectManagementTools(server, client, fieldCache) {
         try {
             const { owner, repo, projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
-            const fieldId = fieldCache.getFieldId(args.field);
+            const fieldId = fieldCache.getFieldId(args.field, projectNumber);
             if (!fieldId) {
-                const validFields = fieldCache.getFieldNames();
+                const validFields = fieldCache.getFieldNames(projectNumber);
                 return toolError(`Field "${args.field}" not found in project. ` +
                     `Valid fields: ${validFields.join(", ")}`);
             }
-            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number);
+            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number, projectNumber);
             await client.projectMutate(`mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!) {
             clearProjectV2ItemFieldValue(input: {
               projectId: $projectId,
@@ -280,7 +280,7 @@ export function registerProjectManagementTools(server, client, fieldCache) {
         try {
             const { projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
@@ -296,15 +296,15 @@ export function registerProjectManagementTools(server, client, fieldCache) {
             const projectItemId = result.addProjectV2DraftIssue.projectItem.id;
             const fieldsSet = [];
             if (args.workflowState) {
-                await updateProjectItemField(client, fieldCache, projectItemId, "Workflow State", args.workflowState);
+                await updateProjectItemField(client, fieldCache, projectItemId, "Workflow State", args.workflowState, projectNumber);
                 fieldsSet.push("Workflow State");
             }
             if (args.priority) {
-                await updateProjectItemField(client, fieldCache, projectItemId, "Priority", args.priority);
+                await updateProjectItemField(client, fieldCache, projectItemId, "Priority", args.priority, projectNumber);
                 fieldsSet.push("Priority");
             }
             if (args.estimate) {
-                await updateProjectItemField(client, fieldCache, projectItemId, "Estimate", args.estimate);
+                await updateProjectItemField(client, fieldCache, projectItemId, "Estimate", args.estimate, projectNumber);
                 fieldsSet.push("Estimate");
             }
             return toolSuccess({
@@ -375,14 +375,14 @@ export function registerProjectManagementTools(server, client, fieldCache) {
         try {
             const { owner, repo, projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
-            const itemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number);
+            const itemId = await resolveProjectItemId(client, fieldCache, owner, repo, args.number, projectNumber);
             let afterId;
             if (args.afterNumber !== undefined) {
-                afterId = await resolveProjectItemId(client, fieldCache, owner, repo, args.afterNumber);
+                afterId = await resolveProjectItemId(client, fieldCache, owner, repo, args.afterNumber, projectNumber);
             }
             await client.projectMutate(`mutation($projectId: ID!, $itemId: ID!, $afterId: ID) {
             updateProjectV2ItemPosition(input: {
@@ -457,7 +457,7 @@ export function registerProjectManagementTools(server, client, fieldCache) {
             }
             const { projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
@@ -499,13 +499,13 @@ export function registerProjectManagementTools(server, client, fieldCache) {
             }
             const { projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
-            const fieldId = fieldCache.getFieldId(args.field);
+            const fieldId = fieldCache.getFieldId(args.field, projectNumber);
             if (!fieldId) {
-                const validFields = fieldCache.getFieldNames();
+                const validFields = fieldCache.getFieldNames(projectNumber);
                 return toolError(`Field "${args.field}" not found in project. ` +
                     `Valid fields: ${validFields.join(", ")}`);
             }
@@ -562,7 +562,7 @@ export function registerProjectManagementTools(server, client, fieldCache) {
             }
             const { projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
@@ -639,7 +639,7 @@ export function registerProjectManagementTools(server, client, fieldCache) {
         try {
             const { projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
@@ -813,7 +813,7 @@ export function registerProjectManagementTools(server, client, fieldCache) {
         try {
             const { projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }
@@ -949,7 +949,7 @@ export function registerProjectManagementTools(server, client, fieldCache) {
         try {
             const { projectNumber, projectOwner } = resolveFullConfig(client, args);
             await ensureFieldCache(client, fieldCache, projectOwner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }

package/dist/tools/project-tools.js

@@ -577,7 +577,7 @@ export function registerProjectTools(server, client, fieldCache) {
             }
             // Ensure field cache is populated
             await ensureFieldCache(client, fieldCache, owner, projectNumber);
-            const projectId = fieldCache.getProjectId();
+            const projectId = fieldCache.getProjectId(projectNumber);
             if (!projectId) {
                 return toolError("Could not resolve project ID");
             }

package/dist/tools/relationship-tools.js

@@ -452,7 +452,7 @@ export function registerRelationshipTools(server, client, fieldCache) {
             for (const issueNum of issueNumbers) {
                 try {
                     // Get current workflow state
-                    const currentState = await getCurrentFieldValue(client, fieldCache, owner, repo, issueNum, "Workflow State");
+                    const currentState = await getCurrentFieldValue(client, fieldCache, owner, repo, issueNum, "Workflow State", projectNumber);
                     if (!currentState) {
                         skipped.push({
                             number: issueNum,
@@ -473,10 +473,10 @@ export function registerRelationshipTools(server, client, fieldCache) {
                         continue;
                     }
                     // Advance the issue
-                    const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, issueNum);
-                    await updateProjectItemField(client, fieldCache, projectItemId, "Workflow State", args.targetState);
+                    const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, issueNum, projectNumber);
+                    await updateProjectItemField(client, fieldCache, projectItemId, "Workflow State", args.targetState, projectNumber);
                     // Sync default Status field (best-effort, one-way)
-                    await syncStatusField(client, fieldCache, projectItemId, args.targetState);
+                    await syncStatusField(client, fieldCache, projectItemId, args.targetState, projectNumber);
                     advanced.push({
                         number: issueNum,
                         fromState: currentState,
@@ -573,7 +573,7 @@ export function registerRelationshipTools(server, client, fieldCache) {
             const childStates = [];
             let minStateIdx = Infinity;
             for (const sibling of siblings) {
-                const currentState = await getCurrentFieldValue(client, fieldCache, owner, repo, sibling.number, "Workflow State");
+                const currentState = await getCurrentFieldValue(client, fieldCache, owner, repo, sibling.number, "Workflow State", projectNumber);
                 const state = currentState || "unknown";
                 childStates.push({
                     number: sibling.number,
@@ -614,7 +614,7 @@ export function registerRelationshipTools(server, client, fieldCache) {
                 });
             }
             // Get parent's current workflow state
-            const parentState = await getCurrentFieldValue(client, fieldCache, owner, repo, parentNumber, "Workflow State");
+            const parentState = await getCurrentFieldValue(client, fieldCache, owner, repo, parentNumber, "Workflow State", projectNumber);
             // Check if parent is already at or past the target state
             const parentIdx = stateIndex(parentState || "");
             if (parentIdx >= minStateIdx) {
@@ -631,9 +631,9 @@ export function registerRelationshipTools(server, client, fieldCache) {
                 });
             }
             // Advance the parent
-            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, parentNumber);
-            await updateProjectItemField(client, fieldCache, projectItemId, "Workflow State", minState);
-            await syncStatusField(client, fieldCache, projectItemId, minState);
+            const projectItemId = await resolveProjectItemId(client, fieldCache, owner, repo, parentNumber, projectNumber);
+            await updateProjectItemField(client, fieldCache, projectItemId, "Workflow State", minState, projectNumber);
+            await syncStatusField(client, fieldCache, projectItemId, minState, projectNumber);
             return toolSuccess({
                 advanced: true,
                 parent: {

package/dist/tools/routing-tools.js

@@ -99,9 +99,9 @@ export function registerRoutingTools(server, client, fieldCache) {
                     for (let i = 0; i < config.rules.length; i++) {
                         const rule = config.rules[i];
                         if (rule.action.workflowState) {
-                            const optionId = fieldCache.resolveOptionId("Workflow State", rule.action.workflowState);
+                            const optionId = fieldCache.resolveOptionId("Workflow State", rule.action.workflowState, projectNumber);
                             if (optionId === undefined) {
-                                const valid = fieldCache.getOptionNames("Workflow State");
+                                const valid = fieldCache.getOptionNames("Workflow State", projectNumber);
                                 errors.push({
                                     ruleIndex: i,
                                     field: "action.workflowState",

package/dist/tools/view-tools.js

@@ -99,9 +99,9 @@ export function registerViewTools(server, client, fieldCache) {
             }
             // Ensure field cache is populated
             await ensureFieldCache(client, fieldCache, owner, projectNumber);
-            const fieldId = fieldCache.getFieldId(args.fieldName);
+            const fieldId = fieldCache.getFieldId(args.fieldName, projectNumber);
             if (!fieldId) {
-                return toolError(`Field "${args.fieldName}" not found. Available fields: ${fieldCache.getFieldNames().join(", ")}`);
+                return toolError(`Field "${args.fieldName}" not found. Available fields: ${fieldCache.getFieldNames(projectNumber).join(", ")}`);
             }
             const result = await client.projectMutate(`mutation($fieldId: ID!, $options: [ProjectV2SingleSelectFieldOptionInput!]!) {
             updateProjectV2Field(input: {

package/package.json

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